如何编写GIMP插件(二)

写在前面: 本人翻译并不专业,甚至英语不好,翻译内容仅供参考。由于博主是边学边翻译,所以不能保证翻译的准确性和正确性,如果可以,请查看原版学习,本文仅作学习记录之用。

《How to write a GIMP plug-in, part II》

原文:http://developer.gimp.org/writing-a-plug-in/2/index.html

作者:Dave Neary

在第一部分,我们展示了使用gimp去构建一个插件所需要的基本要素,现在为我们的插件提供一个简单且有用的算法。

介绍

我们将要实现一个简单模糊,它将默认安装在GIMP的“滤镜 – 模糊 – 模糊”中。 这个算法非常简单,把每个像素值替换为它周围像素的平均值即可,例如,我们举一个最简单的案例,一个3×3的矩阵,值为1到9,那么中心值则为5,9个元素就是它的邻里

使用这个方法,边缘差异会导致出现一个模糊的结果,可以采用不同的半径,使用(2r+1)x(2r+1)矩阵。

<-- more -->

图像结构

我们在上个例子中写过一个run()函数,但是没有什么功能,现在我们再看一下run()的函数原形

static void run (const gchar     *name,
                 gint             nparams,
                 const GimpParam *param,
                 gint            *nreturn_vals,
                 GimpParam      **return_vals);

前三个输入参数中的第一个是运行模式,还有一个是图像的标识符,另一个是活动并可拖拽的(图层或是遮盖) ,在GIMP中的图像是一个结构体,它包含指南,图层,遮盖,以及任何和图像相关的数据。“可拖拽”经常用在GIMP内部结构,它是一个可修改的对象,所以,图层,图层遮盖,选区全都是“可拖拽”的

GimpImage.png

获取数据

为了从标识符中获取GimpDrawable结构体,我们需要使用gimp_drawable_get()函数:

GimpDrawable *gimp_drawable_get (gint32 drawable_id);

使用这个结构体,我们可以通过GimpPixelRgn结构去访问可拖拽的数据,并且可以查看可拖拽类型(RGB,灰度)。完整的关于GimpDrawable函数列表可以在官方API中查询

两个对插件来说非常重要的函数是gimp_drawable_mask_bounds() 和 gimp_pixel_rgn_init()。第一个是用来为可拖拽对象的活动选区做限制,第二个是用来初始化GimpPixelRgn

当我们初始化完GimpPixelRgn后,我们可以通过不同的方式来访问数据,如以像素,以矩形,以圆,以柱方式访问,最好的方法取决于你打算使用的算法。此外,GIMP使用tile-based结构,载入/载出数据开销是很大的,所以如非必要,我们不要经常的使用它们。

tiles.png

主函数获取和设置的函数如下:

void gimp_pixel_rgn_get_pixel (GimpPixelRgn *pr,
                               guchar       *buf,
                               gint          x,
                               gint          y);
void gimp_pixel_rgn_get_row   (GimpPixelRgn *pr,
                               guchar       *buf,
                               gint          x,
                               gint          y,
                               gint          width);
void gimp_pixel_rgn_get_col   (GimpPixelRgn *pr,
                               guchar       *buf,
                               gint          x,
                               gint          y,
                               gint          height);
void gimp_pixel_rgn_get_rect  (GimpPixelRgn *pr,
                               guchar       *buf,
                               gint          x,
                               gint          y,
                               gint          width,
                               gint          height);
void gimp_pixel_rgn_set_pixel (GimpPixelRgn *pr,
                               const guchar *buf,
                               gint          x,
                               gint          y);
void gimp_pixel_rgn_set_row   (GimpPixelRgn *pr,
                               const guchar *buf,
                               gint          x,
                               gint          y,
                               gint          width);
void gimp_pixel_rgn_set_col   (GimpPixelRgn *pr,
                               const guchar *buf,
                               gint          x,
                               gint          y,
                               gint          height);
void gimp_pixel_rgn_set_rect  (GimpPixelRgn *pr,
                               const guchar *buf,
                               gint          x,
                               gint          y,
                               gint          width,
                               gint          height);

这里还有其它方法可以访问图像数据(甚至用的更多),它允许管理数据在tile级别,稍后我们将会详细的讨论它。

更新数据

插件更新图像数据后必须提交数据到内核,告诉它应该更新显示。这是通过如下两个函数实现的:

gimp_displays_flush ();
gimp_drawable_detach (drawable);

实现blur()函数

为了尝试不同的方法,我们使用blur函数,下面是run函数实现

static void run (const gchar name, gint nparams, const GimpParam param, gint nreturn_vals, GimpParam return_vals) { static GimpParam values[1]; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpRunMode run_mode; GimpDrawable drawable;

/ Setting mandatory output values / nreturn_vals = 1; return_vals = values;

values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status;

/ Getting run_mode - we won't display a dialog if * we are in NONINTERACTIVE mode / run_mode = param[0].data.d_int32;

/ Get the specified drawable / drawable = gimp_drawable_get (param[2].data.d_drawable);

gimp_progress_init ("My Blur...");

/ Let's time blur * GTimer timer = g_timer_new time (); */

blur (drawable);

/ g_print ("blur() took %g seconds.\n", g_timer_elapsed (timer)); * g_timer_destroy (timer); /

gimp_displays_flush (); gimp_drawable_detach (drawable); }

这里我们需要解释一些行,gimp_progress_init()函数的作用是为我们的插件初始化进度条(参数就是进度条上面显示的字符串)。稍后会在blur中调用gimp_progress_update()函数,根据参数百分比打印进度条。运行模式(run_mode)决定插件是否以图形界面开始。它可以是GIMP_RUN_INTERACTIVE, GIMP_RUN_NONINTERACTIVE 或 GIMP_RUN_WITH_LAST_VALS中的一个值。它们分别是“交互式运行”,“脚本运行”,“重复上次的滤镜”。

关于模糊算法本身,如下的版本使用的是gimp_pixel_rgn_(get|set)_pixel()函数,我们暂时还没有对它进行说明。

gimp_drawable_mask_bounds()是用来计算滤镜影响的范围,不包括任何非活动区域,通过这种方式限制处理可以提高性能。

gimp_pixel_rgn_init()根据指定参数初始化像素区域,两个bool变量存储着GimpPixelRgn的行为,如果dirty变量和shadow变量都为FALSE,那么这个GimpPixelRgn是用来读取的,如果都为TRUE,那么这个GimpPixelRgn是用来写的,其它的组合很少使用。

static void
blur (GimpDrawable *drawable)
{
  gint         i, j, k, channels;
  gint         x1, y1, x2, y2;
  GimpPixelRgn rgn_in, rgn_out;
  guchar       output[4];

  /* Gets upper left and lower right coordinates,
   * and layers number in the image */
  gimp_drawable_mask_bounds (drawable-&gt;drawable_id,
                             &amp;x1, &amp;y1,
                             &amp;x2, &amp;y2);
  channels = gimp_drawable_bpp (drawable-&gt;drawable_id);

  /* Initialises two PixelRgns, one to read original data,
   * and the other to write output data. That second one will
   * be merged at the end by the call to
   * gimp_drawable_merge_shadow() */
  gimp_pixel_rgn_init (&amp;rgn_in,
                       drawable,
                       x1, y1,
                       x2 - x1, y2 - y1,
                       FALSE, FALSE);
  gimp_pixel_rgn_init (&amp;rgn_out,
                       drawable,
                       x1, y1,
                       x2 - x1, y2 - y1,
                       TRUE, TRUE);

  for (i = x1; i &lt; x2; i++)
    {
      for (j = y1; j &lt; y2; j++)
        {
          guchar pixel[9][4];

          /* Get nine pixels */
          gimp_pixel_rgn_get_pixel (&amp;rgn_in,
                                    pixel[0],
                                    MAX (i - 1, x1),
                                    MAX (j - 1, y1));
          gimp_pixel_rgn_get_pixel (&amp;rgn_in,
                                    pixel[1],
                                    MAX (i - 1, x1),
                                    j);
          gimp_pixel_rgn_get_pixel (&amp;rgn_in,
                                    pixel[2],
                                    MAX (i - 1, x1),
                                    MIN (j + 1, y2 - 1));

          gimp_pixel_rgn_get_pixel (&amp;rgn_in,
                                    pixel[3],
                                    i,
                                    MAX (j - 1, y1));
          gimp_pixel_rgn_get_pixel (&amp;rgn_in,
                                    pixel[4],
                                    i,
                                    j);
          gimp_pixel_rgn_get_pixel (&amp;rgn_in,
                                    pixel[5],
                                    i,
                                    MIN (j + 1, y2 - 1));

          gimp_pixel_rgn_get_pixel (&amp;rgn_in,
                                    pixel[6],
                                    MIN (i + 1, x2 - 1),
                                    MAX (j - 1, y1));
          gimp_pixel_rgn_get_pixel (&amp;rgn_in,
                                    pixel[7],
                                    MIN (i + 1, x2 - 1),
                                    j);
          gimp_pixel_rgn_get_pixel (&amp;rgn_in,
                                    pixel[8],
                                    MIN (i + 1, x2 - 1),
                                    MIN (j + 1, y2 - 1));

          /* For each layer, compute the average of the
           * nine */
          for (k = 0; k &lt; channels; k++)
            {
              int tmp, sum = 0;
              for (tmp = 0; tmp &lt; 9; tmp++)
                sum += pixel[tmp][k];
              output[k] = sum / 9;
            }

          gimp_pixel_rgn_set_pixel (&amp;rgn_out,
                                    output,
                                    i, j);
        }

      if (i % 10 == 0)
        gimp_progress_update ((gdouble) (i - x1) / (gdouble) (x2 - x1));
    }

  /*  Update the modified region */
  gimp_drawable_flush (drawable);
  gimp_drawable_merge_shadow (drawable-&gt;drawable_id, TRUE);
  gimp_drawable_update (drawable-&gt;drawable_id,
                        x1, y1,
                        x2 - x1, y2 - y1);
}

按行处理

我们的函数有一个致命的缺点:性能,一个300×300的选区,在我的K6-2 350MHz处理需要12分钟,同样的选区,使用高斯模糊则仅仅需要3秒钟。

如果我们使用gimp_pixel_rgn_(get|set)_row()函数处理,那么速度会快很多,使用blur() v2版本,处理300×300的选区所需时间从760秒降到6秒钟。

static void
blur (GimpDrawable *drawable)
{
  gint         i, j, k, channels;
  gint         x1, y1, x2, y2;
  GimpPixelRgn rgn_in, rgn_out;
  guchar      *row1, *row2, *row3;
  guchar      *outrow;

  gimp_drawable_mask_bounds (drawable-&gt;drawable_id,
                             &amp;x1, &amp;y1,
                             &amp;x2, &amp;y2);
  channels = gimp_drawable_bpp (drawable-&gt;drawable_id);

  gimp_pixel_rgn_init (&amp;rgn_in,
                       drawable,
                       x1, y1,
                       x2 - x1, y2 - y1,
                       FALSE, FALSE);
  gimp_pixel_rgn_init (&amp;rgn_out,
                       drawable,
                       x1, y1,
                       x2 - x1, y2 - y1,
                       TRUE, TRUE);

  /* Initialise enough memory for row1, row2, row3, outrow */
  row1 = g_new (guchar, channels * (x2 - x1));
  row2 = g_new (guchar, channels * (x2 - x1));
  row3 = g_new (guchar, channels * (x2 - x1));
  outrow = g_new (guchar, channels * (x2 - x1));

  for (i = y1; i &lt; y2; i++)
    {
      /* Get row i-1, i, i+1 */
      gimp_pixel_rgn_get_row (&amp;rgn_in,
                              row1,
                              x1, MAX (y1, i - 1),
                              x2 - x1);
      gimp_pixel_rgn_get_row (&amp;rgn_in,
                              row2,
                              x1, i,
                              x2 - x1);
      gimp_pixel_rgn_get_row (&amp;rgn_in,
                              row3,
                              x1, MIN (y2 - 1, i + 1),
                              x2 - x1);

      for (j = x1; j &lt; x2; j++)
        {
          /* For each layer, compute the average of the nine
           * pixels */
          for (k = 0; k &lt; channels; k++)
            {
              int sum = 0;
              sum = row1[channels * MAX ((j - 1 - x1), 0) + k]           +
                    row1[channels * (j - x1) + k]                        +
                    row1[channels * MIN ((j + 1 - x1), x2 - x1 - 1) + k] +
                    row2[channels * MAX ((j - 1 - x1), 0) + k]           +
                    row2[channels * (j - x1) + k]                        +
                    row2[channels * MIN ((j + 1 - x1), x2 - x1 - 1) + k] +
                    row3[channels * MAX ((j - 1 - x1), 0) + k]           +
                    row3[channels * (j - x1) + k]                        +
                    row3[channels * MIN ((j + 1 - x1), x2 - x1 - 1) + k];
              outrow[channels * (j - x1) + k] = sum / 9;
            }

       }

       gimp_pixel_rgn_set_row (&amp;rgn_out,
                               outrow,
                               x1, i,
                               x2 - x1);

       if (i % 10 == 0)
            gimp_progress_update ((gdouble) (i - y1) / (gdouble) (y2 - y1));
  }

  g_free (row1);
  g_free (row2);
  g_free (row3);
  g_free (outrow);

  gimp_drawable_flush (drawable);
  gimp_drawable_merge_shadow (drawable-&gt;drawable_id, TRUE);
  gimp_drawable_update (drawable-&gt;drawable_id,
                        x1, y1,
                        x2 - x1, y2 - y1);
}

来看一下完整的blur1.cblur2.c

第三部分

我们将改造我们的插件,使其可以根据我们提供的参数来处理