# [Gimp-developer] GsoC - 2011 - Porting GIMP plugins to GEGL operations

```My background:
I am a 1st year student of the department of Computer Science and
Engineering at Polytehnical University of Bucharest. I have started to use
GIMP 2 years ago. I wrote emboss, blur and sharpen tools in C and then in
Octave. I wrote a program which converts images from Targa(for RGB images
with colour map or without) to PPM(type 3) and back.```
```
I would also suggest to generalize the emboss plug-in by using some
operators such as: Sobel, Robert Cross, Prewitt, Scharr or Costella. In case
of Sobel operator we can set 3 types of normalizing (gradient x,y or
magnitude) all 3 making some new effects.

Code review and algorithm description (GIMP plug-ins):

1. Cubism
Function cubism: Initializes the values of alpha and image type, and fills
the image with the background colour, which we get from the drawable
image(current image). After calculating the number of tiles of the asked
rectangle the function randoms the indices and initiates the first
rectangle. For each tile the starting point (x,y),height and with is
randomed between certain limits, depending on the tile saturation and tile
size set by the user. The rotation grad is also randomed. Then for each
polygon it adds the calculated points to the structure for creating the
double perspective, rotates and translates it by adding the starting
points(x,y). It checks if the calculated point is between minimum and
maximum and gets the closest value (CLAMP), and gets the pixel color from
the source. Finally it fills with color the drawable image in the pixels
within the polygon.
fill_poly_color: The colour of a pixel will be calculated by looking at the
backgroung image and the intersection of the polygons.
Firstly calculates the distance between the 2 points of the polygon and
initiates values of vector. By polygon_extent we get the minimum and maximum
position of the pixels. It initiates the the values of the lines which need
to be scanned and for every 2 points in the polynom it calculates the
minimum and maximum of the segment.
For every pixel in the polygon it calculates the colour which will be equal
with the color from the source image which is in the position (x,y). x is
equal with ((size_x-1)/4+min_x. In vals the function keeps if that row was
reached or not. The alpha value of the pixel color is between 0.1 and 0.2,
caculated by the distance between the points in the polygon. Every value we
get from buf which will be equal with the color of the coloumn plus the
color from the position (x,y).

2. Fractal trace
Initialization: source pixel table(guchar **) gets the color values of the
current picture for every column. Destination pixel table gets allocated
memory.
Pixel get: In function of the image type the asked pixel gets the values
from source pixel table for RGBA.
Pixel set: The color of a certain (position c,y) is uploaded to destination
pixel table considering also the image type.
Pixel get biliner: Calculates the values of the colors for the asked pixel,
making median of its neighbour. The alpha value is accumulated, for the
other values after accumulating the color*alpha it divides with the
acumulated alpha.
Mandelbrot: While the iteration number is smaller then it calculates the
position of the pixels with the quadratic polynomial. The new pixel position
will be the values calculated on the last iteration.
Filter: For each pixel in the given rectangle the function calculates its
colour value. First it calculates a position of the asked pixel by the
parameters, then iterates it with the mandelbrot function. If the iterated
pixel position is in within the image then its color value is calculated.
Else if the position escaped to infinite then in function of the Outside
type it calculates its value. In case of WRAP the color of the pixel will be
equal with the pixel being at the position (px-px/width,py-py/height).
At last it saves the value of the color in destination pixel table.

It is written almost the same thing for the dialog-preview, the setpixel
function is differing because it considers every picture to be type RGBA.
Possible optimization:
If the given point lies within the cardioid or in the period-2 buld we can
calculate its color without appealing the mandelbrot function, without
iterating, because it will never escape to infinite. Just have to verify
that: q(q+(x-1/4))<1/4*y^2, where q=(x-1/4)^2+y^2.
Moreover the periodicity checking could also be implemented by using a
little more memory. If by iterating a pixel, that pixel reaches another
pixel which was calculated(iterated) before we know its colour.

3. Plasma
The scientific name would be random midpoint displacemant. For a given
rectangle the function divides it in 4 smaller one calculating the values of
each pixel by median.
Plasma: After initialization and random if the asked rectangle is not a
single pixel then it puts a seed pixel in the corners and in the center.
After that, while the size of the rectangle is not 1 it recurse through the
pixels going in further depths.
do_plasma: Calculates the mid-point of the rectangle and in case of depht=-1
(first case) randoms the color values for the corners and the middle of the
image.
If depth is 0 (in case the rectangle has less then 4 pixels) for every case
we get the pixel values from the current image, average it and adds a new
random value for each alpha.
Else it calls the function recursively for the 4 divided rectangles.

This can also be written using for example a perlin noise function and
calculating for each component of c sin(f(x,y)*frequency(c)).

Code review and algorithm descrition(GEGL op):

1. Gaussian-blur:
Algorithm: After calculating the Gaussian matrix with the known function for
a certain radius, we ortonormalize it by dividen each element with the sum
of all elements. Then apply this to the image and calculating the value of
each pixel with weighted median.
Using Gaussian linearly separable property we can divide the process into 2
passes. First a vector is used to blur the image in horizontal or vertical
direction, then another vector is used to blur the image for the remaining
direction.
Area Filter base class is used because the color value of every pixel is
calculated with the help of the surrounding pixels (from the pixels of a
certain area).

fir_gen_convolve_matrix calculates the Gaussian matrix for a certain
radius, and depending on the offset (x or y) fir_ver_blur or fir_hor_blur
calculates the value of each color byte for each color with weighted median.
iir_young_hor_blur (or ver) calculates the values of each new pixel by
calculating for each row (column) its new values. The colour vector blur
stores the calculated color values off the pixels, calculated by weighted
media (vector b is the weight of a color, buf stores the original color of
the pixel).

If there is some problem with code review or anything else please write it
and I will correct it.

Thanks,
Robert Sasu
```
```_______________________________________________
Gimp-developer mailing list
Gimp-developer@lists.XCF.Berkeley.EDU
https://lists.XCF.Berkeley.EDU/mailman/listinfo/gimp-developer
```