semvec/pypi-packages huggingface dataset:
sapphire-renderer 0.0.53
A package to easily render simple 3D scenes
Requires Python: >=3.7


# Sapphire Renderer

Sapphire Renderer is a Python package that allows you to easily render simple 3D scenes. It provides a set of classes and functions to create and manipulate 3D objects, and to render them in a window.

## Features

- **3D Object Creation**: Sapphire Renderer provides classes to create various 3D objects such as Torus, VertLineObject, etc. You can also create your own custom objects.

- **Camera Control**: The package includes a Camera class that allows you to control the viewpoint from which the scene is rendered. You can move and rotate the camera in the 3D space.

- **Object Manipulation**: You can add, remove, and update objects in the scene.

- **Rendering**: The package provides a main rendering loop that continuously updates and renders the scene.

## Installation

You can install Sapphire Renderer using pip:

```bash
pip install sapphire-renderer
```

## Basic Usage

Here is a basic example of how to use Sapphire Renderer:

```python
from sapphirerenderer import SapphireRenderer

# Create a renderer
renderer = SapphireRenderer(width=1000, height=1000, draw_axis=True)

# Add a Torus object to the scene
renderer.add_object("Torus")

# Start the rendering loop
renderer.render_loop()
```

In this example, we first create a SapphireRenderer instance. We then add a Torus object to the scene. Finally, we start the rendering loop which will continuously update and render the scene.

## Documentation

For more detailed information on how to use Sapphire Renderer, please refer to the [official documentation](https://github.com/DarkEden-coding/Sapphire-Renderer)(WIP).

## License

Sapphire Renderer is licensed under the MIT License.
RDAnalyzer 0.0.9
A small example package
Requires Python: >=3.7

# RDAnalyzer
Reactive Diffusion Analyzer (RDAnalyzer)

RDAnalyzer is a Python module for analyzing ReaxFF MD trajectory, especially the hydroxide diffusion in AEM.

Features:
- Splitting trajectory according to user's setting
- Transforming text trajectory to Atoms, Molecules, and Reactions
- Analysis based on these Atoms, Molecules, and Reactions
- Calculation of drift length of hydroxide for obtaining conductivity


## Installation
RDAnalyzer is developed on Ubuntu with python 3.11

RDAnalyzer needs `scipy`, `numpy`, `matplotlib`, `ase` and `networkx`.

You can install these modules manually, and copy RDAnalyzer in the directory that same with trajectory files.

**Or**

**Install with pip**

```pip install RDAnalyzer```

## Getting started
See `Tutorial.ipynb` for detailed usage about RDAnalyzer 

## References
- {}
gecko-soho 0.0.8
Utility lib for the Sungrazer project.
Requires Python: >=3.9

# gecko

It's a small tool for working with 'SOHO' mission images. Aims to help the "Sungrazer" comet hunting project.

<img src="test.gif" height=500 width=500/>

Currently available features:

- image data loader
```python
import datetime
from gecko.data import JPEGDataLoader


loader = JPEGDataLoader(camera='c3')  # instantiate data loader with specified camera (c2/c3)

# choose your datetime slice
start_datetime = datetime.datetime(2008, 7, 8, 7, 41, 0)
end_datetime = datetime.datetime(2008, 7, 8, 15, 45, 0)

images_paths = loader.ls_images(start_datetime, end_datetime)  # list all images available for the period
images = [loader.get_image(x) for x in images_paths]  # load them as PIL.JpegImagePlugin.JpegImageFile objects

first_image = images[0]
first_image  # when in Jupyter Notebook you'll be able to render the image just like that
```
- simplify image
```python
from gecko.transform import Simplifier

# this thing inverts colors to only white and black to keep the picture simple.
#   `level=150` this tells the handler to whit out the pixel if its 'brightness' (RGB channels) is below this level (integer, 0 < level < 255)
#   `add_pixels=<NUMBER_OF_PIXELS>` adds additional pixels around black ones so it's easier to track them with your eyes
simplifier = Simplifier(level=150, add_pixels=0)  
simplified_images = [simplifier.transform(x) for x in images]  # suppose we have `images` list of objects from the example above

first_simplified_image = simplified_images[0]
first_simplified_image  # when in Jupyter Notebook you'll be able to render the image just like that
```
- create gif
```python
from gecko.utils import create_gif

create_gif(images, 'test.gif')  # suppose we have `images` list of objects from the example above
```
- display gif
```python
from gecko.utils import display_gif

display_gif('test.gif')  # display the gif inside the Jupyter Notebook
```

Working on:
- automated search
- validator
- report generator

Contacts: artkrasnyy@gmail.com