semvec/pypi-packages huggingface dataset:
feature-based-registration-BioinfoTongLI 2.0.1
Feature-spot-based image registration for fluorescence microscopy images
Requires Python: >=3.0.*
Keywords: microscope registration DAPI fluorescence microscopy slide-imaging

[![DOI](https://zenodo.org/badge/405296414.svg)](https://zenodo.org/badge/latestdoi/405296414)
# Feature based image registrator

The image registrator uses `FAST` feature finder and `DAISY` feature descriptor for registration. 
It can align images of different size by padding them with 0 values. 
The image registrator can work with multichannel grayscale TIFFs and TIFFs with multiple z-planes. 
Images **MUST** have OME-TIFF XML in their description.
The script does linear image registration. To avoid excessive memory consumption it extracts features from tiles instead of a whole image. 

## Command line arguments

**`-i`**    paths to images you want to register separated by space.

**`-r`**    reference image id, e.g. if `-i 1.tif 2.tif 3.tif`, and you ref image is `1.tif`, then `-r 0` (starting from 0)

**`-c`**    reference channel name, e.g. DAPI. Enclose in double quotes if name consist of several words e.g. "Atto 490LS".

**`-o`**    directory to output registered image.

**`-n`**    multiprocessing: number of processes, default 1

**`--tile_size`**  size of a side of a square tile used for registration, e.g. --tile_size 1000 = tile with dims 1000x1000px

**`--num_pyr_lvl`**  number of pyramid levels. Default 3, 0 - will not use pyramids

**`--num_iter`**  number of registration iterations per pyramid level. Default 3, cannot be less than 1

**`--stack`**  add this flag if input is image stack instead of image list

**`--estimate_only`**   add this flag if you want to get only registration parameters and do not want to process images.

**`--load_param`**  specify path to csv file with registration parameters


## Example usage

`python reg.py -i "/path/to/image1/img1.tif" "/path/to/image2/img2.tif" -o  "/path/to/output/directory" -r 0 -c "Atto 490LS" -n 3`

## Dependencies

`numpy pandas tifffile opencv-contrib-python scikit-learn scikit-image`

`scikit-image` is necessary for affine transformation of big images that has more than 32000 pixels in one or two dimensions. 
The affine registration process in `scikit-image` requires usage of `float64` data, so you need amount of RAM at least 3 times the size of the picture (channel, z-plane).
optical-flow-registration-BioinfoTongLI 1.0.0
Optical-flow-based image registration for fluorescence microscopy images
Requires Python: >=3.0.*
Keywords: microscope registration DAPI fluorescence microscopy slide-imaging

[![DOI](https://zenodo.org/badge/405296622.svg)](https://zenodo.org/badge/latestdoi/405296622)
## Optical flow based registration for immunofluorescence images

These scripts perform fine registration using warping. 
A map for warping is calculated using Farneback optical flow algorithm, by OpenCV.
Although images are MINMAX normalized during processing, optical flow algorithms expect images to have 
similar pixel intensities. 

Currently does not support z-stacks.

### Command line arguments

**`-i`**  path to image stack

**`-c`**  name of reference channel

**`-o`**  output directory

**`-n`**  multiprocessing: number of processes, default 1

####Optional

**`--tile_size`**  size of a square tile, default 1000, which corresponds to 1000x1000px tile

**`--overlap`**  overlap between tiles, default 100

**`--method`**  optical flow method: farneback, denselk, deepflow, rlof, pcaflow, default rlof

### Example usage

**`python opt_flow_reg.py -i /path/to/iamge/stack/out.tif -c "DAPI" -o /path/to/output/dir/ -n 3`**


### Dependencies
`numpy tifffile opencv-contrib-python dask`
supergsl 0.10.0
A python implementation of the Genome Specification Language (GSL) for genetic engineering.
Requires Python: >=3.7

# *SuperGSL*

*SuperGSL* is a python implementation of the Genome Specification Language (GSL) for genetic engineering. *SuperGSL* is very **alpha** so it's probably a bad idea to rely on it for, well, anything.

SuperGSL is inspired by the original Genome Specification Language (See: [Paper](https://pubs.acs.org/doi/abs/10.1021/acssynbio.5b00194) & [Code](https://github.com/Amyris/GslCore)) written by Erin Wilson, Darren Platt and many others at Amyris.

[![Documentation Status](https://readthedocs.org/projects/supergsl/badge/?version=latest)](https://supergsl.readthedocs.io/en/latest/?badge=latest)
![SuperGSL Tests](https://github.com/rmcl/supergsl/workflows/SuperGSL%20Tests/badge.svg)
[![codecov](https://codecov.io/gh/rmcl/supergsl/branch/master/graph/badge.svg?token=LANIO2RFVI)](https://codecov.io/gh/rmcl/supergsl)
[![PyPI version](https://badge.fury.io/py/supergsl.svg)](https://badge.fury.io/py/supergsl)

### New Features in SuperGSL

See how SuperGSL differs from the original GSL [here](https://supergsl.readthedocs.io/en/latest/gsl_vs_supergsl.html).

### Install *SuperGSL*

SuperGSL can be installed using the python package manager.

```
pip install supergsl
```

This will add two commands into your environment- `sgsl` and `sgsl-util`. These two commands can used to invoke the compiler and utility commands respectively.


### Install & Running *SuperGSL* with Docker

*SuperGSL* comes with a Dockerfile and docker-compose file such that you can run superGSL without polluting your local environment.

Using docker you can do the following:

#### Run the tests

To run tests and mypy type validations:

```
docker-compose run supergsl test
```

#### Run the Compiler

To start the REPL shell:

```
docker-compose run supergsl
```

To run the compiler with source input file:
```
docker-compose run supergsl sgsl <input-file>
```
mfg 1.0.0
Display a message on foreground
Requires Python: >=3.6

# Message Foreground

[![License](https://img.shields.io/badge/License-MIT-blue)](#license)

This library allows you to create a message that is displayed in the foreground and above all other elements.


Simple Demo
-----------
```python
# Import the library
from mfg import foreground

# First create a instance with the following parameters
# 	Text: 'Hello World'
# 	Color: White
# 	No background
f = foreground('Hello World', '#fffffe')

# Displayed the message
f.display()
```


Requirement
---------------
- `tkinter`
- `win32api`
- `win32con`
- `threading`
- `pywintypes`


Development
-----------

This library can be improved and if you want to be part of it, contact me.
genalgopy 1.0.0
This package implements various classes and functions for genetic algorithms
Requires Python: >=3.6
Keywords: genetic algorithm,evolution

# Genetic Algorithm

This is a pure Python implementation for a genetic algorithm. It has precreated classes and functions for using this algorithm.

The genetic module is compossed of a Individual and GeneticAlgorithm class. 
````Python
from genetic_algorithm.genetic import GeneticAlgorithm, Individual
from genetic_algorithm.chooser import DefaultChooser
from genetic_algorithm.rules import single_crossover, SimpleMutator

def get_pop() -> list[Individual]:
    ...

def fitness(indivdual: Individual) -> float: # or int
    ...

ga = GeneticAlgorithm(get_pop(), DefaultChooser(), single_crossover, SimpleMutator(), tracker=..., n_keep=..., n_mutated_keeped=...)
ga.train(iterations=10, fitness)
# or use ga.evololution(fitness, do_sort) where fitness is a list of tuples of a number representing a score and an Individual
# if the list isn't sorted already, pass True for do_sort 
````

When creating your population, you should give the Individuals a list of values, a ``keras.Model``, a ``keras.Sequential`` or a ``NN`` object, as well as a id.  
The ``NN`` object can be created with the simple_nn modul. You will need tenserflow for for ``keras.Model`` and ``keras.Sequential``.