Dear Sir,

I am Ravi Bhushan final year student at LNM IIT(The LNM Institute Of
Information Technology). I have strong background in C Programming and
User-interface Programming(Like GTk+).
My area of interest is* Image Processing* and Computer Vision and Pattern
Recognition which was the core subjects in my curriculam during B.Tech. I
have already worked on some of the open-source software likes *Greenstone DL
* and *Moodle*. I have customized Moodle server and Greenstone DL for my
institute and Currently, it is extensively used in my Institute's Digital
Library.

I am eager to implement  the project entitled "Porting GIMP Plugin to GEGL
Operation". As per the pre-requisite, I am sending the code-reviews :-


*Plasma*

Including libgimp/gimp.h avails all the basic plugins of GIMP to this
program.

Global Variables :

SCALE_WIDTH = 48
TILE_CACHE_SIZE= 32

Defined Structures :

 PlasmaValues- Holds values of seed, turbulence and random_seed which is the
input values given to this program by user.

Defined local variables :
1. pvals - It is the default plasma value if user doesn't change the value
through dialog box.
2.GimpPlugInInfo PLUG_IN_INFO : It contains 4 pointers
   init - initialise the process (Optional)
   quit - quit the procedure (Optional)
   query- It is called when a new plugin comes into existence or there is
some modification in the existing plugin.
   run - It is the main function by which plugin works. It takes plugin
name, input parameters, number of return values, pointer to output
parameters as input.

MAIN() - program execution starts from here.

Functions :

1. query() : Defines the input argument. It takes seed, turbulence and image
as input.
             It registers the plugin under Image/FIlters/Render/Clouds.

2. run()   : If there is no GIMP_PDB_CALLING_ERROR, it calls plasma function
to operate on Image.

3. plasma_dialog() : when user clicks on Image/Filters/Render/Clouds/Plasma,
it gives a dialog box to take input from users. It ask users to change the
values of seed and turbulence. If user doesn't change these values, it will
take default values of parameters defined by pvals.

User can change the parameters any number of  times and see the preview. On
clicking the OK button, GTK_RESPONSE_OK signal is released.It will check
whether the drawable is rgb or indexed,final images will be produced by
calling plasma() function. After that the dialog_box will be destroyed.

4. init_plasma(GimpDrawable *drawable,gboolean preview_mode,GRand *gr))

   if preview-mode is true, it will start the image at (0,0) and will set
the width and height of the preview and preview_buffer=
image_width*image_height*bpp. If preview_mode is false, it will set the
mask_bound from ix1 to ix2 and iy1 to iy2. Finally it will return a pointer
*pft ehich will point to the drawable first pixel.

5. plasma(GimpDrawable *drawable, gboolean preview_mode) :

   It initialise the pixel by calling init_plasma function.For the first
iteration, it puts the seed pixels each corners,middle of each edge and
center of the pixel. Then, it continues to go in depth by calling do_plasma
function till we get a point. After getting a point, we put the randomised
pixel value at that position and then, we call end_plasma() function.

6. do_plasma() :

 It calculates the centre of rectangle.For depth=-1, it calculates the
random values of color for the pixels located at
top-left,top-right,bottom-left,bottom-right,middle-left,middle-right,middle-top,middle-bottom
and center of the rectangle and then return FALSE.

 For depth=0, it gets pixels for all the corner point and pixel information
in guchar tl,tr,bl,br array. The variable ran = (gint) ((256.0 / (2.0 *
scale_depth)) * pvals.turbulence) gives a random value to add to the result.

 After that, we divide the rectangular region in four parts and we analyse
every every parts individually. For the left region, average the values,
add_random values and put_pixel(Putting pixel values at the specified
position) in the position. Same task we do for other regions also.

For depth not equal to 0 or -1, it calls the function do_plasma()
recursively(for each region of the rectangle) to go in further depth.It
reduces the values of depth on every call and finally depth becomes equal to
0.

*Fractal-Trace*


Including libgimp/gimp.h avails all the basic plugins of GIMP to this
program.

Here we have four types of mandelbrot fractal which is chosen by user by
deciding the value OUTSIDE_TYPE_WRAP(0),  OUTSIDE_TYPE_TRANSPARENT(1),
OUTSIDE_TYPE_BLACK(2),  OUTSIDE_TYPE_WHITE(3).

Defined Structures :

1.  parameter_t : holds the input values of mandelbrot fractal chosen by
user.
                  x1 : Distance from left.
                  x2 : Distance from right.
                  y1 : Distance from top.
                  y2 : Distance from bottom
                  depth :decides number of iteration.
                  outside_type : defines type of mandelbrot fractal

2. selection_t : holds the user input x1, y1, x2, y2 and width, height,
center_x, center_y of selection chosen by user.

3. image_t : holds info about the image(width, height, alpha,bytes per
pixel).

4. pixel_t  : holds the colour info for each pixel including the RGB value
along with alpha(If there exists alpha channel).

Globally Defined Variable :

PREVIEW_SIZE 200

Defined Local Variable :

1. GimpPlugInInfo PLUG_IN_INFO : It contains 4 pointers.
   init - initialise the process (Optional)
   quit - quit the procedure (Optional)
   query- It is called when a new plugin comes into existence or there is
some modification in the existing plugin.
   run - It is the main function by which plugin works. It takes plugin
name, input parameters, number of return values, pointer to output
parameters as input.

2. parameters : Default value of parameters x1,x2,y1,y2 , depth and
outside_type after opening dialog_box.

3. selection
4. image
5. preview

Functions :

1. query() : Defines the input argument. It takes x1,x2,y1,y2,depth and
outside_type as input.
             It registers the plugin under Image/FIlters/Map.

2. run() : First of all, it initialise the drawable parameter like width ,
height ,bpp, alpha,selection_width, selection_height,center_x,center_y.After
that, we intialises the pixels by calling pixel_init() function. Run()
function will check for the  GIMP_PDB_EXECUTION_ERROR(if any) due to the
wrong format of image. It will take actions according to the values of
run-mode. If it is interactive, it will provide a dialog_box to the users
and if it is non-interactive, it will check for the proper number of
arguments and if it is less, it will give execution error.We can also run
the program with the last_values of parameters.

3. pixels_init (GimpDrawable *drawable) : Initialises the pixel region
pointed by *sPr and *dpr.  starting point would be (0,0), width and height
would be image->width, image->height and the region pointed by sPr will be
used to read the actual drawable datas and region pointed by dPr will be
used to write the data.

 We also initilises two memory location sPixels[y] and dPixels[y] which will
store pixels colouring information of a row for a particular height(y).

4. pixel_free() : It is used to free the memory location occupied bt sPixels
and dPixels array.

5. pixels_get (gint x,gint y,pixel_t *pixel) :
      It initialises the pixels colouring information according the type of
image(RGB, RGB+A,GRAY, GRAY+A) and stores into Pixel->r,g,b,a variable
defined in pixel_t structure.

6. pixels_get_biliner (gdouble x,gdouble y,pixel_t *pixel) : For a
particular pixel, we calculates x1 = floor(x) and x2 = x1+1(Here x1 and x2
are the x-position of the neighbouring pixel of pixel located at (x,y)).

Also, we calculate y1=floor(y) and y2=y1+1 and then it gets the pixel color
information for these pixels-  (x1,y1),(x1,y2),(x2,y1)(x2,y2).These 4 pixels
will be neighbouring pixels of the (x,y) pixel.

Then, we calculate the aggregate alpha value by formula mentioned below

alpha = 1.0001*(a * (gdouble) A.a + b * (gdouble) B.a + c * (gdouble) C.a +
d * (gdouble) D.a);

and if this aggregate alpha value for the pixel(x,y) is not zero then we
redefine the RGB values of that particular pixel.

7. pixels_set (gint x, gint y, pixel_t *pixel ) : It sets value for the
destination pixel using dPixels[y] array according to the bpp for the source
image.

8. pixels_store (void) : It sets the pixels pointed by dPr by values of
dpixel[y]. It draws pixels from values (0,y) to (0+width-1,y) and we do this
for evey y.

9. mandelbrot (gdouble  x, gdouble  y, gdouble *u, gdouble *v) :  It
initialises local variables xx = x, yy = y.And then on every iteration yy =
2*xx*yy + y and xx = x^2 - y^2 + x and updated x^2 = xx and y^2 = yy  after
every iteration. After every itration we increase iter by 1 and we continue
this iteration till iter is less than the depth parameter. This function
would return the final values of *u and *v and it will be stored as px and
py in the calling function.

10. filter( GimpDrawable *drawable ) :
(a) calculate the scale_x and scale_y parameters.
(b) We traverse the drawable row wise  and calculate px, py from mandelbrot
function. If the returned values lie between the image bounds i.e 0 <= px <=
width and 0 <= py <= height then apply pixel_biliner to calculate
corresponding color and alpha value which would be stored in pixel->r,g,b,a
variable defined under structure pixel_t.
(c) Else, if values of px and py doesn't lies in the image bound, it makes
use of enum variable.

In case of enum= OUTSIDE_TYPE_WRAP : if( px < 0 ) px = px + image.width and
similarly for height and then use pixel_biliner() to get pixel color of the
pixel located by (px,py) which is now in the image bound.
In case of OUTSIDE_TYPE_TRANSPARENT : r = g = b = a = 0;
In case of OUTSIDE_BLACK : r = g = b = 0, a = 255
In case of OUTSIDE_TYPE_WHITE : r = g = b = a = 255


gimp_progress_update() shows the progress bar labelled by "Fractal Trace" as
the image is being mapped to destination .The progress bar is calculated
with the help of selection width and height. Finally the shadow tiles are
merged and the drawable image is updated.

11. dialog_show() -
It sets up the dialog box and give a previlege to users to set  parameters
for the mandelbrot fractal.There are radio buttons including - Wrap,
Transparent,Black, White for the outside type.
The values of these radio-buttons is stored in enum variable, which is
respectively 0,1,2 and 3.
There exist a bar to set the value of variable for each of x1,x2,y1,y2 and
depth value and an ok button.On clicking it releases signal GTK_RESPONSE_OK
,which results saving the parameters and destroying the widget. We can
change the parameters indefinitely and have a look in a preview window.

12. dialog_preview_setpixel (gint x,gint y,pixel_t *pixel) : It sets the
colouring information of the pixls in the preview window.

13. dialog_preview_init (void) : It initialises the preview window
parameters like preview width,height and scale.


*Cubism*

Including libgimp/gimp.h avails all the basic plugins of GIMP to this
program.

Global Variables :
SCALE_WIDTH =  125
BLACK       =    0init - initialise the process (Optional)
   quit - quit the procedure (Optional)
   query- It is called when a new plugin comes into existence or there is
some modification in the existing plugin.
   run - It is the main function by which plugin works. It takes plugin
name, input parameters, number of return values, pointer to output
parameters as input.
BG          =    1
SUPERSAMPLE =    4
MAX_POINTS  =    4
RANDOMNESS  =    5

Structures :

1. Polygon : It contains details of a polygon like number of pts in a
polygon and information about that point.

2. CubismVals : It contains the information about
tile_size,tile_saturation(defines intensity of colour),bg_color,preview.

Local Variables :

 1. cvals : It stores default values for the parameters of the structure
CubismVals. If user doen't choose any values through the dialog_box, the
cubism will take these values for operation.

 2. GimpPlugInInfo PLUG_IN_INFO : It contains four pointers.
        init : initialise the process (Optional)
        quit : quit the procedure (Optional)
        query : It is called when a new plugin comes into existence or there
is some modification in the existing plugin.
        run : It is the main function by which plugin works. It takes plugin
name, input parameters, number of return values, pointer to output
parameters as input.


Functions :

1. query() :  Defines the input argument. It takes tile_Saturation,bg_color
and tile_size as input.
             It registers the plugin under Image/FIlters/Artistic.

2. run()  :   This function will check for the  GIMP_PDB_EXECUTION_ERROR(if
any) due to the wrong format of image. It will take actions according to the
values of run-mode. If it is interactive, it will provide a dialog_box to
the users and if it is non-interactive, it will check for the proper number
of arguments and if it is less, it will give execution error.We can also run
the program with the last_values of parameters.

3. cubism_dialog (GimpDrawable *drawable) :  It provides a dialog box for
the user for choosing the input parameters and defines the lay-out of
dialog_box. User can change the value of parameters and have a preview for
every changed argument.The widget does not gets destroyed until the ok
button(GTK_RESPONSE_OK signal releases) or cancel button is pressed and the
final parameters are then saved for the next time.

4. cubism (GimpDrawable *drawable,GimpPreview  *preview) :

  (a) If preview is true, we set the parameter of preview like
x1,y1(starting pixels), selection_width and selection_height. By this, we
can calcute the final pixel position as x2,y2.
  (b) If preview is false, we choose a mask bounded by x1 and x2, y1 and y2.

  If background color(bg_col) is BLACK then we put 0 for all the bytes
position in a pixel.Else, we put actual bg_color at every pixel. Function
fills the image with the background color.

   If it is for preview then it directly assigns each destination byte with
the color in bg_color.
   Else,cubistic transformation displays the progress bar having a label -
'Cubistic Transformation'.

   Now, It  traverse every pixel and initialises the background color to the
colour of the original image.Based on the number of rows and columns, it
calculates the number of tiles.

   Initialise a pixel region pointed by src_rgn,new region being attached to
drawable region, (x1,y1) as initial coordinates, width=(x2-x1)and
height=(y2-y1).

   Based on tile size, cols and random indices array it determines the
random starting points( x, y ), then random width and height and random
angle( theta ). It initialises a polygon by calling function
polygon_reset(). After that, we add four points in the polygon. These
vectors are translated based upon the values of tx and ty and rotated based
on the values calculated by theta. By making use of CLAMP, it checks whether
the starting point x and y lie within the specified range (x1, x2-1) and
(y1, y2-1) respectively then it fills the buffer pointed by col with the
value of pixel (ix,iy) in the region src_rgn.col. It fills the respective
polygon by calling fill_poly_color() function and updates the image.

5. fill_poly_color (Polygon *poly,GimpDrawable *drawable, GimpPreview
*preview,guchar *col,guchar *dest) :

  First of all, it calculates the distance between two points in a polygon,
and define x and  y vector between them. After that we call
polygon_extends() function to get the extreme positions of polygon using
min_x,max_x, min_y and max_y variable and from these values,we initialise
the size_y=(max_y - min_y) * SUPERSAMPLE and  size_x =(max_x - min_x) *
SUPERSAMPLE;

 Now, it determines the colors suitable for the polygon by comparing with
the pixel values of the src_rgn at the polygon's position, and fills the
polygon with the color values holded by buf  array(Contains color values at
each pixels).



Regards,

-- 

RAVI BHUSHAN
Undergraduate Final Year,
Computer Engineering,
The LNMIIT,
+91-9462135022
_______________________________________________
Gimp-developer mailing list
Gimp-developer@lists.XCF.Berkeley.EDU
https://lists.XCF.Berkeley.EDU/mailman/listinfo/gimp-developer

Reply via email to