home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / plug-ins / common / iwarp.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-08-28  |  42.2 KB  |  1,594 lines
  1. /* The GIMP -- an image manipulation program
  2.  * Copyright (C) 1995 Spencer Kimball and Peter Mattis
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify
  5.  * it under the terms of the GNU General Public License as published by
  6.  * the Free Software Foundation; either version 2 of the License, or
  7.  * (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17.  */
  18.  
  19. /* IWarp  a plug-in for the GIMP
  20.    Version 0.1 
  21.    
  22.    IWarp is a gimp plug-in for interactive image warping. To apply the 
  23.    selected deformation to the image, press the left mouse button and 
  24.    move the mouse pointer in the preview image.
  25.    
  26.    Copyright (C) 1997 Norbert Schmitz
  27.    nobert.schmitz@student.uni-tuebingen.de
  28.  
  29.    Most of the gimp and gtk specific code is taken from other plug-ins 
  30.  
  31.    v0.11a
  32.     animation of non-alpha layers (background) creates now layers with 
  33.     alpha channel. (thanks to Adrian Likins for reporting this bug)
  34.  
  35.   v0.12 
  36.     fixes a very bad bug. 
  37.      (thanks to Arthur Hagen for reporting it)
  38.     
  39. */
  40.  
  41. #include "config.h"
  42.  
  43. #include <stdlib.h>
  44. #include <string.h>
  45. #include <stdio.h>
  46.  
  47. #include <gtk/gtk.h>
  48.  
  49. #include <libgimp/gimp.h>
  50. #include <libgimp/gimpui.h>
  51.  
  52. #include "libgimp/stdplugins-intl.h"
  53.  
  54.  
  55. #define MAX_PREVIEW_WIDTH      256
  56. #define MAX_PREVIEW_HEIGHT     256
  57. #define MAX_DEFORM_AREA_RADIUS 100
  58.  
  59. #define SCALE_WIDTH    100
  60. #define MAX_NUM_FRAMES 100
  61.  
  62. typedef enum
  63. {
  64.   GROW,
  65.   SHRINK,
  66.   MOVE,
  67.   REMOVE,
  68.   SWIRL_CCW,
  69.   SWIRL_CW
  70. } DeformMode;
  71.  
  72. typedef struct
  73. {
  74.   gint run;
  75. } iwarp_interface;
  76.  
  77. typedef struct
  78. {
  79.   gint        deform_area_radius;
  80.   gdouble     deform_amount;
  81.   DeformMode  deform_mode;
  82.   gboolean    do_bilinear;
  83.   gboolean    do_supersample;
  84.   gdouble     supersample_threshold;
  85.   gint        max_supersample_depth;
  86. } iwarp_vals_t; 
  87.  
  88.  
  89. /* Declare local functions.
  90.  */
  91. static void      query  (void);
  92. static void      run    (gchar     *name,
  93.              gint       nparams,
  94.              GimpParam    *param,
  95.              gint      *nreturn_vals,
  96.              GimpParam   **return_vals);
  97.  
  98. static void      iwarp                   (void);
  99. static void      iwarp_frame             (void);
  100.  
  101. static gboolean  iwarp_dialog            (void);
  102. static void      iwarp_animate_dialog    (GtkWidget *dlg,
  103.                       GtkWidget *notebook);
  104.  
  105. static void      iwarp_settings_dialog   (GtkWidget *dlg,
  106.                       GtkWidget *notebook);
  107.  
  108. static void      iwarp_ok_callback       (GtkWidget *widget,
  109.                       gpointer   data);
  110. static void      iwarp_reset_callback    (GtkWidget *widget,
  111.                       gpointer   data);
  112.  
  113. static gint      iwarp_motion_callback   (GtkWidget *widget,
  114.                       GdkEvent  *event);
  115.  
  116. static void      iwarp_update_preview    (gint       x0,
  117.                       gint       y0,
  118.                       gint       x1,
  119.                       gint       y1);
  120.  
  121. static void      iwarp_get_pixel         (gint       x,
  122.                       gint       y,
  123.                       guchar    *pixel);
  124.  
  125. static void      iwarp_get_deform_vector (gdouble    x,
  126.                       gdouble    y, 
  127.                       gdouble   *xv,
  128.                       gdouble   *yv);
  129.  
  130. static void      iwarp_get_point         (gdouble    x,
  131.                       gdouble    y,
  132.                       guchar    *color);
  133.  
  134. static gint      iwarp_supersample_test  (GimpVector2 *v0,
  135.                       GimpVector2 *v1, 
  136.                       GimpVector2 *v2,
  137.                       GimpVector2 *v3);
  138.  
  139. static void      iwarp_getsample         (GimpVector2  v0,
  140.                       GimpVector2  v1,
  141.                       GimpVector2  v2,
  142.                       GimpVector2  v3, 
  143.                       gdouble      x,
  144.                       gdouble      y,
  145.                       gint        *sample,
  146.                       gint        *cc,
  147.                       gint         depth,
  148.                       gdouble      scale);
  149.  
  150. static void      iwarp_supersample       (gint       sxl,
  151.                       gint       syl,
  152.                       gint       sxr,
  153.                       gint       syr,
  154.                       guchar    *dest_data,
  155.                       gint       stride,
  156.                       gint      *progress,
  157.                       gint       max_progress);
  158.  
  159. static guchar    iwarp_transparent_color (gint       x,
  160.                       gint       y);
  161.  
  162. static void      iwarp_cpy_images        (void);
  163.  
  164. static void      iwarp_preview_get_pixel (gint       x,
  165.                       gint       y,
  166.                       guchar   **color);
  167.  
  168. static void      iwarp_preview_get_point (gdouble    x,
  169.                       gdouble    y,
  170.                       guchar    *color);
  171.  
  172. static void      iwarp_deform            (gint       x,
  173.                       gint       y,
  174.                       gdouble    vx,
  175.                       gdouble    vy);
  176.  
  177. static void      iwarp_move              (gint       x,
  178.                       gint       y,
  179.                       gint       xx,
  180.                       gint       yy);
  181.  
  182.  
  183. GimpPlugInInfo PLUG_IN_INFO =
  184. {
  185.   NULL,  /* init_proc  */
  186.   NULL,  /* quit_proc  */
  187.   query, /* query_proc */
  188.   run,   /* run_proc   */
  189. };
  190.  
  191. static iwarp_interface wint = 
  192. {
  193.   FALSE
  194. };
  195.  
  196. static iwarp_vals_t iwarp_vals = 
  197. {
  198.   20,
  199.   0.3,
  200.   MOVE,
  201.   TRUE,
  202.   FALSE,
  203.   2.0,
  204.   2
  205. }; 
  206.  
  207. static GimpDrawable   *drawable = NULL;
  208. static GimpDrawable   *destdrawable = NULL;
  209. static GtkWidget   *preview = NULL;
  210. static guchar      *srcimage = NULL;
  211. static guchar      *dstimage = NULL;
  212. static gint         preview_width, preview_height;
  213. static gint         sel_width, sel_height;
  214. static gint         image_bpp;
  215. static gint         preserve_trans;
  216. static GimpVector2 *deform_vectors = NULL;
  217. static GimpVector2 *deform_area_vectors = NULL;
  218. static gint         lastx, lasty;
  219. static gdouble      filter[MAX_DEFORM_AREA_RADIUS];
  220. static gboolean     do_animate = FALSE;
  221. static gboolean     do_animate_reverse = FALSE;
  222. static gboolean     do_animate_ping_pong = FALSE;
  223. static gdouble      supersample_threshold_2;
  224. static gint         xl, yl, xh, yh;
  225. static gint         tile_width, tile_height;
  226. static GimpTile       *tile = NULL;
  227. static gdouble      pre2img, img2pre;
  228. static gint         preview_bpp;
  229. static gdouble      animate_deform_value = 1.0;
  230. static gint32       imageID;
  231. static gint         animate_num_frames = 2;
  232. static gint         frame_number;
  233. static gint         layer_alpha;
  234.  
  235.  
  236. MAIN ()
  237.  
  238. static void
  239. query (void)
  240. {
  241.   static GimpParamDef args[] =
  242.   {
  243.     { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
  244.     { GIMP_PDB_IMAGE, "image", "Input image (unused)" },
  245.     { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
  246.   };
  247.   static gint nargs = sizeof (args) / sizeof (args[0]);
  248.  
  249.   gimp_install_procedure ("plug_in_iwarp",
  250.               "Interactive warping of the specified drawable",
  251.               "Interactive warping of the specified drawable",
  252.               "Norbert Schmitz",
  253.               "Norbert Schmitz",
  254.               "1997",
  255.               N_("<Image>/Filters/Distorts/IWarp..."),
  256.               "RGB*, GRAY*",
  257.               GIMP_PLUGIN,
  258.               nargs, 0,
  259.               args, NULL);
  260. }
  261.  
  262. static void
  263. run (gchar   *name,
  264.      gint     nparams,
  265.      GimpParam  *param,
  266.      gint    *nreturn_vals,
  267.      GimpParam **return_vals)
  268. {
  269.   static GimpParam values[1];
  270.   GimpRunModeType run_mode;
  271.   GimpPDBStatusType status = GIMP_PDB_SUCCESS;
  272.  
  273.   run_mode = param[0].data.d_int32;
  274.  
  275.   /*  Get the specified drawable  */
  276.   destdrawable = drawable = gimp_drawable_get (param[2].data.d_drawable);
  277.   imageID = param[1].data.d_int32;
  278.  
  279.   /*  Make sure that the drawable is gray or RGB color  */
  280.   if (gimp_drawable_is_rgb (drawable->id) ||
  281.       gimp_drawable_is_gray (drawable->id))
  282.     {
  283.       switch (run_mode)
  284.     {
  285.         case GIMP_RUN_INTERACTIVE:
  286.           INIT_I18N_UI();
  287.           gimp_get_data ("plug_in_iwarp", &iwarp_vals);
  288.           gimp_tile_cache_ntiles (2 * (drawable->width + gimp_tile_width ()-1) /
  289.                   gimp_tile_width ());
  290.           if (iwarp_dialog())
  291.         iwarp();
  292.           gimp_set_data ("plug_in_iwarp", &iwarp_vals, sizeof (iwarp_vals_t));
  293.        gimp_displays_flush ();
  294.       break;
  295.  
  296.         case GIMP_RUN_NONINTERACTIVE:
  297.       status = GIMP_PDB_CALLING_ERROR;
  298.         break;
  299.  
  300.         case GIMP_RUN_WITH_LAST_VALS:
  301.       status = GIMP_PDB_CALLING_ERROR;
  302.         break;
  303.  
  304.         default:
  305.       break;
  306.     }
  307.     }
  308.   else
  309.     {
  310.       status = GIMP_PDB_EXECUTION_ERROR;
  311.     }
  312.  
  313.   *nreturn_vals = 1;
  314.   *return_vals = values;
  315.  
  316.   values[0].type = GIMP_PDB_STATUS;
  317.   values[0].data.d_status = status;
  318.  
  319.   gimp_drawable_detach (drawable);
  320.  
  321.   g_free (srcimage);
  322.   g_free (dstimage);  
  323.   g_free (deform_vectors);
  324.   g_free (deform_area_vectors);
  325. }
  326.  
  327. static void
  328. iwarp_get_pixel (gint    x,
  329.          gint    y,
  330.          guchar *pixel)
  331. {
  332.  static gint  old_col = -1;
  333.  static gint  old_row = -1;
  334.  guchar      *data;
  335.  gint         col, row;
  336.  gint         i;
  337.  
  338.  if (x >= xl && x < xh && y  >= yl && y < yh)
  339.    {
  340.      col = x / tile_width;
  341.      row = y / tile_height;
  342.      if (col != old_col || row != old_row)
  343.        {
  344.      gimp_tile_unref (tile, FALSE);
  345.      tile = gimp_drawable_get_tile (drawable, FALSE, row, col);
  346.      gimp_tile_ref (tile);
  347.      old_col = col;
  348.      old_row = row;
  349.        }
  350.      data =
  351.        tile->data +
  352.        (tile->ewidth * (y % tile_height) +
  353.     x % tile_width) * image_bpp;
  354.      for (i = 0; i < image_bpp; i++)
  355.        *pixel++ = *data++;
  356.    }
  357.  else
  358.    {
  359.      pixel[0] = pixel[1] = pixel[2] = pixel[3] = 0;
  360.    }
  361. }
  362.  
  363. static void
  364. iwarp_get_deform_vector (gdouble  x,
  365.              gdouble  y,
  366.              gdouble *xv,
  367.              gdouble *yv)
  368. {
  369.   gint    i, xi, yi;
  370.   gdouble dx, dy, my0, my1, mx0, mx1;
  371.  
  372.   if (x >= 0 && x < (preview_width - 1) && y >= 0  && y < (preview_height - 1))
  373.     { 
  374.       xi = (gint) x;
  375.       yi = (gint) y;
  376.       dx = x-xi;
  377.       dy = y-yi;
  378.       i = (yi * preview_width + xi);
  379.       mx0 =
  380.     deform_vectors[i].x +
  381.     (deform_vectors[i+1].x -
  382.      deform_vectors[i].x) * dx;
  383.       mx1 =
  384.     deform_vectors[i+preview_width].x +
  385.     (deform_vectors[i+preview_width+1].x -
  386.      deform_vectors[i+preview_width].x) * dx;
  387.       my0 =
  388.     deform_vectors[i].y +
  389.     dx * (deform_vectors[i+1].y -
  390.           deform_vectors[i].y);
  391.       my1 =
  392.     deform_vectors[i+preview_width].y +
  393.     dx * (deform_vectors[i+preview_width+1].y -
  394.           deform_vectors[i+preview_width].y);
  395.       *xv = mx0 + dy * (mx1 - mx0);
  396.       *yv = my0 + dy * (my1 - my0); 
  397.     }
  398.   else
  399.     {
  400.       *xv = *yv = 0.0; 
  401.     }
  402. }
  403.  
  404. static void
  405. iwarp_get_point (gdouble  x,
  406.          gdouble  y,
  407.          guchar  *color)
  408. {
  409.   gdouble dx, dy, m0, m1;
  410.   guchar  p0[4], p1[4], p2[4], p3[4]; 
  411.   gint    xi, yi, i;
  412.   
  413.   xi = (gint) x;
  414.   yi = (gint) y;
  415.   dx = x - xi;
  416.   dy = y - yi; 
  417.   iwarp_get_pixel (xi, yi, p0);
  418.   iwarp_get_pixel (xi + 1, yi, p1);
  419.   iwarp_get_pixel (xi, yi + 1, p2);
  420.   iwarp_get_pixel (xi + 1, yi + 1, p3);              
  421.   for (i = 0; i < image_bpp; i++)
  422.     {
  423.       m0 = p0[i] + dx * (p1[i] - p0[i]);
  424.       m1 = p2[i] + dx * (p3[i] - p2[i]);
  425.       color[i] = (guchar) (m0 + dy * (m1 - m0));
  426.     }
  427. } 
  428.  
  429. static gboolean
  430. iwarp_supersample_test (GimpVector2 *v0,
  431.             GimpVector2 *v1,
  432.             GimpVector2 *v2,
  433.             GimpVector2 *v3)
  434. {
  435.   gdouble dx, dy;
  436.  
  437.   dx = 1.0+v1->x - v0->x;
  438.   dy = v1->y - v0->y;
  439.   if (dx * dx + dy * dy > supersample_threshold_2)
  440.     return TRUE;
  441.  
  442.   dx = 1.0+v2->x - v3->x;
  443.   dy = v2->y - v3->y;
  444.   if (dx*dx+dy*dy > supersample_threshold_2) 
  445.     return TRUE;
  446.  
  447.   dx = v2->x - v0->x;
  448.   dy = 1.0+v2->y - v0->y;
  449.   if (dx*dx+dy*dy > supersample_threshold_2) 
  450.     return TRUE;
  451.  
  452.   dx = v3->x - v1->x;
  453.   dy = 1.0+v3->y - v1->y;
  454.   if (dx*dx+dy*dy > supersample_threshold_2) 
  455.     return TRUE; 
  456.  
  457.   return FALSE;
  458. }
  459.  
  460. static void
  461. iwarp_getsample (GimpVector2  v0,
  462.          GimpVector2  v1,
  463.          GimpVector2  v2,
  464.          GimpVector2  v3, 
  465.          gdouble      x,
  466.          gdouble      y,
  467.          gint        *sample,
  468.          gint        *cc,
  469.          gint         depth,
  470.          gdouble      scale)
  471. {
  472.   gint        i;
  473.   gdouble     xv, yv;
  474.   GimpVector2 v01, v13, v23, v02, vm;
  475.   guchar      c[4];
  476.  
  477.   if ((depth >= iwarp_vals.max_supersample_depth) ||
  478.       (!iwarp_supersample_test (&v0, &v1, &v2, &v3)))
  479.     {
  480.       iwarp_get_deform_vector (img2pre * (x - xl),
  481.                    img2pre * (y - yl),
  482.                    &xv, &yv);
  483.       xv *= animate_deform_value;
  484.       yv *= animate_deform_value;
  485.       iwarp_get_point (pre2img * xv + x, pre2img * yv + y, c);
  486.       for (i = 0;  i < image_bpp; i++)
  487.     sample[i] += c[i];
  488.       (*cc)++;
  489.     }
  490.  else
  491.    {
  492.      scale *= 0.5;
  493.      iwarp_get_deform_vector (img2pre * (x - xl),
  494.                   img2pre * (y - yl),
  495.                   &xv, &yv);
  496.      xv *= animate_deform_value;
  497.      yv *= animate_deform_value;
  498.      iwarp_get_point (pre2img * xv + x, pre2img * yv + y, c);
  499.      for (i = 0;  i < image_bpp; i++)
  500.        sample[i] += c[i];
  501.      (*cc)++;
  502.      vm.x = xv;
  503.      vm.y = yv;
  504.  
  505.      iwarp_get_deform_vector (img2pre * (x - xl),
  506.                   img2pre * (y - yl - scale),
  507.                   &xv, &yv);
  508.      xv *= animate_deform_value;
  509.      yv *= animate_deform_value;
  510.      v01.x = xv;
  511.      v01.y = yv;
  512.   
  513.      iwarp_get_deform_vector (img2pre * (x - xl + scale),
  514.                   img2pre * (y - yl),
  515.                   &xv, &yv);
  516.      xv *= animate_deform_value;
  517.      yv *= animate_deform_value;
  518.      v13.x = xv;
  519.      v13.y = yv;
  520.  
  521.      iwarp_get_deform_vector (img2pre * (x - xl),
  522.                   img2pre * (y - yl + scale),
  523.                   &xv, &yv);
  524.      xv *= animate_deform_value;
  525.      yv *= animate_deform_value;
  526.      v23.x = xv;
  527.      v23.y = yv;
  528.  
  529.      iwarp_get_deform_vector (img2pre * (x - xl - scale),
  530.                   img2pre * (y - yl),
  531.                   &xv, &yv);
  532.      xv *= animate_deform_value;
  533.      yv *= animate_deform_value;
  534.      v02.x = xv;
  535.      v02.y = yv;
  536.  
  537.      iwarp_getsample (v0, v01, vm, v02,
  538.               x-scale, y-scale,
  539.               sample, cc, depth + 1,
  540.               scale);
  541.      iwarp_getsample (v01, v1, v13, vm,
  542.               x + scale, y - scale,
  543.               sample, cc, depth + 1,
  544.               scale);
  545.      iwarp_getsample (v02, vm, v23, v2,
  546.               x - scale, y + scale,
  547.               sample, cc, depth + 1,
  548.               scale);
  549.      iwarp_getsample (vm, v13, v3, v23,
  550.               x + scale, y + scale,
  551.               sample, cc, depth + 1,
  552.               scale);
  553.    }
  554. }
  555.  
  556. static void
  557. iwarp_supersample (gint    sxl,
  558.            gint    syl,
  559.            gint    sxr,
  560.            gint    syr,
  561.            guchar *dest_data,
  562.            gint    stride,
  563.            gint   *progress,
  564.            gint    max_progress)
  565. {
  566.   gint         i, wx, wy, col, row, cc;
  567.   GimpVector2 *srow, *srow_old, *vh;
  568.   gdouble      xv, yv;
  569.   gint         color[4];
  570.   guchar      *dest;
  571.  
  572.   wx = sxr - sxl + 1;
  573.   wy = syr - syl + 1;
  574.   srow     = g_new (GimpVector2, sxr - sxl + 1);
  575.   srow_old = g_new (GimpVector2, sxr - sxl + 1);
  576.  
  577.   for (i = sxl; i < (sxr + 1); i++)
  578.     {
  579.       iwarp_get_deform_vector (img2pre * (-0.5 + i - xl),
  580.                    img2pre * (-0.5 + syl - yl),
  581.                    &xv, &yv);
  582.       xv *= animate_deform_value;
  583.       yv *= animate_deform_value;
  584.       srow_old[i-sxl].x = xv;
  585.       srow_old[i-sxl].y = yv;
  586.     }
  587.  
  588.   for (col = syl; col < syr; col++)
  589.     {
  590.       iwarp_get_deform_vector (img2pre * (-0.5 + sxl - xl),
  591.                    img2pre * (0.5 + col - yl),
  592.                    &xv, &yv);
  593.       xv *= animate_deform_value;
  594.       yv *= animate_deform_value;
  595.       srow[0].x = xv;
  596.       srow[0].y = yv; 
  597.       for (row = sxl; row <sxr; row++)
  598.     {
  599.       iwarp_get_deform_vector (img2pre * (0.5 + row - xl),
  600.                    img2pre * (0.5 + col - yl),
  601.                    &xv, &yv);
  602.       xv *= animate_deform_value;
  603.       yv *= animate_deform_value;
  604.       srow[row-sxl+1].x = xv;
  605.       srow[row-sxl+1].y = yv;
  606.       cc = 0;
  607.       color[0] = color[1] = color[2] = color[3] = 0;
  608.       iwarp_getsample (srow_old[row-sxl], srow_old[row-sxl+1],
  609.                srow[row-sxl], srow[row-sxl+1],
  610.                row, col, color, &cc, 0, 1.0);
  611.       if (layer_alpha)
  612.         dest = dest_data + (col-syl) * (stride) + (row-sxl) * (image_bpp+1);
  613.       else 
  614.         dest = dest_data + (col-syl) * stride + (row-sxl) * image_bpp;
  615.       for (i = 0; i < image_bpp; i++)
  616.         *dest++ = color[i] / cc;
  617.       if (layer_alpha)
  618.         *dest++ = 255; 
  619.       (*progress)++;
  620.     }
  621.  
  622.       gimp_progress_update ((gdouble) (*progress) / max_progress);
  623.       vh = srow_old;
  624.       srow_old = srow;
  625.       srow = vh;   
  626.     }
  627.  
  628.   g_free (srow);
  629.   g_free (srow_old);
  630. }
  631.  
  632. static void
  633. iwarp_frame (void)
  634. {
  635.   GimpPixelRgn  dest_rgn;
  636.   gpointer   pr;
  637.   guchar    *dest_row, *dest;
  638.   gint       row, col;
  639.   gint       i;
  640.   gint       progress, max_progress;
  641.   guchar     color[4];
  642.   gdouble    xv, yv;
  643.  
  644.   progress = 0;
  645.   max_progress = (yh-yl)*(xh-xl);
  646.  
  647.   gimp_pixel_rgn_init (&dest_rgn, destdrawable,
  648.                xl, yl, xh-xl, yh-yl, TRUE, TRUE);
  649.  
  650.   if (!do_animate)
  651.     gimp_progress_init (_("Warping..."));
  652.  
  653.   for (pr = gimp_pixel_rgns_register (1, &dest_rgn);
  654.        pr != NULL;
  655.        pr = gimp_pixel_rgns_process (pr))
  656.     {
  657.       dest_row = dest_rgn.data;
  658.       if (!iwarp_vals.do_supersample)
  659.     {
  660.       for (row = dest_rgn.y; row < (dest_rgn.y + dest_rgn.h); row++)
  661.         {
  662.           dest = dest_row;
  663.           for (col = dest_rgn.x; col < (dest_rgn.x + dest_rgn.w); col++)
  664.         {
  665.           progress++;
  666.           iwarp_get_deform_vector (img2pre * (col -xl),
  667.                        img2pre * (row -yl),
  668.                        &xv ,&yv);
  669.           xv *= animate_deform_value;
  670.           yv *= animate_deform_value;
  671.           if (fabs(xv) > 0.0 || fabs(yv) > 0.0)
  672.             {
  673.               iwarp_get_point (pre2img * xv + col,
  674.                        pre2img *yv + row,
  675.                        color);
  676.               for (i = 0; i < image_bpp; i++)
  677.             *dest++ = color[i];
  678.               if (layer_alpha)
  679.             *dest++ = 255;
  680.             }
  681.           else
  682.             {
  683.               iwarp_get_pixel (col, row, color);
  684.               for (i = 0; i < image_bpp; i++)
  685.             *dest++ = color[i];
  686.               if (layer_alpha)
  687.             *dest++ = 255;
  688.             }
  689.         }
  690.           dest_row += dest_rgn.rowstride;
  691.           gimp_progress_update ((gdouble) (progress) / max_progress);
  692.         }
  693.     }
  694.       else
  695.     {
  696.       supersample_threshold_2 =
  697.         iwarp_vals.supersample_threshold * iwarp_vals.supersample_threshold; 
  698.       iwarp_supersample (dest_rgn.x, dest_rgn.y,
  699.                  dest_rgn.x + dest_rgn.w, dest_rgn.y + dest_rgn.h,
  700.                  dest_rgn.data,
  701.                  dest_rgn.rowstride,
  702.                  &progress, max_progress);
  703.     } 
  704.     }
  705.  
  706.   gimp_drawable_flush (destdrawable);
  707.   gimp_drawable_merge_shadow (destdrawable->id, TRUE);
  708.   gimp_drawable_update (destdrawable->id, xl, yl, (xh - xl), (yh - yl));
  709. }
  710.  
  711. static void
  712. iwarp (void)
  713. {
  714.   gint     i;
  715.   gint32   layerID;
  716.   gint32  *animlayers;
  717.   gchar   *st;
  718.   gdouble  delta;
  719.  
  720.   if (animate_num_frames > 1 && do_animate)
  721.     {
  722.       animlayers = g_new (gint32, animate_num_frames);
  723.       if (do_animate_reverse)
  724.     {
  725.       animate_deform_value = 1.0;
  726.       delta = -1.0 / (animate_num_frames - 1);
  727.     }
  728.       else
  729.     {
  730.       animate_deform_value = 0.0;
  731.       delta = 1.0 / (animate_num_frames - 1);
  732.     }
  733.       layerID = gimp_image_get_active_layer (imageID);
  734.       if (image_bpp == 1 || image_bpp == 3)
  735.     layer_alpha = TRUE;
  736.       else
  737.     layer_alpha = FALSE;
  738.       frame_number = 0;
  739.       for (i = 0; i < animate_num_frames; i++)
  740.     {
  741.       st = g_strdup_printf (_("Frame %d"), i);
  742.       animlayers[i] = _gimp_layer_copy (layerID, TRUE);
  743.       gimp_layer_set_name (animlayers[i], st);
  744.       g_free (st);
  745.       destdrawable = gimp_drawable_get (animlayers[i]);
  746.       st = g_strdup_printf (_("Warping Frame Nr %d ..."), frame_number);
  747.       gimp_progress_init (st);
  748.       g_free (st);
  749.       if (animate_deform_value >0.0)
  750.         iwarp_frame ();
  751.       gimp_image_add_layer (imageID, animlayers[i], 0);
  752.       animate_deform_value = animate_deform_value + delta;
  753.       frame_number++;
  754.     }
  755.       if (do_animate_ping_pong)
  756.     {
  757.       st = g_strdup_printf (_("Warping Frame Nr %d ..."), frame_number);
  758.       gimp_progress_init (_("Ping Pong"));
  759.       g_free (st);
  760.       for (i = 0; i < animate_num_frames; i++)
  761.         {
  762.           gimp_progress_update ((gdouble) i / (animate_num_frames - 1));
  763.           layerID = _gimp_layer_copy (animlayers[animate_num_frames-i-1],
  764.                       TRUE); 
  765.           st = g_strdup_printf (_("Frame %d"), i + animate_num_frames);
  766.           gimp_layer_set_name (layerID, st);
  767.           g_free (st);
  768.           gimp_image_add_layer (imageID, layerID, 0); 
  769.         }
  770.     }
  771.       g_free (animlayers);
  772.     } 
  773.   else
  774.     {
  775.       animate_deform_value = 1.0;
  776.       iwarp_frame ();
  777.     }
  778.   if (tile != NULL)
  779.     {
  780.       gimp_tile_unref (tile, FALSE);
  781.       tile = NULL;
  782.     }
  783. }
  784.  
  785. static guchar
  786. iwarp_transparent_color (gint x,
  787.              gint y)
  788. {
  789.   if ((y % (GIMP_CHECK_SIZE * 4)) > (GIMP_CHECK_SIZE * 2))
  790.     {
  791.       if ((x % (GIMP_CHECK_SIZE * 4)) > (GIMP_CHECK_SIZE * 2))
  792.     return GIMP_CHECK_DARK * 255;
  793.       else
  794.     return GIMP_CHECK_LIGHT * 255;
  795.     }
  796.   else
  797.     {
  798.       if ((x % (GIMP_CHECK_SIZE * 4)) < (GIMP_CHECK_SIZE * 2))
  799.     return GIMP_CHECK_DARK * 255;
  800.       else
  801.     return GIMP_CHECK_LIGHT * 255;
  802.     }
  803. }
  804.  
  805. static void
  806. iwarp_cpy_images (void)
  807. {
  808.   gint     i, j, k, p;
  809.   gdouble  alpha;
  810.   guchar  *srccolor, *dstcolor;
  811.  
  812.   if (image_bpp == 1 || image_bpp ==3) 
  813.     {
  814.       memcpy (dstimage, srcimage, preview_width * preview_height * preview_bpp);
  815.     }
  816.   else
  817.     {
  818.       for (i = 0; i< preview_width; i++) 
  819.     for (j = 0; j< preview_height; j++)
  820.       {
  821.         p = (j * preview_width + i);
  822.         srccolor = srcimage + p * image_bpp;
  823.         alpha = (gdouble) srccolor[image_bpp-1] / 255;
  824.         dstcolor = dstimage + p * preview_bpp;
  825.         for (k = 0; k < preview_bpp; k++)
  826.           {
  827.         *dstcolor++ = (guchar)
  828.           (alpha *srccolor[k]+(1.0-alpha) *
  829.            iwarp_transparent_color (i,j));
  830.           }
  831.       }  
  832.     }
  833. }
  834.  
  835. static void
  836. iwarp_init (void)
  837. {
  838.   gint       y, x, xi, i;
  839.   GimpPixelRgn  srcrgn;
  840.   guchar    *pts;
  841.   guchar    *linebuffer = NULL;
  842.   gdouble    dx, dy;
  843.  
  844.   gimp_drawable_mask_bounds (drawable->id, &xl, &yl, &xh, &yh);
  845.   sel_width = xh-xl;
  846.   sel_height = yh-yl;
  847.   image_bpp = gimp_drawable_bpp (drawable->id);
  848.   if (gimp_drawable_is_layer (drawable->id))
  849.     preserve_trans = (gimp_layer_get_preserve_transparency (drawable->id));
  850.   else
  851.     preserve_trans = FALSE;
  852.   if (image_bpp < 3)
  853.     preview_bpp = 1;
  854.   else
  855.     preview_bpp = 3;
  856.   dx = (gdouble) sel_width / MAX_PREVIEW_WIDTH;
  857.   dy = (gdouble) sel_height / MAX_PREVIEW_HEIGHT;
  858.   if (dx >dy)
  859.     pre2img = dx;
  860.   else
  861.     pre2img = dy;
  862.   if (dx <=1.0 && dy <= 1.0)
  863.     pre2img = 1.0;  
  864.   img2pre = 1.0 / pre2img;
  865.   preview_width = (gint) (sel_width / pre2img);
  866.   preview_height = (gint) (sel_height / pre2img);
  867.   tile_width = gimp_tile_width ();
  868.   tile_height = gimp_tile_height ();
  869.  
  870.   srcimage = g_new (guchar, preview_width * preview_height * image_bpp);
  871.   dstimage = g_new (guchar, preview_width * preview_height * preview_bpp);
  872.   deform_vectors = g_new (GimpVector2, preview_width * preview_height);
  873.   deform_area_vectors = g_new (GimpVector2,
  874.                    (MAX_DEFORM_AREA_RADIUS * 2 + 1) *
  875.                    (MAX_DEFORM_AREA_RADIUS * 2 + 1));
  876.   linebuffer = g_new (guchar, sel_width * image_bpp);
  877.  
  878.   for (i = 0; i < preview_width * preview_height; i++) 
  879.     deform_vectors[i].x = deform_vectors[i].y = 0.0;
  880.  
  881.   gimp_pixel_rgn_init (&srcrgn, drawable,
  882.                xl, yl, sel_width, sel_height, FALSE, FALSE);
  883.  
  884.   for (y = 0; y < preview_height; y++)
  885.     {
  886.       gimp_pixel_rgn_get_row (&srcrgn, linebuffer,
  887.                   xl, (gint) (pre2img * y) + yl, sel_width);
  888.       for (x = 0; x < preview_width; x++)
  889.     {
  890.       pts = srcimage + (y * preview_width +x) * image_bpp;
  891.       xi = (gint) (pre2img * x);
  892.       for (i = 0; i < image_bpp; i++)
  893.         {
  894.           *pts++ = linebuffer[xi*image_bpp+i];
  895.         }
  896.     }
  897.     }
  898.   iwarp_cpy_images ();
  899.   for (i = 0; i < MAX_DEFORM_AREA_RADIUS; i++)
  900.     {
  901.       filter[i] = 
  902.     pow ((cos (sqrt((gdouble) i / MAX_DEFORM_AREA_RADIUS) * G_PI) + 1) *
  903.          0.5, 0.7); /*0.7*/
  904.     }
  905.   g_free (linebuffer);
  906. }
  907.  
  908. static void
  909. iwarp_animate_dialog (GtkWidget *dlg,
  910.               GtkWidget *notebook)
  911. { 
  912.   GtkWidget *vbox;
  913.   GtkWidget *frame;
  914.   GtkWidget *table;
  915.   GtkWidget *button;
  916.   GtkObject *scale_data;
  917.  
  918.   vbox = gtk_vbox_new (FALSE, 4);
  919.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
  920.  
  921.   button = gtk_check_button_new_with_label (_("Animate"));
  922.   gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
  923.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), do_animate);
  924.   gtk_signal_connect (GTK_OBJECT (button), "toggled",
  925.                       GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  926.                       &do_animate);
  927.   gtk_widget_show (button);
  928.  
  929.   frame = gtk_frame_new (NULL);
  930.   gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
  931.   gtk_widget_show (frame);
  932.  
  933.   gtk_object_set_data (GTK_OBJECT (button), "set_sensitive", frame);
  934.   gtk_widget_set_sensitive (frame, do_animate);
  935.  
  936.   table = gtk_table_new (3, 3, FALSE);
  937.   gtk_container_set_border_width (GTK_CONTAINER (table), 4);
  938.   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  939.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  940.   gtk_container_add (GTK_CONTAINER (frame), table);
  941.   gtk_widget_show (table);
  942.  
  943.   scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
  944.                      _("Number of Frames:"), SCALE_WIDTH, 0,
  945.                      animate_num_frames,
  946.                      2, MAX_NUM_FRAMES, 1.0, 10.0, 1,
  947.                      TRUE, 0, 0,
  948.                      NULL, NULL);
  949.   gtk_signal_connect (GTK_OBJECT (scale_data), "value_changed",
  950.               GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
  951.               &animate_num_frames);
  952.  
  953.   button = gtk_check_button_new_with_label (_("Reverse"));
  954.   gtk_table_attach (GTK_TABLE (table), button, 0, 3, 1, 2,
  955.             GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0); 
  956.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  957.                       GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  958.                       &do_animate_reverse);
  959.   gtk_widget_show (button);
  960.  
  961.   button = gtk_check_button_new_with_label (_("Ping Pong"));
  962.   gtk_table_attach (GTK_TABLE (table), button, 0, 3, 2, 3,
  963.             GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0); 
  964.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  965.                       GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  966.                       &do_animate_ping_pong);
  967.   gtk_widget_show (button);
  968.  
  969.   gtk_widget_show (vbox);
  970.  
  971.   gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
  972.                 vbox,
  973.                 gtk_label_new (_("Animate")));
  974. }
  975.  
  976. static void
  977. iwarp_settings_dialog (GtkWidget *dlg,
  978.                GtkWidget *notebook)
  979. {
  980.   GtkWidget *vbox;
  981.   GtkWidget *vbox2;
  982.   GtkWidget *vbox3;
  983.   GtkWidget *hbox;
  984.   GtkWidget *frame;
  985.   GtkWidget *button;
  986.   GtkWidget *table;
  987.   GtkObject *scale_data;
  988.   GtkWidget *widget[3];
  989.   gint       i;
  990.  
  991.   vbox = gtk_vbox_new (FALSE, 4);
  992.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
  993.  
  994.   table = gtk_table_new (2, 3, FALSE);
  995.   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  996.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  997.   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
  998.   gtk_widget_show (table);
  999.  
  1000.   scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
  1001.                      _("Deform Radius:"), SCALE_WIDTH, 0,
  1002.                      iwarp_vals.deform_area_radius,
  1003.                      5.0, MAX_DEFORM_AREA_RADIUS, 1.0, 10.0, 0,
  1004.                      TRUE, 0, 0,
  1005.                      NULL, NULL);
  1006.   gtk_signal_connect (GTK_OBJECT (scale_data), "value_changed",
  1007.               GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
  1008.               &iwarp_vals.deform_area_radius);
  1009.  
  1010.   scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
  1011.                      _("Deform Amount:"), SCALE_WIDTH, 0,
  1012.                      iwarp_vals.deform_amount,
  1013.                      0.0, 1.0, 0.01, 0.1, 2,
  1014.                      TRUE, 0, 0,
  1015.                      NULL, NULL);
  1016.   gtk_signal_connect (GTK_OBJECT (scale_data), "value_changed",
  1017.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  1018.               &iwarp_vals.deform_amount);
  1019.  
  1020.   frame = gtk_frame_new (_("Deform Mode"));
  1021.   gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
  1022.   gtk_widget_show (frame);
  1023.  
  1024.   hbox = gtk_hbox_new (TRUE, 4);
  1025.   gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
  1026.   gtk_container_add (GTK_CONTAINER (frame), hbox);
  1027.   gtk_widget_show (hbox);
  1028.  
  1029.   vbox2 = gimp_radio_group_new2 (FALSE, NULL,
  1030.                  gimp_radio_button_update,
  1031.                  &iwarp_vals.deform_mode,
  1032.                  (gpointer) iwarp_vals.deform_mode,
  1033.  
  1034.                  _("Move"),      (gpointer) MOVE, NULL,
  1035.                  _("Grow"),      (gpointer) GROW, NULL,
  1036.                  _("Swirl CCW"), (gpointer) SWIRL_CCW, NULL,
  1037.                  _("Remove"),    (gpointer) REMOVE, &widget[0],
  1038.                  _("Shrink"),    (gpointer) SHRINK, &widget[1],
  1039.                  _("Swirl CW"),  (gpointer) SWIRL_CW, &widget[2],
  1040.  
  1041.                  NULL);
  1042.   gtk_container_add (GTK_CONTAINER (hbox), vbox2);
  1043.   gtk_widget_show (vbox2);
  1044.  
  1045.   vbox3 = gtk_vbox_new (FALSE, 1);
  1046.   gtk_container_add (GTK_CONTAINER (hbox), vbox3);
  1047.   gtk_widget_show (vbox3);
  1048.  
  1049.   for (i = 0; i < 3; i++)
  1050.     {
  1051.       gtk_object_ref (GTK_OBJECT (widget[i]));
  1052.       gtk_widget_hide (widget[i]);
  1053.       gtk_container_remove (GTK_CONTAINER (vbox2), widget[i]);
  1054.       gtk_box_pack_start (GTK_BOX (vbox3), widget[i],
  1055.                           FALSE, FALSE, 0);
  1056.       gtk_widget_show (widget[i]);
  1057.       gtk_object_unref (GTK_OBJECT (widget[i]));
  1058.     }
  1059.  
  1060.   button = gtk_check_button_new_with_label (_("Bilinear"));
  1061.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
  1062.                 iwarp_vals.do_bilinear);
  1063.   gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
  1064.   gtk_signal_connect (GTK_OBJECT (button), "toggled",
  1065.                       GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  1066.                       &iwarp_vals.do_bilinear);
  1067.   gtk_widget_show(button);
  1068.  
  1069.   frame = gtk_frame_new (NULL);
  1070.   gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
  1071.   gtk_widget_show (frame);
  1072.  
  1073.   vbox2 = gtk_vbox_new (FALSE, 4);
  1074.   gtk_container_set_border_width (GTK_CONTAINER (vbox2), 4);
  1075.   gtk_container_add (GTK_CONTAINER (frame), vbox2);
  1076.   gtk_widget_show (vbox2);
  1077.  
  1078.   button = gtk_check_button_new_with_label (_("Adaptive Supersample"));
  1079.   gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
  1080.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
  1081.                 iwarp_vals.do_supersample);
  1082.   gtk_signal_connect (GTK_OBJECT (button), "toggled",
  1083.                       GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  1084.                       &iwarp_vals.do_supersample);
  1085.   gtk_widget_show (button);
  1086.  
  1087.   table = gtk_table_new (2, 3, FALSE);
  1088.   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  1089.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  1090.   gtk_box_pack_start (GTK_BOX (vbox2), table, FALSE, FALSE, 0);
  1091.   gtk_widget_show (table);
  1092.  
  1093.   gtk_object_set_data (GTK_OBJECT (button), "set_sensitive", table);
  1094.   gtk_widget_set_sensitive (table, iwarp_vals.do_supersample);
  1095.  
  1096.   scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
  1097.                      _("Max Depth:"), SCALE_WIDTH, 0,
  1098.                      iwarp_vals.max_supersample_depth,
  1099.                      1.0, 5.0, 1.1, 1.0, 0,
  1100.                      TRUE, 0, 0,
  1101.                      NULL, NULL);
  1102.   gtk_signal_connect (GTK_OBJECT (scale_data), "value_changed",
  1103.               GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
  1104.               &iwarp_vals.max_supersample_depth);
  1105.  
  1106.   scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
  1107.                      _("Threshold:"), SCALE_WIDTH, 0,
  1108.                      iwarp_vals.supersample_threshold,
  1109.                      1.0, 10.0, 0.01, 0.1, 2,
  1110.                      TRUE, 0, 0,
  1111.                      NULL, NULL);
  1112.   gtk_signal_connect (GTK_OBJECT (scale_data), "value_changed",
  1113.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  1114.               &iwarp_vals.supersample_threshold);
  1115.  
  1116.   gtk_widget_show (vbox);
  1117.  
  1118.   gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
  1119.                 vbox,
  1120.                 gtk_label_new (_("Settings")));
  1121. }
  1122.  
  1123. static gboolean
  1124. iwarp_dialog (void)
  1125. {
  1126.   GtkWidget *dlg;
  1127.   GtkWidget *main_hbox;
  1128.   GtkWidget *frame;
  1129.   GtkWidget *abox;
  1130.   GtkWidget *pframe;
  1131.   GtkWidget *notebook;
  1132.  
  1133.   gimp_ui_init ("iwarp", TRUE);
  1134.  
  1135.   iwarp_init ();
  1136.  
  1137.   dlg = gimp_dialog_new (_("IWarp"), "iwarp",
  1138.              gimp_standard_help_func, "filters/iwarp.html",
  1139.              GTK_WIN_POS_MOUSE,
  1140.              FALSE, TRUE, FALSE,
  1141.  
  1142.              _("OK"), iwarp_ok_callback,
  1143.              NULL, NULL, NULL, TRUE, FALSE,
  1144.              _("Reset"), iwarp_reset_callback,
  1145.              NULL, NULL, NULL, FALSE, FALSE,
  1146.              _("Cancel"), gtk_widget_destroy,
  1147.              NULL, 1, NULL, FALSE, TRUE,
  1148.  
  1149.              NULL);
  1150.  
  1151.   gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
  1152.               GTK_SIGNAL_FUNC (gtk_main_quit),
  1153.               NULL);
  1154.  
  1155.   main_hbox = gtk_hbox_new (FALSE, 6);
  1156.   gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 6);
  1157.   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), main_hbox,
  1158.               FALSE, FALSE, 0);
  1159.  
  1160.   frame = gtk_frame_new (_("Preview"));
  1161.   gtk_box_pack_start (GTK_BOX (main_hbox), frame, FALSE, FALSE, 0);
  1162.   gtk_widget_show (frame);
  1163.  
  1164.   abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
  1165.   gtk_container_set_border_width (GTK_CONTAINER (abox), 4);
  1166.   gtk_container_add (GTK_CONTAINER (frame), abox);
  1167.   gtk_widget_show (abox);
  1168.  
  1169.   pframe = gtk_frame_new (NULL);
  1170.   gtk_frame_set_shadow_type (GTK_FRAME (pframe), GTK_SHADOW_IN);
  1171.   gtk_container_add (GTK_CONTAINER (abox), pframe);
  1172.   gtk_widget_show (pframe); 
  1173.  
  1174.   if (preview_bpp == 3)
  1175.     preview = gtk_preview_new (GTK_PREVIEW_COLOR);
  1176.   else
  1177.     preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
  1178.   gtk_preview_size (GTK_PREVIEW (preview), preview_width, preview_height);
  1179.   iwarp_update_preview (0, 0, preview_width, preview_height);
  1180.   gtk_container_add (GTK_CONTAINER (pframe), preview);
  1181.   gtk_widget_show (preview);
  1182.  
  1183.   gtk_widget_set_events (preview,
  1184.              GDK_BUTTON_PRESS_MASK |
  1185.              GDK_BUTTON_RELEASE_MASK |
  1186.              GDK_BUTTON1_MOTION_MASK | 
  1187.              GDK_POINTER_MOTION_HINT_MASK);
  1188.   gtk_signal_connect (GTK_OBJECT(preview), "event",
  1189.               GTK_SIGNAL_FUNC (iwarp_motion_callback),
  1190.               NULL);
  1191.  
  1192.   notebook = gtk_notebook_new ();
  1193.   gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
  1194.   gtk_box_pack_start (GTK_BOX (main_hbox), notebook, TRUE, TRUE, 0);
  1195.  
  1196.   iwarp_settings_dialog (dlg, notebook);
  1197.   iwarp_animate_dialog (dlg, notebook);
  1198.  
  1199.   gtk_widget_show (notebook);
  1200.  
  1201.   gtk_widget_show (main_hbox);
  1202.   gtk_widget_show (dlg);
  1203.  
  1204.   gtk_main ();
  1205.   gdk_flush ();
  1206.  
  1207.   return wint.run;   
  1208. }
  1209.  
  1210. static void 
  1211. iwarp_update_preview (gint x0,
  1212.               gint y0,
  1213.               gint x1,
  1214.               gint y1)
  1215. {
  1216.   gint i;
  1217.   GdkRectangle rect;
  1218.  
  1219.   if (x0 < 0)
  1220.     x0 = 0;
  1221.   if (y0 < 0)
  1222.     y0 = 0;
  1223.   if (x1 >= preview_width)
  1224.     x1 = preview_width;
  1225.   if (y1 >= preview_height)
  1226.     y1 = preview_height;
  1227.   for (i = y0; i < y1; i++)
  1228.     gtk_preview_draw_row (GTK_PREVIEW (preview),
  1229.               dstimage + (i * preview_width + x0) * preview_bpp,
  1230.               x0, i,x1-x0);
  1231.   rect.x = x0;
  1232.   rect.y = y0;
  1233.   rect.width = x1-x0;
  1234.   rect.height = y1-y0;  
  1235.   gtk_widget_draw (preview, &rect);
  1236.   gdk_flush ();
  1237. }
  1238.  
  1239. static void
  1240. iwarp_preview_get_pixel (gint     x,
  1241.              gint     y,
  1242.              guchar **color)
  1243. {
  1244.   static guchar black[4] = { 0, 0, 0, 0 };
  1245.  
  1246.   if (x < 0 || x >= preview_width || y<0 || y >= preview_height)
  1247.     { 
  1248.       *color = black;
  1249.       return;
  1250.     }
  1251.   *color = srcimage + (y * preview_width + x) * image_bpp; 
  1252. } 
  1253.  
  1254. static void
  1255. iwarp_preview_get_point (gdouble  x,
  1256.              gdouble  y,
  1257.              guchar  *color)
  1258. {
  1259.   gint     xi, yi, j;
  1260.   gdouble  dx, dy, m0, m1;
  1261.   guchar  *p0, *p1, *p2, *p3;
  1262.  
  1263.   xi = (gint) x;
  1264.   yi = (gint) y;
  1265.   if (iwarp_vals.do_bilinear)
  1266.     {
  1267.       dx = x-xi;
  1268.       dy = y-yi; 
  1269.       iwarp_preview_get_pixel (xi, yi, &p0);
  1270.       iwarp_preview_get_pixel (xi + 1, yi, &p1);
  1271.       iwarp_preview_get_pixel (xi, yi + 1, &p2);
  1272.       iwarp_preview_get_pixel (xi + 1, yi + 1, &p3);
  1273.       for (j = 0; j < image_bpp; j++)
  1274.     {
  1275.       m0 = p0[j] + dx * (p1[j] - p0[j]);
  1276.       m1 = p2[j] + dx * (p3[j] - p2[j]);
  1277.       color[j] = (guchar) (m0 + dy * (m1 - m0));  
  1278.     }
  1279.     }
  1280.   else
  1281.     {
  1282.       iwarp_preview_get_pixel (xi, yi, &p0);
  1283.       for (j = 0; j < image_bpp; j++)
  1284.     color[j] = p0[j];
  1285.     }
  1286. }
  1287.  
  1288. static void 
  1289. iwarp_deform (gint    x,
  1290.           int     y,
  1291.           gdouble vx,
  1292.           gdouble vy)
  1293. {
  1294.   gint    xi, yi, ptr, fptr, x0, x1, y0, y1, radius2, length2;
  1295.   gdouble deform_value, xn, yn, nvx=0, nvy=0, emh, em, edge_width, xv, yv, alpha;
  1296.   guchar  color[4];
  1297.  
  1298.   if (x - iwarp_vals.deform_area_radius <0)
  1299.     x0 = -x;
  1300.   else
  1301.     x0 = -iwarp_vals.deform_area_radius;
  1302.  
  1303.   if (x + iwarp_vals.deform_area_radius >= preview_width)
  1304.     x1 = preview_width - x - 1;
  1305.   else
  1306.     x1 = iwarp_vals.deform_area_radius;
  1307.  
  1308.   if (y - iwarp_vals.deform_area_radius < 0)
  1309.     y0 = -y;
  1310.   else
  1311.     y0 = -iwarp_vals.deform_area_radius;
  1312.  
  1313.   if (y + iwarp_vals.deform_area_radius >= preview_height)
  1314.     y1 = preview_height-y-1;
  1315.   else
  1316.     y1 = iwarp_vals.deform_area_radius;
  1317.  
  1318.   radius2 = iwarp_vals.deform_area_radius * iwarp_vals.deform_area_radius;
  1319.  
  1320.   for (yi = y0; yi <= y1; yi++)
  1321.     for (xi = x0; xi <= x1; xi++)
  1322.       {
  1323.     length2 = (xi * xi + yi * yi) * MAX_DEFORM_AREA_RADIUS / radius2;
  1324.     if (length2 < MAX_DEFORM_AREA_RADIUS)
  1325.       {
  1326.         ptr = (y + yi) * preview_width + x + xi;   
  1327.         fptr =
  1328.           (yi + iwarp_vals.deform_area_radius) *
  1329.           (iwarp_vals.deform_area_radius * 2 + 1) +
  1330.           xi +
  1331.           iwarp_vals.deform_area_radius;
  1332.  
  1333.         switch (iwarp_vals.deform_mode)
  1334.           {
  1335.           case GROW:
  1336.         deform_value = filter[length2] *  0.1* iwarp_vals.deform_amount;
  1337.         nvx = -deform_value * xi;
  1338.         nvy = -deform_value * yi;
  1339.         break;
  1340.  
  1341.           case SHRINK:
  1342.         deform_value = filter[length2] * 0.1* iwarp_vals.deform_amount;
  1343.         nvx = deform_value * xi;
  1344.         nvy = deform_value * yi;
  1345.         break;
  1346.  
  1347.           case SWIRL_CW:
  1348.         deform_value = filter[length2] * iwarp_vals.deform_amount * 0.5;
  1349.         nvx =  deform_value * yi;
  1350.         nvy = -deform_value * xi;
  1351.         break;
  1352.  
  1353.           case SWIRL_CCW:
  1354.         deform_value = filter[length2] *iwarp_vals.deform_amount * 0.5;
  1355.         nvx = -deform_value * yi;
  1356.         nvy =  deform_value  * xi;
  1357.         break;
  1358.  
  1359.           case MOVE:
  1360.         deform_value = filter[length2] * iwarp_vals.deform_amount;
  1361.         nvx = deform_value * vx;
  1362.         nvy = deform_value * vy;
  1363.         break;
  1364.  
  1365.           default:
  1366.         break;
  1367.           }
  1368.  
  1369.         if (iwarp_vals.deform_mode == REMOVE)
  1370.           {
  1371.         deform_value =
  1372.           1.0 - 0.5 * iwarp_vals.deform_amount * filter[length2];
  1373.         deform_area_vectors[fptr].x =
  1374.           deform_value * deform_vectors[ptr].x ;
  1375.         deform_area_vectors[fptr].y =
  1376.           deform_value * deform_vectors[ptr].y ;
  1377.           } 
  1378.         else
  1379.           {
  1380.         edge_width = 0.2 *  iwarp_vals.deform_area_radius;
  1381.         emh = em = 1.0;
  1382.         if (x+xi < edge_width)
  1383.           em = (gdouble) (x + xi) / edge_width;
  1384.         if (y + yi < edge_width)
  1385.           emh = (gdouble) (y + yi) / edge_width;
  1386.         if (emh <em)
  1387.           em = emh;
  1388.         if (preview_width - x - xi - 1 < edge_width)
  1389.           emh = (gdouble) (preview_width - x - xi - 1) / edge_width;
  1390.         if (emh < em)
  1391.           em = emh;
  1392.         if (preview_height-y-yi-1 < edge_width)
  1393.           emh = (gdouble) (preview_height - y - yi - 1) / edge_width;
  1394.         if (emh <em)
  1395.           em = emh;
  1396.  
  1397.         nvx = nvx * em;
  1398.         nvy = nvy * em;
  1399.  
  1400.         iwarp_get_deform_vector (nvx + x+ xi, nvy + y + yi, &xv, &yv);
  1401.         xv = nvx +xv;
  1402.         if (xv +x+xi <0.0)
  1403.           xv = -x - xi;
  1404.         else if (xv + x +xi > (preview_width-1))
  1405.           xv = preview_width - x -xi-1;
  1406.         yv = nvy +yv;
  1407.         if (yv + y + yi < 0.0)
  1408.           yv = -y - yi;
  1409.         else if (yv + y + yi > (preview_height-1))
  1410.           yv = preview_height - y -yi - 1;
  1411.         deform_area_vectors[fptr].x = xv;
  1412.         deform_area_vectors[fptr].y = yv;
  1413.           }
  1414.  
  1415.         xn = deform_area_vectors[fptr].x + x + xi;
  1416.         yn = deform_area_vectors[fptr].y + y + yi;
  1417.  
  1418.         /* gcc - shut up! */
  1419.         alpha = 1;
  1420.  
  1421.         /* Yeah, it is ugly but since color is a pointer into image-data
  1422.          * I must not change color[image_bpp - 1]  ...
  1423.          */
  1424.         if (preserve_trans && (image_bpp == 4 || image_bpp == 2))
  1425.           {
  1426.         iwarp_preview_get_point (x + xi, y + yi, color);
  1427.         alpha = (gdouble) color[image_bpp - 1] / 255;
  1428.           }
  1429.  
  1430.         iwarp_preview_get_point (xn, yn, color);
  1431.  
  1432.         if (!preserve_trans && (image_bpp == 4 || image_bpp == 2))
  1433.           {
  1434.         alpha = (gdouble) color[image_bpp - 1] / 255;
  1435.           }
  1436.  
  1437.         if (preview_bpp == 3)
  1438.           {
  1439.         if (image_bpp == 4)
  1440.           {
  1441.             dstimage[ptr*3] =
  1442.               (guchar) (alpha * color[0] +
  1443.                 (1.0 - alpha) *
  1444.                 iwarp_transparent_color (x + xi, y + yi));
  1445.             dstimage[ptr*3+1] =
  1446.               (guchar) (alpha * color[1] +
  1447.                 (1.0 - alpha) *
  1448.                 iwarp_transparent_color (x + xi, y + yi));
  1449.             dstimage[ptr*3+2] =
  1450.               (guchar) (alpha * color[2] +
  1451.                 (1.0 - alpha) *
  1452.                 iwarp_transparent_color (x + xi, y + yi));
  1453.           }
  1454.         else
  1455.           {
  1456.             dstimage[ptr*3] = color[0];
  1457.             dstimage[ptr*3+1] = color[1];
  1458.             dstimage[ptr*3+2] = color[2];
  1459.           }
  1460.           }
  1461.         else
  1462.           {
  1463.         if (image_bpp == 2)
  1464.           {
  1465.             dstimage[ptr] =
  1466.               (guchar) (alpha * color[0] +
  1467.                 (1.0 - alpha) *
  1468.                 iwarp_transparent_color (x + xi, y + yi)) ;
  1469.           }
  1470.         else
  1471.           {
  1472.             dstimage[ptr] = color[0];
  1473.           }
  1474.           }
  1475.       }
  1476.       }
  1477.  
  1478.   for (yi = y0; yi <= y1; yi++)
  1479.     for (xi = x0; xi <= x1; xi++)
  1480.       {
  1481.     length2 = (xi*xi+yi*yi) * MAX_DEFORM_AREA_RADIUS / radius2;
  1482.     if (length2 <MAX_DEFORM_AREA_RADIUS)
  1483.       {
  1484.         ptr = (yi +y) * preview_width + xi +x;
  1485.         fptr =
  1486.           (yi+iwarp_vals.deform_area_radius) *
  1487.           (iwarp_vals.deform_area_radius*2+1) +
  1488.           xi +
  1489.           iwarp_vals.deform_area_radius;
  1490.         deform_vectors[ptr].x = deform_area_vectors[fptr].x;
  1491.         deform_vectors[ptr].y = deform_area_vectors[fptr].y;
  1492.       }
  1493.       }
  1494.  
  1495.   iwarp_update_preview (x + x0, y + y0, x + x1 + 1, y + y1 + 1);   
  1496. } 
  1497.  
  1498. static void
  1499. iwarp_move (gint x,
  1500.         gint y,
  1501.         gint xx,
  1502.         gint yy)
  1503. {
  1504.   gdouble l, dx, dy, xf, yf;
  1505.   gint    num, i, x0, y0; 
  1506.  
  1507.   dx = x-xx;
  1508.   dy = y-yy;
  1509.   l= sqrt (dx * dx + dy * dy);
  1510.   num = (gint) (l * 2 / iwarp_vals.deform_area_radius) + 1;
  1511.   dx /= num;
  1512.   dy /= num;
  1513.   xf = xx + dx; yf = yy + dy; 
  1514.   for (i=0; i< num; i++)
  1515.     {
  1516.       x0 = (gint) xf;
  1517.       y0 = (gint) yf;
  1518.       iwarp_deform (x0, y0, -dx, -dy);
  1519.       xf += dx;
  1520.       yf += dy;
  1521.     }
  1522. } 
  1523.  
  1524. static void
  1525. iwarp_ok_callback (GtkWidget *widget,
  1526.             gpointer   data)
  1527. {
  1528.   wint.run = TRUE;
  1529.  
  1530.   gtk_widget_destroy (GTK_WIDGET (data));
  1531. }
  1532.  
  1533. static gint
  1534. iwarp_motion_callback (GtkWidget *widget,
  1535.                GdkEvent  *event)
  1536. {
  1537.   GdkEventButton *mb;
  1538.   gint x, y;
  1539.  
  1540.   mb = (GdkEventButton *) event; 
  1541.   switch (event->type)
  1542.     {
  1543.     case GDK_BUTTON_PRESS:
  1544.       lastx = mb->x;
  1545.       lasty = mb->y;
  1546.       break;
  1547.  
  1548.     case GDK_BUTTON_RELEASE:
  1549.       if (mb->state & GDK_BUTTON1_MASK)
  1550.     {
  1551.       x = mb->x;
  1552.       y = mb->y;
  1553.       if (iwarp_vals.deform_mode == MOVE)
  1554.         iwarp_move (x, y, lastx, lasty);
  1555.       else
  1556.         iwarp_deform (x, y, 0.0, 0.0);
  1557.     }
  1558.       break;
  1559.  
  1560.    case GDK_MOTION_NOTIFY:
  1561.      if (mb->state & GDK_BUTTON1_MASK)
  1562.        {
  1563.      x = mb->x;
  1564.      y = mb->y;
  1565.      if (iwarp_vals.deform_mode == MOVE)
  1566.        iwarp_move (x, y, lastx, lasty);
  1567.      else
  1568.        iwarp_deform (x, y, 0.0, 0.0);
  1569.      lastx = x;
  1570.      lasty = y;
  1571.      gtk_widget_get_pointer (widget, NULL, NULL); 
  1572.        }
  1573.      break;
  1574.  
  1575.     default:
  1576.       break;
  1577.     }
  1578.  
  1579.   return FALSE;
  1580. }
  1581.  
  1582. static void
  1583. iwarp_reset_callback (GtkWidget *widget,
  1584.               gpointer   data)
  1585. {
  1586.   gint i;
  1587.  
  1588.   iwarp_cpy_images ();
  1589.   for (i = 0; i < preview_width * preview_height; i++)
  1590.     deform_vectors[i].x = deform_vectors[i].y = 0.0;
  1591.  
  1592.   iwarp_update_preview (0, 0, preview_width, preview_height);   
  1593. }
  1594.