BlobStats: blobstats-1.0.c

/* BlobStats -- GIMP plug-in to display and report image blob statistics
 * Version 1.0 Released June 11, 2009
 *
 * By Adam C. Powell, IV of Opennovation
 * Copyright (C) 2008-2009 ZPower, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the ZPower nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY ZPOWER AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL ZPOWER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * The GIMP -- an image manipulation program
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 *
 * BlobStats is a GIMP plug-in for calculating and reporting statistics on
 * "blobs" in images.  Roughly speaking, it does the following:
 *
 *  - Find each individual "blob" with intensity above a given threshold.
 *  - Calculate the zeroth (area), first (centroid) and second (width) moments
 *    of each blob.
 *  - Create different colored shapes for each blob against a transparent
 *    background (if drawable is RGB not grayscale).
 *  - Draw lines using the current brush, foreground color and opacity
 *    representing the major and minor axes of the ellipsoid fitting each blob
 *    based on its second moments, and centered at its centroid.
 *  - Optionally save each blob's moment statistics, along with derived
 *    properties such as aspect ratio and orientation angle, in a CSV (comma-
 *    separated values) file for later processing using spreadsheet software.
 *
 * This has many potential uses in materials science, for example:
 *
 *  - Calculate the density and spatial distribution of precipitates or grains
 *    (if grain boundaries are sufficiently clear).
 *  - Calculate particle size mean and standand deviation, or plot a histogram.
 *  - Statistics on 2-D aspect ratios correlate with those of 3-D particles
 *    etc.
 *
 * Embedding this within GIMP brings along all of its tools, for example:
 *
 *  - One can set the foreground color, brush and opacity to any values, these
 *    are used to draw the ellipsoid axes.
 *  - It can be helpful to duplicate a layer before using BlobStats; the
 *    resulting blobs and axes look compelling against the original background.
 *  - Grainy images can probably go through a blurring process before using
 *    BlobStats (see Filters -> Blur for some examples).
 *  - To find dark blobs in a bright background, use Colors -> Invert before
 *    using BlobStats.
 *  - Use other Edge-Detect filters to convert the detected blobs to outlines.
 *
 * COMPILATION INSTRUCTIONS:
 *
 * On Debian, Ubuntu and other Debian-based systems, install the packages
 * libgimp2.0-dev, libc6-dev and gcc.  Then type:
 *
 * gimptool-2.0 --install blobstats.c
 *
 * (Ignore the "no previous prototype" warnings, this single-file plugin
 * doesn't need prototypes.)
 * When GIMP next starts, the Filters -> Edge-Detect menu should now have an
 * entry for BlobStats.  You can re-compile and re-install it on the fly
 * without quitting GIMP.
 *
 * BUGS:
 *
 *  - I can't for the life of me figure out how to draw the axes on the preview
 *    window.
 *
 * FUTURE POSSIBILITIES:
 *
 *  - Select the channel for finding blobs and calculating moments from
 *    intensity, alpha, red, green, blue.
 *  - Have blob parameters, such as orientation, aspect ratio and size,
 *    determine the blob color.
 *  - Replace string entry with a file dialog to select the CSV file name.
 */

#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include <libgimp/gimptypes.h>
#include <gtk/gtkstyle.h>
#include <glib/gmacros.h>
#include <glib/gtypes.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>


G_BEGIN_DECLS

#define PLUG_IN_BINARY  "blobstats"
#define PLUG_IN_PROC    "plug-in-blobstats"

#define TILE_WIDTH  gimp_tile_width()
#define TILE_HEIGHT gimp_tile_height()

G_END_DECLS

struct bs_savable {
  gfloat                threshold;
  gfloat                color_opacity;
  gboolean              save_csv;
  gchar                 filename [256];
};

typedef struct {
  gint32                drawable_ID;
  struct bs_savable     p;
} BlobStatsParam;

BlobStatsParam *blobstats_param_new (gint32 drawable_ID)
{
  BlobStatsParam *param;

  if (!(param = g_new0 (BlobStatsParam, 1)))
    return NULL;

  param->drawable_ID      = drawable_ID;
  param->p.threshold      = 0.5;
  param->p.color_opacity  = 0.4;
  param->p.save_csv       = FALSE;
  strcpy (param->p.filename, "output.csv");

  return param;
}

gboolean blobstats_param_set (BlobStatsParam *param, gint gimp_nparams,
                              const GimpParam *gimp_param)
{
  g_assert (param);
  g_assert (gimp_param);

  if (gimp_nparams != 9)
    return FALSE;

  param->p.threshold     = CLAMP (gimp_param[3].data.d_float, 0., 1.);
  param->p.color_opacity = CLAMP (gimp_param[6].data.d_float, 0., 1.);
  param->p.save_csv      = (gimp_param[7].data.d_int32 != -1) ? TRUE : FALSE;
  return TRUE;
}

gboolean blobstats_param_restore (BlobStatsParam *param)
{
  const gsize size = sizeof (struct bs_savable);

  g_assert (param);

  if (gimp_procedural_db_get_data_size (PLUG_IN_PROC) != size)
    return FALSE;

  return gimp_procedural_db_get_data (PLUG_IN_PROC, &(param->p));
}

gboolean blobstats_param_store (BlobStatsParam *param)
{
  g_assert (param);

  return gimp_procedural_db_set_data (PLUG_IN_PROC, &(param->p),
                                      sizeof (struct bs_savable));
}

typedef struct {
  gdouble area;
  gdouble xavg, yavg;
  gdouble xxwid, yywid, xywid;
  gdouble majaxis, minaxis;
  gdouble aspect_ratio;
  gdouble angle;
} BlobMoments;

// Calculate the moments of a guint8 field
BlobMoments blobstats_moments (guint8 *field, int pixskip, int rowskip,
                               int width, int height)
{
  int x, y;
  BlobMoments moments = { 0.,0.,0.,0.,0.,0.,0.,0.,0.,0. };

  // Calculate zero and first moments
  for (y=0; y<height; y++)
    for (x=0; x<width; x++)
      {
        double pixel = (double)(field [y*rowskip + x*pixskip])/255.;
        moments.area += pixel;
        moments.xavg += pixel * x;
        moments.yavg += pixel * y;
      }
  moments.xavg /= moments.area;
  moments.yavg /= moments.area;

  // Calculate second moments
  for (y=0; y<height; y++)
    for (x=0; x<width; x++)
      {
        double pixel = (double)(field [y*rowskip + x*pixskip])/255.;
        double xoff = pixel * (moments.xavg - x);
        double yoff = pixel * (moments.yavg - y);
        moments.xxwid += xoff * xoff;
        moments.yywid += yoff * yoff;
        moments.xywid += xoff * yoff;
      }
  moments.xxwid = sqrt (moments.xxwid/moments.area);
  moments.yywid = sqrt (moments.yywid/moments.area);
  // This looks funny, but it preserves the sign of xywid
  moments.xywid /= sqrt (fabs(moments.xywid*moments.area));

  return moments;
}

// This calculates the moments of all pixels equal to "value"
BlobMoments blobstats_moments_value (guint8 *field, guint8 value, int pixskip,
                                     int rowskip, int width, int height)
{
  int x, y;
  BlobMoments moments = { 0.,0.,0.,0.,0.,0.,0.,0.,0.,0. };

  // Calculate zero and first moments
  for (y=0; y<height; y++)
    for (x=0; x<width; x++)
      if (field [y*rowskip + x*pixskip] == value)
        {
          moments.area += 1.;
          moments.xavg += x;
          moments.yavg += y;
        }
  moments.xavg /= moments.area;
  moments.yavg /= moments.area;

  // Calculate second moments
  for (y=0; y<height; y++)
    for (x=0; x<width; x++)
      if (field [y*rowskip + x*pixskip] == value)
        {
          double xoff = (moments.xavg - x);
          double yoff = (moments.yavg - y);
          moments.xxwid += xoff * xoff;
          moments.yywid += yoff * yoff;
          moments.xywid += xoff * yoff;
      }

  // Calculate axes, ratio, and angle
  moments.majaxis = (moments.xxwid+moments.yywid) +
    sqrt ((moments.xxwid-moments.yywid) * (moments.xxwid-moments.yywid) +
          4. * moments.xywid * moments.xywid);
  moments.minaxis = (moments.xxwid+moments.yywid) -
    sqrt ((moments.xxwid-moments.yywid) * (moments.xxwid-moments.yywid) +
          4. * moments.xywid * moments.xywid);
  moments.angle = 0.5 * atan2 (2.*moments.xywid, moments.xxwid-moments.yywid);

  // Now normalize them all
  moments.xxwid = sqrt (moments.xxwid/moments.area);
  moments.yywid = sqrt (moments.yywid/moments.area);
  // This looks funny, but it preserves the sign of xywid
  if (moments.xywid != 0.)
    moments.xywid /= sqrt (fabs(moments.xywid*moments.area));

  moments.majaxis = sqrt (2.*moments.majaxis/moments.area);
  moments.minaxis = sqrt (2.*moments.minaxis/moments.area);
  moments.aspect_ratio = moments.majaxis / moments.minaxis;

  return moments;  
}

// Pixel values in the "meaning field"
#define EMPTY   0
#define FILLED  1
#define NEWBLOB 2
#define COLOR0  16 // red
#define COLOR1  17 // green
#define COLOR2  18 // blue
#define COLOR3  19 // yellow
#define COLOR4  20 // cyan
#define COLOR5  21 // magenta
#define COLOR6  22 // pink
#define COLOR7  23 // lightgreen
#define COLOR8  24 // lightblue
#define COLOR9  25 // orange

#define COLORLIST                                                       \
  { 1.,0.,0.,   /* red */                                               \
      0.,1.,0., /* green */                                             \
      0.,0.,1., /* blue */                                              \
      1.,1.,0., /* yellow */                                            \
      1.,0.,1., /* magenta */                                           \
      0.,1.,1., /* cyan */                                              \
      1.,.5,.5, /* pink */                                              \
      .5,1.,.5, /* lightgreen */                                        \
      .5,.5,1., /* lightblue */                                         \
      1.,.5,0.  /* orange */ }

#define COLORNAMES { "Red", "Green", "Blue", "Yellow", "Magenta", \
      "Cyan", "Pink", "Light Green", "Light Blue", "Orange" }

#define FIELD(x,y) (field [(y)*rowskip + (x)*pixskip])

// Recursive function which fills a region of value "value" with "new_value"
//  starting at a point
void blobline (guint8 *field, guint8 value, int new_value, int pixskip,
               int rowskip, int width, int height, int xstart, int y)
{
  int x1;

  if (FIELD (xstart,y) != value)
    {
      printf ("Blobline algorithm error\n");
      return;
    }

  // Fill in this contiguous blob line with new_value
  while (xstart>0 && FIELD (xstart-1,y) == value)
    xstart--;
  for (x1=xstart; x1<width && FIELD (x1,y) == value; x1++)
    FIELD (x1,y) = new_value;

  // Check previous and next lines for value, blobline them if it's there
  for (x1=xstart; x1<width && FIELD (x1,y) == new_value; x1++)
    {
      if (y>0)
        if (FIELD (x1,y-1) == value)
          blobline (field, value, new_value, pixskip, rowskip, width, height,
                    x1, y-1);

      if (y<height-1)
        if (FIELD (x1,y+1) == value)
          blobline (field, value, new_value, pixskip, rowskip, width, height,
                    x1, y+1);
    }
}

// This locates a contiguous region of value "value", and replaces it with
// "new_value"; returns TRUE if it found a blob, FALSE otherwise.
gboolean find_blob (guint8 *field, guint8 value, int new_value,
                    int pixskip, int rowskip, int width, int height)
{
  int x=width, y;

  // Look for value and return FALSE if not found
  for (y=0; y<height && x == width; y++)
    for (x=0; x<width && FIELD (x,y) != value; x++)
      ;
  if (--y == height-1 && x == width)
    return FALSE;

  // Fill in the blob using the recursive blobline function
  blobline (field, value, new_value, pixskip, rowskip, width, height, x, y);

  return TRUE;
}

gboolean blobstats_analyze (GimpPreview *preview, BlobStatsParam *bs_param)
{
  int blobnum=0, win_width, win_height, x,y, x1,x2,y1,y2, pixskip,rowskip, i,
    num_moms=10;
  guint8 *source_data, color=COLOR0;
  gboolean has_selection;
  FILE *csv_file = NULL;
  GimpDrawable *drawable;
  GimpPixelRgn source_region, output_region;
  BlobMoments *mom;

  if (!(mom = malloc (num_moms * sizeof (BlobMoments))))
    return FALSE;

  if (!(drawable = (GimpDrawable *) gimp_drawable_get (bs_param->drawable_ID)))
    return FALSE;
  has_selection = gimp_drawable_mask_bounds (bs_param->drawable_ID,
                                             &x1, &y1, &x2, &y2);
  pixskip = drawable->bpp;
  rowskip = (x2-x1) * pixskip;

  // Get source region and data
  if (!(source_data = g_new (guchar, pixskip * (x2-x1) * (y2-y1))))
    return FALSE;
  gimp_pixel_rgn_init (&source_region, drawable, x1, y1, x2-x1, y2-y1, FALSE,
                       FALSE);
  gimp_pixel_rgn_get_rect (&source_region, source_data, x1, y1, x2-x1, y2-y1);

  if (preview)
    {
      int px1, py1, px2, py2;

      gimp_preview_get_position (GIMP_PREVIEW (preview), &px1, &py1);
      gimp_preview_get_size (GIMP_PREVIEW (preview), &win_width, &win_height);
      px2 = px1 + win_width;
      py2 = py1 + win_height;

      if (px2 <= x1 || px1 >= x2 || py2 <= y1 || py1 >= y2)
        return TRUE;

      x1 = MAX (x1, px1);
      x2 = MIN (x2, px2);
      y1 = MAX (y1, py1);
      y2 = MIN (y2, py2);
    }

  win_width = x2-x1;
  win_height = y2-y1;

  if (!preview && bs_param->p.save_csv)
    {
      if (!(csv_file = fopen (bs_param->p.filename, "w")))
        printf ("Error: cannot open CSV file %s\n", bs_param->p.filename);
      else
        {
          fprintf (csv_file, "BlobStats GIMP plug-in output\n\n");
          fprintf (csv_file, "Blob #,Color,Area,Center X,Center Y,"
                   "Width XX,Width YY,Width XY,Maj Axis,Min Axis,"
                   "Asp Ratio,Orientation\n");
        }
    }

  // Identify the blobs
  for (y=0; y<win_height; y++)
    {
    for (x=0; x<win_width; x++)
      {
        guint8 source_intensity =
          (source_data [(y1+y)*rowskip + (x1+x)*pixskip] +
           source_data [(y1+y)*rowskip + (x1+x)*pixskip + 1] +
           source_data [(y1+y)*rowskip + (x1+x)*pixskip + 2]) /3;

        source_data [(y1+y)*rowskip + (x1+x)*pixskip] =
          (source_intensity > bs_param->p.threshold * 255) ? FILLED : EMPTY;
        /*if (csv_file)
          fprintf (csv_file, "%c%c%c%c ",
                   'a'+source_data [(y1+y)*rowskip + (x1+x)*pixskip]/10,
                   'a'+source_data [(y1+y)*rowskip + (x1+x)*pixskip + 1]/10,
                   'a'+source_data [(y1+y)*rowskip + (x1+x)*pixskip + 2]/10,
                   'a'+source_intensity/10);*/
      }
    //if (csv_file)
    //  fprintf (csv_file, "\n");
    }

  // Mark contiguous blobs and save their data
  while (find_blob (source_data + y1*rowskip + x1*pixskip, FILLED, NEWBLOB,
                    pixskip, rowskip, win_width, win_height))
    {
      char *color_names [10] = COLORNAMES;

      if (blobnum >= num_moms)
        if (!(mom = realloc (mom, (num_moms *= 2) * sizeof (BlobMoments))))
          return FALSE;

      mom [blobnum] = blobstats_moments_value
        (source_data + y1*rowskip + x1*pixskip, NEWBLOB, pixskip, rowskip,
         win_width, win_height);

      for (y=0; y<win_height; y++)
        for (x=0; x<win_width; x++)
          if (source_data [(y1+y)*rowskip + (x1+x)*pixskip] == NEWBLOB)
            source_data [(y1+y)*rowskip + (x1+x)*pixskip] = color;

      // Ignore single-point blobs (many of which are often off-window)
      if (mom[blobnum].area > 1)
        {
          if (csv_file)
            fprintf (csv_file, "%d,%s,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g\n",
                     blobnum, color_names [color-COLOR0], mom[blobnum].area,
                     mom[blobnum].xavg, mom[blobnum].yavg,
                     mom[blobnum].xxwid, mom[blobnum].yywid, mom[blobnum].xywid,
                     mom[blobnum].majaxis, mom[blobnum].minaxis,
                     mom[blobnum].aspect_ratio,
                     gimp_rad_to_deg(mom[blobnum].angle));

          blobnum++;
          if (++color > COLOR9)
            color = COLOR0;
        }
    }

  if (csv_file)
    fclose (csv_file);

  // Put blob colors in source data
  for (y=0; y<source_region.h; y++)
    for (x=0; x<source_region.w; x++)
      {
        guint8 pixel = source_data [(y1+y)*rowskip + (x1+x)*pixskip];
        if (pixel >= COLOR0 && pixel <= COLOR9)
          {
            float colorlist [30] = COLORLIST;

            source_data [(y1+y)*rowskip + (x1+x)*pixskip] =
              255 * colorlist [(pixel - COLOR0) *3];
            source_data [(y1+y)*rowskip + (x1+x)*pixskip + 1] =
              255 * colorlist [(pixel - COLOR0) *3 +1];
            source_data [(y1+y)*rowskip + (x1+x)*pixskip + 2] =
              255 * colorlist [(pixel - COLOR0) *3 +2];
            if (pixskip == 4)
              source_data [(y1+y)*rowskip + (x1+x)*pixskip + 3] =
                255 * bs_param->p.color_opacity;
          }
        else
          {
            source_data [(y1+y)*rowskip + (x1+x)*pixskip] =
              source_data [(y1+y)*rowskip + (x1+x)*pixskip + 1] =
              source_data [(y1+y)*rowskip + (x1+x)*pixskip + 2] = 0;
            if (pixskip == 4)
              source_data [(y1+y)*rowskip + (x1+x)*pixskip + 3] = 0;
          }
      }

  // Create and draw to output region
  gimp_pixel_rgn_init (&output_region, drawable, x1, y1, win_width, win_height,
                       (preview == NULL), TRUE);

  gimp_pixel_rgn_set_rect
    (&output_region, source_data + y1*rowskip, 0, y1,
     rowskip/pixskip, win_height);

  // Draw region into preview, or update 
  if (preview)
    gimp_drawable_preview_draw_region (GIMP_DRAWABLE_PREVIEW (preview),
                                       &output_region);
  else
    {
      gimp_drawable_flush (drawable);
      gimp_drawable_merge_shadow (bs_param->drawable_ID, TRUE);
      gimp_drawable_update (bs_param->drawable_ID, x1, y1, win_width, win_height);

      // Draw the axes onto the image
      // Can't for the life of me figure out how to do this for the preview...
      for (i=0; i<blobnum; i++)
        {
          const gdouble linepoints [8] = {
            mom [i].xavg+x1 - mom[i].majaxis*cos(mom[i].angle),
            mom [i].yavg+y1 - mom[i].majaxis*sin(mom[i].angle),
            mom [i].xavg+x1 + mom[i].majaxis*cos(mom[i].angle),
            mom [i].yavg+y1 + mom[i].majaxis*sin(mom[i].angle),
            mom [i].xavg+x1 - mom[i].minaxis*sin(mom[i].angle),
            mom [i].yavg+y1 + mom[i].minaxis*cos(mom[i].angle),
            mom [i].xavg+x1 + mom[i].minaxis*sin(mom[i].angle),
            mom [i].yavg+y1 - mom[i].minaxis*cos(mom[i].angle) } ;

          gimp_context_set_paint_mode (GIMP_NORMAL_MODE);
          gimp_pencil (bs_param->drawable_ID, 4, linepoints);
          gimp_pencil (bs_param->drawable_ID, 4, linepoints+4);
        }
    }

  free (mom);
  // Not sure why I can't free this, but it segfaults if I do...
  //g_free (source_data);

  return TRUE;
}

void sensitize_filename_hbox (GtkToggleButton *csv_toggle,
                                     GtkWidget *filename_hbox)
{
  gtk_widget_set_sensitive (filename_hbox,
                            gtk_toggle_button_get_active (csv_toggle));
}

gboolean blobstats_dialog (BlobStatsParam *bs_param)
{
  GtkWidget *dialog, *main_vbox, *preview, *entry_table, *csv_toggle,
    *filename_hbox, *file_label, *filename_entry;
  GtkObject *threshold, *color_opacity;
  GimpDrawable *drawable;
  gint run;

  if (!(drawable = (GimpDrawable *) gimp_drawable_get (bs_param->drawable_ID)))
    return 0;

  gimp_ui_init (PLUG_IN_BINARY, TRUE);

  // Dialog window
  dialog = gimp_dialog_new ("BlobStats", PLUG_IN_BINARY, NULL, 0,
                            gimp_standard_help_func, PLUG_IN_PROC,
                            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                            GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);

  gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
  gimp_window_set_transient (GTK_WINDOW (dialog));

  // Main vbox
  main_vbox = gtk_vbox_new (FALSE, 4);
  gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 5);
  gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog) -> vbox), main_vbox);
  gtk_widget_show (main_vbox);

  // Effect preview
  preview = gimp_drawable_preview_new (drawable, NULL);
  gtk_box_pack_start (GTK_BOX (main_vbox), preview, FALSE, TRUE, 0);
  gtk_widget_show (preview);

  g_signal_connect (G_OBJECT (preview), "invalidated",
                    G_CALLBACK (blobstats_analyze),
                    bs_param);
  /* g_signal_connect (G_OBJECT (gimp_preview_get_area (GIMP_PREVIEW (preview))),
                    "button_press_event",
                    G_CALLBACK (blobstats_preview_button_press),
                    param); */

  // Float parameter entry table
  entry_table = gtk_table_new (4, 3, FALSE);
  gtk_table_set_col_spacings (GTK_TABLE (entry_table), 3);
  gtk_table_set_row_spacings (GTK_TABLE (entry_table), 3);
  gtk_box_pack_start (GTK_BOX (main_vbox), entry_table, FALSE, FALSE, 0);
  gtk_widget_show (entry_table);

  threshold = gimp_scale_entry_new (GTK_TABLE (entry_table), 0, 0,
                                    "Threshold", 1, 0, bs_param->p.threshold,
                                    0., 1., 0.01, 0.1, 2, TRUE, 0, 0,
                                    NULL, NULL);
  g_signal_connect (G_OBJECT (threshold), "value-changed",
                    G_CALLBACK (gimp_float_adjustment_update),
                    &(bs_param->p.threshold));
  g_signal_connect_swapped (G_OBJECT (threshold), "value-changed",
                            G_CALLBACK (gimp_preview_invalidate), preview);

  color_opacity = gimp_scale_entry_new (GTK_TABLE (entry_table), 0, 3,
                                        "Blob color opacity", 1, 0,
                                        bs_param->p.color_opacity,
                                        0., 1., 0.01, 0.1, 2, TRUE, 0, 0,
                                        NULL, NULL);
  g_signal_connect (G_OBJECT (color_opacity), "value-changed",
                    G_CALLBACK (gimp_float_adjustment_update),
                    &(bs_param->p.color_opacity));
  g_signal_connect_swapped (G_OBJECT (color_opacity), "value-changed",
                            G_CALLBACK (gimp_preview_invalidate), preview);

  // CSV file toggle
  csv_toggle = gtk_check_button_new_with_mnemonic ("Save CSV file");
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (csv_toggle),
                                bs_param->p.save_csv);
  gtk_box_pack_start (GTK_BOX (main_vbox), csv_toggle, FALSE, FALSE, 0);
  gtk_widget_show (csv_toggle);
  g_signal_connect (G_OBJECT (csv_toggle), "toggled",
                    G_CALLBACK (gimp_toggle_button_update),
                    &(bs_param->p.save_csv));

  // CSV file name entry (no signals, get its value when done)
  filename_hbox = gtk_hbox_new (FALSE, 2);
  gtk_container_border_width (GTK_CONTAINER (filename_hbox), 3);
  gtk_box_pack_start (GTK_BOX (main_vbox), filename_hbox, FALSE, FALSE, 0);
  gtk_widget_show(filename_hbox);

  file_label = gtk_label_new ("CSV file name:");
  gtk_box_pack_start (GTK_BOX (filename_hbox), file_label, FALSE, FALSE, 0);
  gtk_widget_show(file_label);

  filename_entry = gtk_entry_new ();
  gtk_box_pack_start (GTK_BOX (filename_hbox), filename_entry, TRUE, TRUE, 0);
  if (bs_param->p.filename[0])
    gtk_entry_set_text (GTK_ENTRY (filename_entry), bs_param->p.filename);
  gtk_widget_set_sensitive (filename_hbox, bs_param->p.save_csv);
  gtk_widget_show(filename_entry);

  g_signal_connect (G_OBJECT (csv_toggle), "toggled",
                    G_CALLBACK (sensitize_filename_hbox),
                    filename_hbox);

  // Display, run, and destroy the dialog
  gtk_widget_show (dialog);
  run = ((gimp_dialog_run (GIMP_DIALOG (dialog))) == GTK_RESPONSE_OK);

  strncpy (bs_param->p.filename,
           gtk_entry_get_text (GTK_ENTRY (filename_entry)), 254);
  bs_param->p.filename [255] = '\0';

  gtk_widget_destroy (dialog);

  return run;
}

static void query (void)
{
  static const GimpParamDef args[] = {
    {GIMP_PDB_INT32,    "run_mode",      "Interactive, non-interactive"},
    {GIMP_PDB_IMAGE,    "image",         "Input image"},
    {GIMP_PDB_DRAWABLE, "drawable",      "Input drawable"},
    {GIMP_PDB_FLOAT,    "threshold",     "Blob threshold"},
    {GIMP_PDB_INT32,    "axes_width",    "Blob axes width"},
    {GIMP_PDB_FLOAT,    "axes_opacity",  "Blob axes opacity"},
    {GIMP_PDB_FLOAT,    "color_opacity", "Blob color opacity"},
    {GIMP_PDB_INT8,     "save_csv",      "Save CSV output file (TRUE,FALSE)"},
    {GIMP_PDB_STRING,   "filename",      "CSV output filename"},
  };

  gimp_install_procedure (PLUG_IN_PROC,
                          "Display and report image blob statistics",
                          "This plug-in analyzes, displays, and reports the "
                          "area, centroid, and ellipsoid fit major/minor axes "
                          "(based on second moments) of blobs whose intensity "
                          "exceeds the threshold value.",
                          "Adam C. Powell, IV <apowell@opennovation.com>",
                          "Adam C. Powell, IV",
                          "2008-2009",
                          "BlobStats...",
                          "RGB*, GRAY*",
                          GIMP_PLUGIN,
                          G_N_ELEMENTS (args), 0,
                          args,
                          NULL);

  gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Filters/Edge-Detect");
}

static void run (const gchar *name, gint nparams, const GimpParam *param,
                 gint *nreturn_vals, GimpParam **return_vals)
{
  static GimpParam   values[1];
  GimpRunMode        run_mode;
  GimpPDBStatusType  status;
  gint32             drawable_ID;
  BlobStatsParam     *bs_param;

  run_mode    = param[0].data.d_int32;
  drawable_ID = param[2].data.d_drawable;

  // Make sure drawable is RGB
  if (!gimp_drawable_is_rgb (drawable_ID))
    {
      status = GIMP_PDB_EXECUTION_ERROR;
      goto blobstats_exit;
    }

  // Create new parameter structure
  if (! (bs_param = blobstats_param_new (drawable_ID)))
    {
      status = GIMP_PDB_EXECUTION_ERROR;
      goto blobstats_exit;
    }

  switch (run_mode)
    {
    case GIMP_RUN_INTERACTIVE:
      blobstats_param_restore (bs_param);

      if (! blobstats_dialog (bs_param))
        {
          status = GIMP_PDB_SUCCESS;
          goto blobstats_exit;
        }
      break;

    case GIMP_RUN_NONINTERACTIVE:
      if (! blobstats_param_set (bs_param, nparams, param))
        {
          status = GIMP_PDB_CALLING_ERROR;
          goto blobstats_exit;
        }
      break;

    case GIMP_RUN_WITH_LAST_VALS:
      if (! blobstats_param_restore (bs_param))
        {
          status = GIMP_PDB_CALLING_ERROR;
          goto blobstats_exit;
        }
      break;
    }

  // Run the algorithm
  if (blobstats_analyze (NULL, bs_param))
    status = GIMP_PDB_SUCCESS;
  else
    status = GIMP_PDB_EXECUTION_ERROR;

  if (run_mode == GIMP_RUN_INTERACTIVE)
    blobstats_param_store (bs_param);

  if (run_mode != GIMP_RUN_NONINTERACTIVE)
    gimp_displays_flush ();

 blobstats_exit:

  values[0].type          = GIMP_PDB_STATUS;
  values[0].data.d_status = status;
  *nreturn_vals = G_N_ELEMENTS (values);
  *return_vals  = values;
}

const GimpPlugInInfo PLUG_IN_INFO = { NULL, NULL, query, run };

// GIMP plug-in MAIN function from libgimp/gimp.h
MAIN()