semvec/pypi-packages huggingface dataset:
flippy 0.1.2
Build videos from image directories
License: MIT
Keywords: opencv video flipbook overlay python3 timelapse lapse flip flipy

# flippy
Python script for generating videos by rapidly flipping through or overlaying images.

![Preview Example](https://i.imgur.com/LLKZpr5.gif)

## Installation
`pip install flippy`

This will automatically download and install `flippy`, `opencv-python`, and `numpy`.


## Usage

```
flippy /some/image/path
```

This will build a video out of the images in the directory `/some/image/path`, using the auto-detected resolution at the default 20 FPS.

Flippy is heavily configurable, and accepts a number of command line arguments.

```
flippy /some/image/path -o ~/output.avi -f 60.0 -c XVID -t blend

INFO:root:Auto-detected image dimensions as 64x64...
INFO:root:Building fading timelapse of 24247 images in /some/path/faces...
INFO:root:Output settings: 64x64 @ 60.0 FPS
INFO:root:Successfully wrote /home/user/output.avi
```

For the full list of availble arguments, type `flippy --help`.
```
usage: flippy [-h] [-v] [-f FPS] [-o OUTPUT] [-c CODEC] [-t TYPE] [-r REGEX]
                path [path ...]

Build a fading timelapse of overlayed images.

positional arguments:
  path                  path to read image files from

optional arguments:
  -h, --help            show this help message and exit
  -v, --verbose         verbose logging
  -f FPS, --fps FPS     frames per second
  -o OUTPUT, --output OUTPUT
                        output file
  -c CODEC, --codec CODEC
                        fourcc codec (DIVX, XVID, MJPG, X264, WMV1, WMV2)
  -t TYPE, --type TYPE  type of video (blend, flipbook, split)
  -r REGEX, --regex REGEX
                        file regex for images in path, default matches common
                        lowercase image extensions
```

## Requirements
* [OpenCV](https://opencv.org/)
* [numpy](http://www.numpy.org/)
BriCA1 1.0.0.dev0
Brain-inspired Computing Architecture Version 1
License: MIT
Requires Python: >=2.7.0

# BriCA V1

wbap/V1 repository contains a python implementation for BriCA V1

## Reference:
* [Tutorial](http://wbap.github.io/BriCA1/)
* [Wiki](http://wba-initiative.org/wiki/en/brica)

## Support:
If you have any question, please send us message on Google Group:  
https://groups.google.com/d/forum/wbai-dev
neurosynchro 0.1.4
Use neural networks to approximate polarized synchrotron radiative transfer coefficients
License: MIT
Keywords: neural-networks radiative-transfer science

*Neurosynchro* is a small Python package for creating and using neural
networks to quickly approximate the coefficients needed for fully-polarized
synchrotron radiative transfer. It builds on the `Keras <https://keras.io/>`_
deep learning library. Documentation may be found `on ReadTheDocs
<https://neurosynchro.readthedocs.io/en/stable/>`_.

Say that you have a code — such as `Rimphony
<https://github.com/pkgw/rimphony/>`_ or `Symphony
<https://github.com/AFD-Illinois/symphony>`_ — that calculates synchrotron
radiative transfer coefficients as a function of some input model parameters
(electron temperature, particle energy index, etc.). These calculations are
often accurate but slow. With *neurosynchro*, you can train a neural network
that will quickly approximate these calculations with good accuracy. The
achievable level of accuracy will depend on the particulars of your target
distribution function, range of input parameters, and so on.

This code is specific to synchrotron radiation because it makes certain
assumptions about how the coefficients scale with input parameters such as the
observing frequency.