Exemplos de gimp_rgn_iterate2 em C++ (Cpp)

Exemplo n.º 1

Arquivo: colorify.c Projeto: Amerekanets/gimp

static void
colorify (GimpDrawable *drawable,
          GimpPreview  *preview)
{
  gint  i;

  for (i = 0; i < 256; i ++)
    {
      lum_red_lookup[i]     = i * GIMP_RGB_LUMINANCE_RED;
      lum_green_lookup[i]   = i * GIMP_RGB_LUMINANCE_GREEN;
      lum_blue_lookup[i]    = i * GIMP_RGB_LUMINANCE_BLUE;
      final_red_lookup[i]   = i * cvals.color.r;
      final_green_lookup[i] = i * cvals.color.g;
      final_blue_lookup[i]  = i * cvals.color.b;
    }

  if (preview)
    {
      gint    width, height, bytes;
      guchar *src;

      src = gimp_zoom_preview_get_source (GIMP_ZOOM_PREVIEW (preview),
                                        &width, &height, &bytes);
      for (i = 0; i < width * height; i++)
        colorify_func (src + i * bytes, src + i * bytes, bytes, NULL);

      gimp_preview_draw_buffer (preview, src, width * bytes);
      g_free (src);
    }
  else
    {
      gimp_rgn_iterate2 (drawable, 0 /* unused */, colorify_func, NULL);
    }
}

Exemplo n.º 2

Arquivo: contrast-normalize.c Projeto: AnonPower/picman

static void
normalize (GimpDrawable *drawable)
{
  NormalizeParam_t param;
  gint x;
  guchar  range;

  param.min = 255;
  param.max = 0;
  param.has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
  param.alpha = (param.has_alpha) ? drawable->bpp - 1 : drawable->bpp;

  gimp_rgn_iterate1 (drawable, 0 /* unused */, find_min_max, &param);

  /* Calculate LUT */

  range = param.max - param.min;

  if (range != 0)
    for (x = param.min; x <= param.max; x++)
      param.lut[x] = 255 * (x - param.min) / range;
  else
    param.lut[(gint)param.min] = param.min;

  gimp_rgn_iterate2 (drawable, 0 /* unused */, normalize_func, &param);
}

Exemplo n.º 3

Arquivo: autostretch_hsv.c Projeto: Amerekanets/gimp

static void
autostretch_hsv (GimpDrawable *drawable)
{
  AutostretchData data = {0.0, 1.0, 0.0, 1.0};

  gimp_rgn_iterate1 (drawable, 0 /* unused */, (GimpRgnFunc1) find_max, &data);
  gimp_rgn_iterate2 (drawable, 0 /* unused */, (GimpRgnFunc2) autostretch_hsv_func,
		     &data);
}

Exemplo n.º 4

Arquivo: noise-hsv.c Projeto: jdburton/gimp-osx

static void
scatter_hsv (GimpDrawable *drawable)
{
  gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));

  gimp_progress_init (_("HSV Noise"));

  gimp_rgn_iterate2 (drawable, 0 /* unused */, scatter_hsv_func, NULL);

  gimp_drawable_detach (drawable);
}

Exemplo n.º 5

Arquivo: max-rgb.c Projeto: AdamGrzonkowski/gimp-1

static GimpPDBStatusType
main_function (GimpDrawable *drawable,
               GimpPreview  *preview)
{
  MaxRgbParam_t param;

  param.init_value = (pvals.max_p > 0) ? 0 : 255;
  param.flag = (0 < pvals.max_p) ? 1 : -1;
  param.has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);

  if (preview)
    {
      gint    i;
      guchar *buffer;
      guchar *src;
      gint    width, height, bpp;

      src = gimp_zoom_preview_get_source (GIMP_ZOOM_PREVIEW (preview),
                                          &width, &height, &bpp);

      buffer = g_new (guchar, width * height * bpp);

      for (i = 0; i < width * height; i++)
        {
          max_rgb_func (src    + i * bpp,
                        buffer + i * bpp,
                        bpp,
                        &param);
        }

      gimp_preview_draw_buffer (preview, buffer, width * bpp);
      g_free (buffer);
      g_free (src);
    }
  else
    {
      gimp_progress_init (_("Max RGB"));

      gimp_rgn_iterate2 (drawable, 0 /* unused */, max_rgb_func, &param);

      gimp_drawable_detach (drawable);
    }

  return GIMP_PDB_SUCCESS;
}

Exemplo n.º 6

Arquivo: alien-map.c Projeto: AjayRamanathan/gimp

static void
alienmap2 (GimpDrawable *drawable)
{
  gimp_rgn_iterate2 (drawable, 0 /* unused */, alienmap2_func, NULL);
}

Exemplo n.º 7

Arquivo: color-to-alpha.c Projeto: Amerekanets/gimp-1

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

  run_mode = param[0].data.d_int32;

  *nreturn_vals = 1;
  *return_vals  = values;

  INIT_I18N ();

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

  image_ID = param[1].data.d_image;
  drawable = gimp_drawable_get (param[2].data.d_drawable);

  switch (run_mode)
    {
    case GIMP_RUN_INTERACTIVE:
      gimp_get_data (PLUG_IN_PROC, &pvals);
      if (! color_to_alpha_dialog (drawable))
        {
          gimp_drawable_detach (drawable);
          return;
        }
      break;

    case GIMP_RUN_NONINTERACTIVE:
      if (nparams != 4)
        status = GIMP_PDB_CALLING_ERROR;

      if (status == GIMP_PDB_SUCCESS)
        pvals.color = param[3].data.d_color;
      break;

    case GIMP_RUN_WITH_LAST_VALS:
      gimp_get_data (PLUG_IN_PROC, &pvals);
      break;

    default:
      break;
    }

  if (status == GIMP_PDB_SUCCESS &&
      gimp_drawable_is_rgb (drawable->drawable_id) &&
      gimp_item_is_layer (drawable->drawable_id))
    {
      gboolean lock_alpha;

      gimp_image_undo_group_start (image_ID);

      /*  Add alpha if not present */
      gimp_layer_add_alpha (drawable->drawable_id);

      /*  Reget the drawable, bpp might have changed  */
      drawable = gimp_drawable_get (drawable->drawable_id);

      /*  Unset 'Lock alpha'  */
      lock_alpha = gimp_layer_get_lock_alpha (drawable->drawable_id);
      gimp_layer_set_lock_alpha (drawable->drawable_id, FALSE);

      gimp_progress_init (_("Removing color"));
      gimp_rgn_iterate2 (drawable, 0 /* unused */, to_alpha_func, NULL);

      gimp_layer_set_lock_alpha (drawable->drawable_id, lock_alpha);

      gimp_image_undo_group_end (image_ID);

      if (run_mode != GIMP_RUN_NONINTERACTIVE)
        gimp_displays_flush ();
    }

  gimp_drawable_detach (drawable);

  if (run_mode == GIMP_RUN_INTERACTIVE)
    gimp_set_data (PLUG_IN_PROC, &pvals, sizeof (pvals));

  values[0].data.d_status = status;
}