Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/egecetin/libkaleidoscope
A library to create kaleidoscope effect on images with CUDA. You can build on all platforms using CMake
https://github.com/egecetin/libkaleidoscope
c cpp cuda image-filter image-filtering image-manipulation image-processing kaleidoscope python real-time real-time-processing video-filter video-filtering video-processing
Last synced: 3 months ago
JSON representation
A library to create kaleidoscope effect on images with CUDA. You can build on all platforms using CMake
- Host: GitHub
- URL: https://github.com/egecetin/libkaleidoscope
- Owner: egecetin
- License: mit
- Created: 2021-07-31T12:18:08.000Z (over 3 years ago)
- Default Branch: master
- Last Pushed: 2024-03-15T10:52:53.000Z (10 months ago)
- Last Synced: 2024-03-15T12:06:05.993Z (10 months ago)
- Topics: c, cpp, cuda, image-filter, image-filtering, image-manipulation, image-processing, kaleidoscope, python, real-time, real-time-processing, video-filter, video-filtering, video-processing
- Language: C
- Homepage: https://egecetin.github.io/libKaleidoscope/
- Size: 11.8 MB
- Stars: 12
- Watchers: 2
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Funding: .github/FUNDING.yml
- License: LICENSE
Awesome Lists containing this project
README
A library to create kaleidoscope effect on images. You can build on all platforms using CMake.
The library is written in C language so you can use Foreign Function Interface (FFI) to call functions from your favorite programming language. You can download from python package from PyPI. It also has C++ header only library to provide easier interface for C++ users and CUDA support for people who have doubts about performance. Check for mathematical explanation of the kaleidoscope effect from my [webpage](https://egecetin.github.io/Projects/kaleidoscope)
## Supported Languages
- C : Main programming language
- C++ : Header only binding for easier usage
- Python : Bindings using Cython
- CUDA : For GPU computing
## Install for Python
```
pip install LibKaleidoscope
```
Python users check python/python-test.py in GitHub for basic usage
## Building
Use the following commands,
```
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Release ..
cmake --build . --parallel
```
If you want to enable CUDA backend,
```
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Release -DKALEIDOSCOPE_ENABLE_CUDA=ON ..
cmake --build . --parallel
```
There is no direct dependency for libjpeg-turbo inside from the library. It is just for test and demonstration purposes. If you don't want to install/compile just disable command line tool compilation with ``-DKALEIDOSCOPE_ENABLE_CMD_TOOL=OFF``
## Usage
The library has a simple usage and you need only three functions to use it. Check the sample usage at ``src/kaleidoscope-cmd.c``
- Initialization of the transformation matrix: ``int initKaleidoscope(KaleidoscopeHandle *handler, int n, int width, int height, double scaleDown)``
- Processing image (Can be used multiple times if the input images have same dimensions): ``void processKaleidoscope(KaleidoscopeHandle *handler, double k, unsigned char *imgIn, unsigned char *imgOut)``
- Deinitialization of the transformation matrix: ``void deInitKaleidoscope(KaleidoscopeHandle *handler)``
Alternatively you can directly use the command line program to create kaleidoscope effect with ``./kaleidoscope-cmd ``. You can see an example below for ``N=8``
Image source: AC Valhalla
For C++ and CUDA usage check the unit tests at ``tests/processingTest.cpp`` and ``tests/processingTest.cu``. It is very easy! Just include the header and construct the ``Kaleidoscope`` class from ``kalos`` namespace.
- For C++ header only binding,
```
#include
int main()
{
kalos::Kaleidoscope handler(n, width, height, nComponents, scaleDown, k);
/* ... */
handler.processImage(inData, outData, nPixel);
/* ... */
return 0;
}
```
- For CUDA backend,
```
#include
int main()
{
kalos::cuda::Kaleidoscope handler(n, width, height, nComponents, scaleDown, k);
/* ... */
// Make sure inData and outData is device allocated!
handler.processImage(inData, outData, nPixel);
/* ... */
return 0;
}
```
## Benchmark
It is really fast! On a Intel i7-11800H CPU it achieves,
- ~65 FPS for 4K UHD (3840 x 2160)
- ~265 FPS for Full HD (1920 x 1080)
- ~640 FPS for 720p (1280 x 720)
- ~1350 FPS for 576p (720 x 576)
resolution images. The performance estimation can be seen at the below
$$ FPS = a\text{ }e^{b\text{ }nPixels}+c\text{ }e^{d\text{ }nPixels} $$
$$ a = 2492 \text{, } b = -2.165\text{ }10^{-6} \text{, } c = 364.9 \text{, } d = -2.08\text{ }10^{-7} $$
If you want to benchmark code on your system make sure you configured with ```-DCMAKE_BUILD_TYPE=Release``` and use this command,
```./kaleidoscope-cmd ```