home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / plug-ins / fp / fp_misc.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-08-24  |  10.2 KB  |  416 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. #include <gtk/gtk.h>
  5.  
  6. #include <libgimp/gimp.h>
  7.  
  8. #include "fp.h"
  9.  
  10. extern FP_Params Current;
  11.  
  12. extern GimpDrawable *drawable, *mask;
  13. extern ReducedImage *reduced;
  14.  
  15. extern gint nudgeArray[256];
  16.  
  17. gint colorSign[3][ALL_PRIMARY]=
  18. {{1,-1,-1,-1,1,1},{-1,1,-1,1,1,-1},{-1,-1,1,1,-1,1}};
  19.  
  20.  
  21. void initializeFilterPacks()
  22. {
  23.   gint i, j;
  24.   for (i=0; i<256; i++) 
  25.     for (j=BY_HUE; j<JUDGE_BY; j++) {
  26.       Current.redAdj   [j][i]=0;
  27.       Current.greenAdj [j][i]=0;
  28.       Current.blueAdj  [j][i]=0;
  29.       Current.satAdj   [j][i]=0;
  30.     }
  31. }
  32.  
  33. void resetFilterPacks()
  34. {
  35.   initializeFilterPacks();
  36.   refreshPreviews(Current.VisibleFrames);  
  37. }
  38.  
  39. ReducedImage *Reduce_The_Image(GimpDrawable *drawable,
  40.                    GimpDrawable *mask,
  41.                    gint LongerSize, 
  42.                    gint Slctn)
  43. {
  44.   gint RH, RW, width, height, bytes=drawable->bpp;  
  45.   ReducedImage *temp=(ReducedImage *)malloc(sizeof(ReducedImage));
  46.   guchar *tempRGB, *src_row, *tempmask, *src_mask_row,R,G,B;
  47.   gint i, j, whichcol, whichrow, x1, x2, y1, y2;
  48.   GimpPixelRgn srcPR, srcMask;
  49.   gint NoSelectionMade=TRUE;
  50.   hsv *tempHSV, H, S, V;
  51.  
  52.   gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
  53.   width  = x2-x1;
  54.   height = y2-y1;
  55.  
  56.   if (width != drawable->width && height != drawable->height) 
  57.     NoSelectionMade=FALSE;
  58.  
  59.   if (Slctn==0) {
  60.     x1=0;
  61.     x2=drawable->width;
  62.     y1=0;
  63.     y2=drawable->height;
  64.   }  
  65.  
  66.   if (Slctn==2) {
  67.     x1=MAX(0,                x1-width/2.0);
  68.     x2=MIN(drawable->width,  x2+width/2.0);
  69.     y1=MAX(0,                y1-height/2.0);
  70.     y2=MIN(drawable->height, y2+height/2.0);
  71.   }  
  72.  
  73.   width  = x2-x1;
  74.   height = y2-y1;
  75.  
  76.   if (width>height) {
  77.     RW=LongerSize;
  78.     RH=(float) height * (float) LongerSize/ (float) width;
  79.   }
  80.   else {
  81.     RH=LongerSize;
  82.     RW=(float)width * (float) LongerSize/ (float) height;
  83.   }
  84.   
  85.   tempRGB   = (guchar *) malloc(RW*RH*bytes);
  86.   tempHSV   = (hsv *)    malloc(RW*RH*bytes*sizeof(hsv));
  87.   tempmask  = (guchar *) malloc(RW*RH);
  88.  
  89.   gimp_pixel_rgn_init (&srcPR, drawable, x1, y1, width, height, FALSE, FALSE);
  90.   gimp_pixel_rgn_init (&srcMask, mask, x1, y1, width, height, FALSE, FALSE);
  91.   
  92.   src_row = (guchar *) malloc (width*bytes);
  93.   src_mask_row = (guchar *) malloc (width*bytes);
  94.  
  95.   for (i=0; i<RH; i++) {
  96.     whichrow=(float)i*(float)height/(float)RH;
  97.     gimp_pixel_rgn_get_row (&srcPR, src_row, x1, y1+whichrow, width);   
  98.     gimp_pixel_rgn_get_row (&srcMask, src_mask_row, x1, y1+whichrow, width);
  99.    
  100.     for (j=0; j<RW; j++) {
  101.       whichcol=(float)j*(float)width/(float)RW;
  102.  
  103.       if (NoSelectionMade)
  104.     tempmask[i*RW+j]=255;
  105.       else
  106.     tempmask[i*RW+j]=src_mask_row[whichcol];
  107.  
  108.       R=src_row[whichcol*bytes+0];
  109.       G=src_row[whichcol*bytes+1];
  110.       B=src_row[whichcol*bytes+2];
  111.       
  112.       H = R/255.0;
  113.       S = G/255.0;
  114.       V = B/255.0;
  115.       gimp_rgb_to_hsv_double(&H,&S,&V);
  116.  
  117.       tempRGB[i*RW*bytes+j*bytes+0]=R;
  118.       tempRGB[i*RW*bytes+j*bytes+1]=G;
  119.       tempRGB[i*RW*bytes+j*bytes+2]=B;
  120.  
  121.       tempHSV[i*RW*bytes+j*bytes+0]=H;
  122.       tempHSV[i*RW*bytes+j*bytes+1]=S;
  123.       tempHSV[i*RW*bytes+j*bytes+2]=V;
  124.  
  125.       if (bytes==4)
  126.     tempRGB[i*RW*bytes+j*bytes+3]=src_row[whichcol*bytes+3];
  127.          
  128.     }
  129.   }
  130.   temp->width=RW;
  131.   temp->height=RH;
  132.   temp->rgb=tempRGB;
  133.   temp->hsv=tempHSV;
  134.   temp->mask=tempmask;  
  135.   return temp;
  136. }
  137.  
  138. /*************************************************************/
  139. /************** The Preview Function *************************/
  140. void 
  141. fp_render_preview(GtkWidget     *preview, 
  142.           gint          changewhat,
  143.           gint          changewhich)
  144. { 
  145.   guchar *a;
  146.   gint Inten, bytes=drawable->bpp;
  147.   gint i, j, k, nudge, M, m, middle,JudgeBy;
  148.   float partial;
  149.   gint RW=reduced->width;
  150.   gint RH=reduced->height;
  151.   gint backupP[3], P[3], tempSat[JUDGE_BY][256];
  152.  
  153.   a =(guchar *) malloc(bytes*RW);
  154.    
  155.   if (changewhat==SATURATION)
  156.     for (k=0; k<256; k++) {
  157.       for (JudgeBy=BY_HUE; JudgeBy<JUDGE_BY; JudgeBy++)
  158.     tempSat[JudgeBy][k]=0; 
  159.     tempSat[Current.ValueBy][k] += changewhich*nudgeArray[(k+Current.Offset)%256];
  160.     }
  161.       
  162.   for (i=0; i<RH; i++) {
  163.     for (j=0; j<RW; j++) {
  164.       
  165.       backupP[0] = P[0]  = (int) reduced->rgb[i*RW*bytes + j*bytes + 0];
  166.       backupP[1] = P[1]  = (int) reduced->rgb[i*RW*bytes + j*bytes + 1];
  167.       backupP[2] = P[2]  = (int) reduced->rgb[i*RW*bytes + j*bytes + 2];
  168.       
  169.       m = MIN(MIN(P[0],P[1]),P[2]);
  170.       M = MAX(MAX(P[0],P[1]),P[2]);
  171.       middle=(M+m)/2;
  172.       for (k=0; k<3; k++)
  173.     if (P[k]!=m && P[k]!=M) middle=P[k];
  174.       
  175.       partial = reduced->mask[i*RW+j]/255.0;
  176.       
  177.       for (JudgeBy=BY_HUE; JudgeBy<JUDGE_BY; JudgeBy++) {
  178.     if (!Current.Touched[JudgeBy]) continue;
  179.     
  180.     Inten   = reduced->hsv[i*RW*bytes + j*bytes + JudgeBy]*255.0;
  181.     
  182.     /*DO SATURATION FIRST*/
  183.     if (changewhat != NONEATALL) {
  184.       if (M!=m) {
  185.         for (k=0; k<3; k++)
  186.           if (backupP[k] == M)
  187.         P[k] = MAX(P[k]+partial*Current.satAdj[JudgeBy][Inten],middle);
  188.           else if (backupP[k] == m)
  189.         P[k] = MIN(P[k]-partial*Current.satAdj[JudgeBy][Inten],middle); 
  190.       }
  191.       P[0]  += partial*Current.redAdj[JudgeBy][Inten];
  192.       P[1]  += partial*Current.greenAdj[JudgeBy][Inten];
  193.       P[2]  += partial*Current.blueAdj[JudgeBy][Inten];
  194.     }
  195.       }
  196.       
  197.       Inten   = reduced->hsv[i*RW*bytes + j*bytes + Current.ValueBy]*255.0;
  198.       nudge   = partial*nudgeArray[(Inten+Current.Offset)%256];  
  199.  
  200.       switch (changewhat) {
  201.       case HUE:
  202.     P[0]  += colorSign[RED][changewhich]   * nudge;
  203.     P[1]  += colorSign[GREEN][changewhich] * nudge; 
  204.     P[2]  += colorSign[BLUE][changewhich]  * nudge;
  205.     break;
  206.     
  207.       case SATURATION:
  208.     for (JudgeBy=BY_HUE; JudgeBy<JUDGE_BY; JudgeBy++)
  209.       for (k=0; k<3; k++)
  210.         if (M!=m) {
  211.           if (backupP[k] == M)
  212.         P[k] = MAX(P[k]+
  213.                partial*tempSat[JudgeBy][Inten],middle);
  214.           else if (backupP[k] == m)
  215.         P[k] = MIN(P[k]-
  216.                partial*tempSat[JudgeBy][Inten],middle);
  217.         }
  218.     break;
  219.  
  220.       case VALUE:
  221.     P[0]  += changewhich  * nudge;
  222.     P[1]  += changewhich  * nudge;
  223.     P[2]  += changewhich  * nudge;
  224.     break;
  225.  
  226.       default: 
  227.     break;
  228.       }
  229.       
  230.       a[j*3+0] = MAX(0,MIN(P[0], 255));
  231.       a[j*3+1] = MAX(0,MIN(P[1], 255));
  232.       a[j*3+2] = MAX(0,MIN(P[2], 255));
  233.  
  234.       if (bytes==4) 
  235.     for (k=0; k<3; k++) {
  236.       float transp=reduced->rgb[i*RW*bytes+j*bytes+3]/255.0;
  237.       a[3*j+k]=transp*a[3*j+k]+(1-transp)*fp_fake_transparency(i,j);
  238.     }
  239.     }
  240.     gtk_preview_draw_row( GTK_PREVIEW(preview),a,0,i,RW);
  241.   }
  242.   
  243.   free(a); 
  244.   gtk_widget_draw(preview,NULL);
  245.   gdk_flush();
  246. }
  247.  
  248. void      
  249. Update_Current_FP     (gint   changewhat,
  250.                gint   changewhich)
  251. {
  252.   int i, nudge;
  253.   
  254.   for (i=0; i<256; i++) {
  255.     
  256.     fp_Create_Nudge(nudgeArray);
  257.     nudge=nudgeArray[(i+Current.Offset)%256];
  258.     
  259.     switch (changewhat) {
  260.     case HUE:
  261.       Current.redAdj[Current.ValueBy][i]   += 
  262.     colorSign[RED][changewhich] * nudge;
  263.       
  264.       Current.greenAdj[Current.ValueBy][i] += 
  265.     colorSign[GREEN][changewhich] * nudge;
  266.       
  267.       Current.blueAdj[Current.ValueBy][i]  += 
  268.     colorSign[BLUE][changewhich]  * nudge;
  269.       break;
  270.       
  271.     case SATURATION:
  272.       Current.satAdj[Current.ValueBy][i] += changewhich*nudge;
  273.       break;
  274.       
  275.     case VALUE:
  276.       Current.redAdj[Current.ValueBy][i]   += changewhich * nudge;
  277.       Current.greenAdj[Current.ValueBy][i] += changewhich * nudge;
  278.       Current.blueAdj[Current.ValueBy][i]  += changewhich * nudge;
  279.       break;
  280.       
  281.     default:
  282.       break;
  283.     } /* switch */
  284.     
  285.   } /* for */
  286. }
  287.  
  288.  
  289. void
  290. fp_create_smoothness_graph        (GtkWidget *preview)
  291. {
  292.   guchar data[256*3];
  293.   gint nArray[256];
  294.   int i, j, toBeBlack;
  295.  
  296.   fp_Create_Nudge(nArray);
  297.  
  298.   for (i=0; i<MAX_ROUGHNESS; i++)
  299.     {
  300.       int coor=MAX_ROUGHNESS-i;
  301.       for (j=0; j<256; j++) {
  302.     data[3*j+0]=255;
  303.     data[3*j+1]=255;
  304.     data[3*j+2]=255;
  305.     if  (!(i%(MAX_ROUGHNESS/4))) {
  306.       data[3*j+0]=255;
  307.       data[3*j+1]=128;
  308.       data[3*j+2]=128;
  309.     }
  310.     if  (!((j+1)%32)) {
  311.       data[3*j+0]=255;
  312.       data[3*j+1]=128;
  313.       data[3*j+2]=128;
  314.     }
  315.     toBeBlack=0;
  316.     if (nArray[j]==coor) toBeBlack=1;
  317.  
  318.     if (j<255) {
  319.       int jump=abs(nArray[j]-nArray[j+1]);
  320.       if (   abs(coor-nArray[j])   < jump 
  321.           && abs(coor-nArray[j+1]) < jump)
  322.         toBeBlack=1;
  323.     }
  324.     if (toBeBlack) {
  325.       data[3*j+0]=0;
  326.       data[3*j+1]=0;
  327.       data[3*j+2]=0;
  328.     }  
  329.       }
  330.       gtk_preview_draw_row( GTK_PREVIEW(preview),data,0,i,256);
  331.     }
  332.   gtk_widget_draw(preview,NULL);
  333.   gdk_flush();
  334. }
  335.  
  336. void
  337. fp_range_preview_spill(GtkWidget *preview, int type)
  338. {
  339.   guchar data[256*3];
  340.   int i, j;
  341.   hsv R,G,B;
  342.   
  343.   for (i=0; i<RANGE_HEIGHT; i++) {
  344.     for (j=0; j<256; j++)
  345.       if  (!((j+1)%32)) {
  346.     data[3*j+0]=255;
  347.     data[3*j+1]=128;
  348.     data[3*j+2]=128;
  349.       }
  350.       else
  351.     switch (type) {
  352.     case BY_VAL:
  353.       data[3*j+0]=j-Current.Offset;
  354.       data[3*j+1]=j-Current.Offset;
  355.       data[3*j+2]=j-Current.Offset;
  356.       break;
  357.     case BY_HUE:
  358.       R = (hsv)((j-Current.Offset+256)%256)/255.0;
  359.       G = 1.0;
  360.       B = .5;
  361.       gimp_hsv_to_rgb_double(&R, &G, &B);
  362.       data[3*j+0]=R*255;
  363.       data[3*j+1]=G*255;
  364.       data[3*j+2]=B*255;
  365.       break;
  366.     case BY_SAT:
  367.       R = .5;
  368.       G = (hsv)((j-(gint)Current.Offset+256)%256)/255.0;
  369.       B = .5;
  370.       gimp_hsv_to_rgb_double(&R,&G,&B);
  371.       data[3*j+0]=R*255;
  372.       data[3*j+1]=G*255;
  373.       data[3*j+2]=B*255;
  374.       break;
  375.     }
  376.     gtk_preview_draw_row( GTK_PREVIEW(preview),data,0,i,256);
  377.   }
  378.   gtk_widget_draw(preview,NULL);
  379.   gdk_flush();
  380. }
  381.  
  382.  
  383. void  fp_Create_Nudge(gint  *adjArray)
  384. {
  385.   int left, right, middle,i;
  386.   /* The following function was determined by trial and error */
  387.   double Steepness=pow(1-Current.Alias,4)*.8; 
  388.  
  389.   left = (Current.Range == SHADOWS) ? 0 : Current.Cutoffs[Current.Range-1];
  390.   right = Current.Cutoffs[Current.Range];
  391.   middle = (left + right)/2; 
  392.  
  393.   if (Current.Alias!=0)
  394.     for (i=0; i<256; i++)
  395.       if (i<=middle)
  396.     adjArray[i] = MAX_ROUGHNESS * 
  397.       Current.Rough*(1+tanh(Steepness*(i-left)))/2;
  398.       else
  399.     adjArray[i] = MAX_ROUGHNESS * 
  400.       Current.Rough*(1+tanh(Steepness*(right-i)))/2;
  401.   else
  402.      for (i=0; i<256; i++)
  403.        if (left<=i && i<=right)
  404.      adjArray[i] = MAX_ROUGHNESS * Current.Rough;
  405.        else
  406.      adjArray[i] = 0;
  407. }
  408.  
  409. gint fp_fake_transparency(gint i, gint j)
  410. {
  411.   if ( ((i%20)- 10) * ((j%20)- 10)>0   )
  412.     return 64;
  413.   else 
  414.     return 196;
  415. }
  416.