自学教程：C++ GEGL_IS_BUFFER函数代码示例

voidgimp_gegl_apply_shrink (GeglBuffer          *src_buffer,                        GimpProgress        *progress,                        const gchar         *undo_desc,                        GeglBuffer          *dest_buffer,                        const GeglRectangle *dest_rect,                        gint                 radius_x,                        gint                 radius_y,                        gboolean             edge_lock){  GeglNode *node;  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));  node = gegl_node_new_child (NULL,                              "operation", "gimp:shrink",                              "radius-x",  radius_x,                              "radius-y",  radius_y,                              "edge-lock", edge_lock,                              NULL);  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,                             node, dest_buffer, dest_rect);  g_object_unref (node);}

voidgimp_gegl_apply_gaussian_blur (GeglBuffer          *src_buffer,                               GimpProgress        *progress,                               const gchar         *undo_desc,                               GeglBuffer          *dest_buffer,                               const GeglRectangle *dest_rect,                               gdouble              std_dev_x,                               gdouble              std_dev_y){  GeglNode *node;  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));  node = gegl_node_new_child (NULL,                              "operation", "gegl:gaussian-blur",                              "std-dev-x", std_dev_x,                              "std-dev-y", std_dev_y,                              NULL);  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,                             node, dest_buffer, dest_rect);  g_object_unref (node);}

voidgimp_gegl_apply_color_reduction (GeglBuffer   *src_buffer,                                 GimpProgress *progress,                                 const gchar  *undo_desc,                                 GeglBuffer   *dest_buffer,                                 gint          bits,                                 gint          dither_type){  GeglNode *node;  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));  node = gegl_node_new_child (NULL,                              "operation",       "gegl:color-reduction",                              "red-bits",        bits,                              "green-bits",      bits,                              "blue-bits",       bits,                              "alpha-bits",      bits,                              "dither-strategy", dither_type,                              NULL);  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,                             node, dest_buffer, NULL);  g_object_unref (node);}

voidgimp_gegl_apply_transform (GeglBuffer            *src_buffer,                           GimpProgress          *progress,                           const gchar           *undo_desc,                           GeglBuffer            *dest_buffer,                           GimpInterpolationType  interpolation_type,                           GimpMatrix3           *transform){  GeglNode *node;  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));  node = gegl_node_new_child (NULL,                              "operation", "gegl:transform",                              "sampler",   interpolation_type,                              NULL);  gimp_gegl_node_set_matrix (node, transform);  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,                             node, dest_buffer, NULL);  g_object_unref (node);}

/** * mypaint_gegl_tiled_surface_set_buffer: * @buffer: (transfer full): The buffer which shall back this surface. * */voidmypaint_gegl_tiled_surface_set_buffer(MyPaintGeglTiledSurface *self, GeglBuffer *buffer){    if (buffer && self->buffer == buffer) {        return;    }    if (self->buffer) {        g_object_unref(self->buffer);    }    if (buffer) {        g_return_if_fail(GEGL_IS_BUFFER(buffer));        g_object_ref(buffer);        self->buffer = buffer;    } else {        // Using GeglBuffer with aligned tiles for zero-copy access        self->buffer = GEGL_BUFFER(g_object_new(GEGL_TYPE_BUFFER,                          "x", self->extent_rect.x, "y", self->extent_rect.y,                          "width", self->extent_rect.width, "height", self->extent_rect.height,                          "format", self->format,                          "tile-width", self->parent.tile_size, "tile-height", self->parent.tile_size,                          NULL));    }    g_assert(GEGL_IS_BUFFER(self->buffer));    self->parent.threadsafe_tile_requests = buffer_is_native(self);}

static voidset_buffer (GeglSampler *self, GeglBuffer *buffer){  if (self->buffer != buffer)    {      if (GEGL_IS_BUFFER (self->buffer))        {          g_signal_handlers_disconnect_by_func (self->buffer,                                                G_CALLBACK (buffer_contents_changed),                                                self);          g_object_remove_weak_pointer ((GObject*) self->buffer, (void**) &self->buffer);        }      if (GEGL_IS_BUFFER (buffer))        {          self->buffer = buffer;          g_object_add_weak_pointer ((GObject*) self->buffer, (void**) &self->buffer);          g_signal_connect (buffer, "changed",                            G_CALLBACK (buffer_contents_changed),                            self);        }      else        self->buffer = NULL;      buffer_contents_changed (buffer, NULL, self);    }}

voidgimp_gegl_apply_opacity (GeglBuffer    *src_buffer,                         GimpProgress  *progress,                         const gchar   *undo_desc,                         GeglBuffer    *dest_buffer,                         GeglBuffer    *mask,                         gint           mask_offset_x,                         gint           mask_offset_y,                         gdouble        opacity){  GeglNode *node;  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));  g_return_if_fail (mask == NULL || GEGL_IS_BUFFER (mask));  node = gimp_gegl_create_apply_opacity_node (mask,                                              mask_offset_x,                                              mask_offset_y,                                              opacity);  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,                             node, dest_buffer, NULL);  g_object_unref (node);}

voidgimp_gegl_apply_scale (GeglBuffer            *src_buffer,                       GimpProgress          *progress,                       const gchar           *undo_desc,                       GeglBuffer            *dest_buffer,                       GimpInterpolationType  interpolation_type,                       gdouble                x,                       gdouble                y){  GeglNode *node;  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));  node = gegl_node_new_child (NULL,                              "operation", "gegl:scale-ratio",                              "origin-x",   0.0,                              "origin-y",   0.0,                              "sampler",    interpolation_type,                              "x",          x,                              "y",          y,                              NULL);  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,                             node, dest_buffer, NULL);  g_object_unref (node);}

GimpUndo *gimp_image_undo_push_drawable (GimpImage    *image,                               const gchar  *undo_desc,                               GimpDrawable *drawable,                               GeglBuffer   *buffer,                               gint          x,                               gint          y){  GimpItem *item;  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);  g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);  g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL);  item = GIMP_ITEM (drawable);  g_return_val_if_fail (gimp_item_is_attached (item), NULL);  return gimp_image_undo_push (image, GIMP_TYPE_DRAWABLE_UNDO,                               GIMP_UNDO_DRAWABLE, undo_desc,                               GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE,                               "item",   item,                               "buffer", buffer,                               "x",      x,                               "y",      y,                               NULL);}

/** * gimp_layer_new_from_gegl_buffer: * @buffer:     The buffer to make the new layer from. * @dest_image: The image the new layer will be added to. * @format:     The #Babl format of the new layer. * @name:       The new layer's name. * @opacity:    The new layer's opacity. * @mode:       The new layer's mode. * * Copies %buffer to a layer taking into consideration the * possibility of transforming the contents to meet the requirements * of the target image type * * Return value: The new layer. **/GimpLayer *gimp_layer_new_from_gegl_buffer (GeglBuffer           *buffer,                                 GimpImage            *dest_image,                                 const Babl           *format,                                 const gchar          *name,                                 gdouble               opacity,                                 GimpLayerModeEffects  mode,                                 GimpColorProfile     *buffer_profile){  GimpLayer *layer;  g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL);  g_return_val_if_fail (GIMP_IS_IMAGE (dest_image), NULL);  g_return_val_if_fail (format != NULL, NULL);  g_return_val_if_fail (buffer_profile == NULL ||                        GIMP_IS_COLOR_PROFILE (buffer_profile), NULL);  /*  do *not* use the buffer's format because this function gets   *  buffers of any format passed, and converts them   */  layer = gimp_layer_new (dest_image,                          gegl_buffer_get_width  (buffer),                          gegl_buffer_get_height (buffer),                          format,                          name, opacity, mode);  gimp_layer_new_convert_buffer (layer, buffer, buffer_profile, NULL);  return layer;}

gbooleangimp_gegl_mask_is_empty (GeglBuffer *buffer){  GeglBufferIterator *iter;  g_return_val_if_fail (GEGL_IS_BUFFER (buffer), FALSE);  iter = gegl_buffer_iterator_new (buffer, NULL, 0, babl_format ("Y float"),                                   GEGL_BUFFER_READ, GEGL_ABYSS_NONE);  while (gegl_buffer_iterator_next (iter))    {      gfloat *data = iter->data[0];      gint    i;      for (i = 0; i < iter->length; i++)        {          if (data[i])            {              gegl_buffer_iterator_stop (iter);              return FALSE;            }        }    }  return TRUE;}

voidgimp_create_image_from_buffer (Gimp       *gimp,                               GeglBuffer *buffer){  GimpImage  *image;  GimpLayer  *layer;  const Babl *format;  g_return_if_fail (GIMP_IS_GIMP (gimp));  g_return_if_fail (GEGL_IS_BUFFER (buffer));  format = gegl_buffer_get_format (buffer);  image = gimp_create_image (gimp,                             gegl_buffer_get_width  (buffer),                             gegl_buffer_get_height (buffer),                             gimp_babl_format_get_base_type (format),                             gimp_babl_format_get_precision (format),                             FALSE);  layer = gimp_layer_new_from_buffer (buffer, image, format,                                      "Debug Image",                                      GIMP_OPACITY_OPAQUE,                                      GIMP_NORMAL_MODE);  gimp_image_add_layer (image, layer, NULL, -1, FALSE);  gimp_create_display (gimp, image, GIMP_UNIT_PIXEL, 1.0);}

voidgimp_channel_combine_buffer (GimpChannel    *mask,                             GeglBuffer     *add_on_buffer,                             GimpChannelOps  op,                             gint            off_x,                             gint            off_y){  GeglBuffer *buffer;  gint        x, y, w, h;  g_return_if_fail (GIMP_IS_CHANNEL (mask));  g_return_if_fail (GEGL_IS_BUFFER (add_on_buffer));  buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (mask));  if (! gimp_gegl_mask_combine_buffer (buffer, add_on_buffer,                                       op, off_x, off_y))    return;  gimp_rectangle_intersect (off_x, off_y,                            gegl_buffer_get_width  (add_on_buffer),                            gegl_buffer_get_height (add_on_buffer),                            0, 0,                            gimp_item_get_width  (GIMP_ITEM (mask)),                            gimp_item_get_height (GIMP_ITEM (mask)),                            &x, &y, &w, &h);  mask->bounds_known = FALSE;  gimp_drawable_update (GIMP_DRAWABLE (mask), x, y, w, h);}

voidgegl_render_op (GeglBuffer *source_buffer,                GeglBuffer *target_buffer,                const gchar *first_property_name,                ...){    va_list var_args;    g_return_if_fail (GEGL_IS_BUFFER (source_buffer));    g_return_if_fail (GEGL_IS_BUFFER (target_buffer));    va_start (var_args, first_property_name);    gegl_render_op_valist (source_buffer, target_buffer,                           first_property_name, var_args);    va_end (var_args);}

gbooleangimp_gegl_mask_is_empty (GeglBuffer *buffer){  GeglBufferIterator *iter;  const Babl         *format;  gint                bpp;  g_return_val_if_fail (GEGL_IS_BUFFER (buffer), FALSE);  format = gegl_buffer_get_format (buffer);  bpp    = babl_format_get_bytes_per_pixel (format);  iter = gegl_buffer_iterator_new (buffer, NULL, 0, format,                                   GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 1);  while (gegl_buffer_iterator_next (iter))    {      if (! gegl_memeq_zero (iter->items[0].data, bpp * iter->length))        {          gegl_buffer_iterator_stop (iter);          return FALSE;        }    }  return TRUE;}

voidgimp_applicator_set_mask_buffer (GimpApplicator *applicator,                                 GeglBuffer     *mask_buffer){  g_return_if_fail (GIMP_IS_APPLICATOR (applicator));  g_return_if_fail (mask_buffer == NULL || GEGL_IS_BUFFER (mask_buffer));  if (applicator->mask_buffer == mask_buffer)    return;  gegl_node_set (applicator->mask_node,                 "buffer", mask_buffer,                 NULL);  if (mask_buffer)    {      gegl_node_connect_to (applicator->mask_offset_node, "output",                            applicator->mode_node,        "aux2");    }  else    {      gegl_node_disconnect (applicator->mode_node, "aux2");    }  applicator->mask_buffer = mask_buffer;}

GimpTransformResizegimp_drawable_transform_get_effective_clip (GimpDrawable        *drawable,                                            GeglBuffer          *orig_buffer,                                            GimpTransformResize  clip_result){  g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), clip_result);  g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)),                                               clip_result);  g_return_val_if_fail (orig_buffer == NULL || GEGL_IS_BUFFER (orig_buffer),                        clip_result);  /*  Always clip unfloated buffers since they must keep their size  */  if (GIMP_IS_CHANNEL (drawable))    {      if (orig_buffer)        {          if (! babl_format_has_alpha (gegl_buffer_get_format (orig_buffer)))            clip_result = GIMP_TRANSFORM_RESIZE_CLIP;        }      else        {          GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));          if (gimp_channel_is_empty (gimp_image_get_mask (image)))            clip_result = GIMP_TRANSFORM_RESIZE_CLIP;        }    }  return clip_result;}

GimpBuffer *gimp_buffer_new (GeglBuffer    *buffer,                 const gchar   *name,                 gint           offset_x,                 gint           offset_y,                 gboolean       copy_pixels){  GimpBuffer *gimp_buffer;  g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL);  g_return_val_if_fail (name != NULL, NULL);  gimp_buffer = g_object_new (GIMP_TYPE_BUFFER,                              "name", name,                              NULL);  if (copy_pixels)    gimp_buffer->buffer = gegl_buffer_dup (buffer);  else    gimp_buffer->buffer = g_object_ref (buffer);  gimp_buffer->offset_x = offset_x;  gimp_buffer->offset_y = offset_y;  return gimp_buffer;}

GeglNode *gimp_gegl_add_buffer_source (GeglNode   *parent,                             GeglBuffer *buffer,                             gint        offset_x,                             gint        offset_y){  GeglNode *buffer_source;  g_return_val_if_fail (GEGL_IS_NODE (parent), NULL);  g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL);  buffer_source = gegl_node_new_child (parent,                                       "operation", "gegl:buffer-source",                                       "buffer",    buffer,                                       NULL);  if (offset_x != 0 || offset_y != 0)    {      GeglNode *translate =        gegl_node_new_child (parent,                             "operation", "gegl:translate",                             "x",         (gdouble) offset_x,                             "y",         (gdouble) offset_y,                             NULL);      gegl_node_connect_to (buffer_source, "output",                            translate,     "input");      buffer_source = translate;    }  return buffer_source;}

GimpDrawable *gimp_drawable_transform_paste (GimpDrawable     *drawable,                               GeglBuffer       *buffer,                               GimpColorProfile *buffer_profile,                               gint              offset_x,                               gint              offset_y,                               gboolean          new_layer){  GimpImage   *image;  GimpLayer   *layer     = NULL;  const gchar *undo_desc = NULL;  g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);  g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL);  g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL);  g_return_val_if_fail (GIMP_IS_COLOR_PROFILE (buffer_profile), NULL);  image = gimp_item_get_image (GIMP_ITEM (drawable));  if (GIMP_IS_LAYER (drawable))    undo_desc = C_("undo-type", "Transform Layer");  else if (GIMP_IS_CHANNEL (drawable))    undo_desc = C_("undo-type", "Transform Channel");  else    return NULL;  gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE, undo_desc);  if (new_layer)    {      layer =        gimp_layer_new_from_gegl_buffer (buffer, image,                                         gimp_drawable_get_format_with_alpha (drawable),                                         _("Transformation"),                                         GIMP_OPACITY_OPAQUE,                                         gimp_image_get_default_new_layer_mode (image),                                         buffer_profile);      gimp_item_set_offset (GIMP_ITEM (layer), offset_x, offset_y);      floating_sel_attach (layer, drawable);      drawable = GIMP_DRAWABLE (layer);    }  else    {      gimp_drawable_set_buffer_full (drawable, TRUE, NULL,                                     buffer,                                     offset_x, offset_y,                                     TRUE);    }  gimp_image_undo_group_end (image);  return drawable;}

gbooleangegl_buffer_set_abyss (GeglBuffer          *buffer,                       const GeglRectangle *abyss){  g_return_val_if_fail(GEGL_IS_BUFFER(buffer), FALSE);  buffer->abyss = *abyss;  return TRUE;}

voidgimp_gegl_apply_flatten (GeglBuffer    *src_buffer,                         GimpProgress  *progress,                         const gchar   *undo_desc,                         GeglBuffer    *dest_buffer,                         const GimpRGB *background){  GeglNode *node;  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));  g_return_if_fail (background != NULL);  node = gimp_gegl_create_flatten_node (background);  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,                             node, dest_buffer, NULL);  g_object_unref (node);}

voidgimp_gegl_apply_invert_linear (GeglBuffer    *src_buffer,                               GimpProgress  *progress,                               const gchar   *undo_desc,                               GeglBuffer    *dest_buffer){  GeglNode *node;  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));  node = gegl_node_new_child (NULL,                              "operation", "gegl:invert-linear",                              NULL);  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,                             node, dest_buffer, NULL);  g_object_unref (node);}

voidgimp_gegl_apply_feather (GeglBuffer   *src_buffer,                         GimpProgress *progress,                         const gchar  *undo_desc,                         GeglBuffer   *dest_buffer,                         gdouble       radius_x,                         gdouble       radius_y){  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));  /* 3.5 is completely magic and picked to visually match the old   * gaussian_blur_region() on a crappy laptop display   */  gimp_gegl_apply_gaussian_blur (src_buffer,                                 progress, undo_desc,                                 dest_buffer,                                 radius_x / 3.5,                                 radius_y / 3.5);}

voidgegl_operation_context_set_object (GeglOperationContext *context,                                   const gchar          *padname,                                   GObject              *data){  g_return_if_fail (!data || GEGL_IS_BUFFER (data));  /* Make it simple, just add an extra ref and then take the object */  if (data)    g_object_ref (data);  gegl_operation_context_take_object (context, padname, data);}

voidgegl_apply_op (GeglBuffer *buffer,               const gchar *first_property_name,               ...){    va_list var_args;    g_return_if_fail (GEGL_IS_BUFFER (buffer));    va_start (var_args, first_property_name);    gegl_apply_op_valist (buffer, first_property_name, var_args);    va_end (var_args);}

voidgegl_operation_context_take_object (GeglOperationContext *context,                                    const gchar          *padname,                                    GObject              *data){  GValue *storage;  g_return_if_fail (context != NULL);  g_return_if_fail (!data || GEGL_IS_BUFFER (data));  storage = gegl_operation_context_add_value (context, padname);  g_value_take_object (storage, data);}

voidgimp_gegl_apply_threshold (GeglBuffer    *src_buffer,                           GimpProgress  *progress,                           const gchar   *undo_desc,                           GeglBuffer    *dest_buffer,                           gdouble        value){  GeglNode *node;  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));  node = gegl_node_new_child (NULL,                              "operation", "gegl:threshold",                              "value",     value,                              NULL);  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,                             node, dest_buffer, NULL);  g_object_unref (node);}

voidgegl_apply_op_valist (GeglBuffer  *buffer,                      const gchar *first_property_name,                      va_list      var_args){    GeglBuffer  *tempbuf = NULL;    GeglNode    *node;    GeglNode    *source;    GeglNode    *sink;    g_return_if_fail (GEGL_IS_BUFFER (buffer));    g_object_ref (buffer);    source  = gegl_node_new_child (NULL, "operation", "gegl:buffer-source",                                   "buffer", buffer,                                   NULL);    node   = gegl_node_new_child (NULL, "operation", first_property_name, NULL);    if (!GEGL_IS_OPERATION_POINT_FILTER (node->operation))    {        tempbuf = gegl_buffer_new (gegl_buffer_get_extent (buffer), gegl_buffer_get_format (buffer));        sink = gegl_node_new_child (NULL, "operation", "gegl:write-buffer",                                    "buffer", tempbuf,                                    NULL);    }    else    {        sink = gegl_node_new_child (NULL, "operation", "gegl:write-buffer",                                    "buffer", buffer,                                    NULL);    }    gegl_node_link_many (source, node, sink, NULL);    gegl_node_set_props (node, var_args);    gegl_node_process (sink);    g_object_unref (source);    g_object_unref (node);    g_object_unref (sink);    if (tempbuf)    {        gegl_buffer_copy (tempbuf, NULL, buffer, NULL);        g_object_unref (tempbuf);    }    g_object_unref (buffer);}