This file describes CLIPT. It's a simple image processing toolkit with GPU computation in mind.

This project aims to be a simple appliation with various implementations of image processing algorithms implemented mainly on GPU in one place. It's GUI is made with GTK3, with image rendering through OpenGL and operations in OpenCL (more on that later).

This project was started by Miłosz Kosobucki and Michał Siejak as a programming assignment for Image processing class that took place in winter semester in 2011/2012 acadaemic year at Adam Mickiewicz University of Poznań under supervision of Mr Wojciech Kowalewski Ph.D..

As mentioned before:

• Miłosz Kosobucki - implemented OpenGL context in GTK, most of gui, plugin api implementation, file loading plugin api, ppm loading/saving plugin, all operations except convolutions.
• Michał Siejak - designed and implemented OpenCL/OpenGL buffer sharing system, plugin api, main program structure (subsystem initialization, configuration handling, main loop), convolutions, OpenCL context.

Program looks for .cliptrc.ini in folder specified in XDG_CONFIG_HOME. If this variable doesn't exist, program tries to find it in current directory.

If it's still not found, following values are assumed:

plugin-dir=/usr/lib/clipt
clprog-dir=/usr/lib/clipt/cl

plugin-dir should point to a directory with clipt plugins

clprog-dir should point to a directory with OpenCL kernels

.cliptrc.ini is a simple .ini file with variables defined in [clipt] category:

[clipt]
plugin-dir=/usr/lib/clipt
clprog-dir=/usr/lib/clipt/cl

User interface is implemented using GTK+3. However, the canvas on which the images are drawn is an OpenGL window. Since GTK3 doesn't have any support for embedding OpenGL, it's done by a nasty hack, that takes native X11 window handler and tries to establish GLX context in that window.

UI routines are place in ui/ subfolders of include/ and src/ directories.

Most algorithms are implemented using OpenCL. Kernel files are read and compiled on runtime. Directory path for kernels is specified by configuration file (more on that later).

To avoid sending big images back and forth through PCI Express bus this project uses buffer sharing between OpenCL and OpenGL introduced in OpenCL 1.1.

Internal image format is 32 bits per channel RGB stored as floats. This fact establishes 1GB of VRAM as a reasonable minimum when working with large (4k x 4k) images, since two copies of the image must be stored in GPU memory.

When user previews some filter/operation and adjusts parameters in real time, the data is not leaving the GPU. This makes interaction with program more smooth. Only when the user hits Apply on some effect window, the result of the GPU computation is sent to RAM.

Interoperability routines and buffer sharing mechanisms are implemented in device.c and render.c.

CLIPT implements rather crude plugin mechanism. It tries to load dynamic libraries from specified folder and initialize them.

Plugin API currently works only for file loading/saving plugins and is used by Portable Anymap file plugin.

On GPU:

• simple curve manipulation (brigtness, gamma, contrast)
• histogram (showing, stretching, equalization)
• mathematical morphology
• convolution (custom and some predefined masks)
• Thresholding
• Otsu binarization

• Portable Anymap - reading and writing. Both ASCII and raw version of PPM are supported