Metadata-Version: 2.1
Name: pyclesperanto_prototype
Version: 0.4.0
Summary: OpenCL based GPU-accelerated image processing (an early prototype)
Home-page: https://github.com/clEsperanto/pyclesperanto_prototype
Author: haesleinhuepf
Author-email: rhaase@mpi-cbg.de
License: UNKNOWN
Description: # pyclesperanto
        pyclesperanto is a prototype for [clEsperanto](http://clesperanto.net) - a multi-platform multi-language framework for GPU-accelerated image processing. 
        It uses [OpenCL kernels](https://github.com/clEsperanto/clij-opencl-kernels/tree/development/src/main/java/net/haesleinhuepf/clij/kernels) from [CLIJ](http://clij.github.io/)
        
        Right now, this is very preliminary.
        
        ## Installation
        * Get a python environment, e.g. via [mini-conda](https://docs.conda.io/en/latest/miniconda.html)
        * Install [pyopencl](https://documen.tician.de/pyopencl/).
        
        If installation of pyopencl for Windows fails, consider downloading a precompiled wheel (e.g. from [here](https://www.lfd.uci.edu/~gohlke/pythonlibs/#pyopencl) ) and installing it manually:
        
        ```
        pip install pyopencl-2019.1.1+cl12-cp37-cp37m-win_amd64.whl
        ```
        
        Afterwards, install pyclesperanto:
        
        ```
        pip install pyclesperanto-prototype
        ```
        
        ### Troubleshooting installation
        If you receive an error like 
        ```
        DLL load failed: The specified procedure could not be found.
        ```
        Try downloading and installing a pyopencl with a lower cl version, e.g. cl12 : pyopencl-2020.1+cl12-cp37-cp37m-win_amd64
        
        ## Example code
        A basic image procressing workflow loads blobs.gif and counts the number of gold particles:
        
        ```python
        import pyclesperanto_prototype as cle
        
        from skimage.io import imread, imsave
        
        # initialize GPU
        cle.select_device("GTX")
        print("Used GPU: " + cle.get_device().name)
        
        # load data
        image = imread('https://imagej.nih.gov/ij/images/blobs.gif')
        print("Loaded image size: " + str(image.shape))
        
        # push image to GPU memory
        input = cle.push(image)
        print("Image size in GPU: " + str(input.shape))
        
        # process the image
        inverted = cle.subtract_image_from_scalar(image, scalar=255)
        blurred = cle.gaussian_blur(inverted, sigma_x=1, sigma_y=1)
        binary = cle.threshold_otsu(blurred)
        labeled = cle.connected_components_labeling_box(binary)
        
        # The maxmium intensity in a label image corresponds to the number of objects
        num_labels = cle.maximum_of_all_pixels(labeled)
        
        # print out result
        print("Num objects in the image: " + str(num_labels))
        
        # for debugging: print out image
        print(labeled)
        
        # for debugging: save image to disc
        imsave("result.tif", cle.pull(labeled))
        ```
        
        More examples can be found in the `/demo/` directory.
        
        
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: BSD License
Classifier: Operating System :: OS Independent
Requires-Python: >=3.6
Description-Content-Type: text/markdown
