gimp/pdb/groups/image.pdb

# GIMP - The GNU Image Manipulation Program
# Copyright (C) 1995 Spencer Kimball and Peter Mattis

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <https://www.gnu.org/licenses/>.

# "Perlized" from C source by Manish Singh <yosh@gimp.org>

sub image_is_valid {
    $blurb = 'Returns TRUE if the image is valid.';

    $help = <<'HELP';
This procedure checks if the given image ID is valid and refers to an
existing image.
HELP

    &neo_pdb_misc('2007', '2.4');

    @inargs = (
        { name => 'image', type => 'image', no_validate => 1,
          desc => 'The image to check' }
    );

    @outargs = (
        { name => 'valid', type => 'boolean',
          desc => 'Whether the image ID is valid' }
    );

    %invoke = (
        code => <<'CODE'
{
  valid = GIMP_IS_IMAGE (image);
}
CODE
    );
}

sub image_list {
    $blurb = 'Returns the list of images currently open.';

    $help = <<'HELP';
This procedure returns the list of images currently open in GIMP.
HELP

    &std_pdb_misc;

    @outargs = (
        { name => 'image_ids', type => 'int32array',
          desc => 'The list of images currently open. The returned value must be freed with g_free()',
          array => { name => 'num_images',
                     desc => 'The number of images currently open' } }
    );

    %invoke = (
        code => <<CODE
{
  GList *list = gimp_get_image_iter (gimp);

  num_images = g_list_length (list);

  if (num_images)
    {
      gint i;

      image_ids = g_new (gint32, num_images);

      for (i = 0; i < num_images; i++, list = g_list_next (list))
        image_ids[i] = gimp_image_get_ID (GIMP_IMAGE (list->data));
    }
}
CODE
    );
}

sub image_new {
    $blurb = 'Creates a new image with the specified width, height, and type.';

    $help = <<'HELP';
Creates a new image, undisplayed, with the specified extents and
type. A layer should be created and added before this image is
displayed, or subsequent calls to gimp_display_new() with this image
as an argument will fail. Layers can be created using the
gimp_layer_new() commands. They can be added to an image using the
gimp_image_insert_layer() command.


If your image's type if INDEXED, a colormap must also be added with
gimp_image_set_colormap(). An indexed image without a colormap will
output unexpected colors.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'width', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
          desc => 'The width of the image' },
        { name => 'height', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
          desc => 'The height of the image' },
        { name => 'type', type => 'enum GimpImageBaseType',
          desc => 'The type of image' }
    );

    @outargs = (
        { name => 'image', type => 'image',
          desc => 'The ID of the newly created image' }
    );

    %invoke = (
        code => <<'CODE'
{
  image = gimp_create_image (gimp, width, height, type,
                             GIMP_PRECISION_U8_GAMMA, FALSE);

  if (! image)
    success = FALSE;
}
CODE
    );
}

sub image_new_with_precision {
    $blurb = 'Creates a new image with the specified width, height, type and precision.';

    $help = <<'HELP';
Creates a new image, undisplayed with the specified extents, type
and precision. Indexed images can only be created at GIMP_PRECISION_U8_GAMMA
precision. See gimp_image_new() for further details.
HELP

    &mitch_pdb_misc('2012', '2.10');

    @inargs = (
        { name => 'width', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
          desc => 'The width of the image' },
        { name => 'height', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
          desc => 'The height of the image' },
        { name => 'type', type => 'enum GimpImageBaseType',
          desc => 'The type of image' },
        { name => 'precision', type => 'enum GimpPrecision',
          desc => 'The precision' }
    );

    @outargs = (
        { name => 'image', type => 'image',
          desc => 'The ID of the newly created image' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (gimp->plug_in_manager->current_plug_in)
    gimp_plug_in_enable_precision (gimp->plug_in_manager->current_plug_in);

  if (gimp_babl_is_valid (type, precision))
    {
      image = gimp_create_image (gimp, width, height, type,
                                 precision, FALSE);
      if (! image)
        success = FALSE;
    }
  else
    success = FALSE;
}
CODE
    );
}

sub image_duplicate {
    $blurb = 'Duplicate the specified image';

    $help = <<'HELP';
This procedure duplicates the specified image, copying all layers, channels,
and image information.
HELP

    &std_pdb_misc;
    $date = '1997';

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'new_image', type => 'image',
          desc => 'The new, duplicated image' }
    );

    %invoke = (
        headers => [ qw("core/gimpimage-duplicate.h") ],
        code => <<'CODE'
{
  new_image = gimp_image_duplicate (image);

  if (! new_image)
    success = FALSE;
}
CODE
    );
}

sub image_delete {
    $blurb = 'Delete the specified image.';

    $help = <<'HELP';
If there are no displays associated with this image it will be deleted.
This means that you can not delete an image through the PDB that was
created by the user. If the associated display was however created
through the PDB and you know the display ID, you may delete the display.
Removal of the last associated display will then delete the image.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (gimp_image_get_display_count (image) == 0)
    g_object_unref (image);
  else
    success = FALSE;
}
CODE
    );
}

sub image_get_layers {
    $blurb = 'Returns the list of layers contained in the specified image.';

    $help = <<HELP;
This procedure returns the list of layers contained in the specified image.
The order of layers is from topmost to bottommost.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'layer_ids', type => 'int32array',
          desc => 'The list of layers contained in the image. The returned value must be freed with g_free()',
          array => { name => 'num_layers',
                     desc => 'The number of layers contained in the image' } }
    );

    %invoke = (
        code => <<'CODE'
{
  GList *list = gimp_image_get_layer_iter (image);

  num_layers = g_list_length (list);

  if (num_layers)
    {
      gint i;

      layer_ids = g_new (gint32, num_layers);

      for (i = 0; i < num_layers; i++, list = g_list_next (list))
        layer_ids[i] = gimp_item_get_ID (GIMP_ITEM (list->data));
    }
}
CODE
    );
}

sub image_get_channels {
    $blurb = 'Returns the list of channels contained in the specified image.';

    $help = <<HELP;
This procedure returns the list of channels contained in the specified image.
This does not include the selection mask, or layer masks. The order is from
topmost to bottommost. Note that "channels" are custom channels and do not
include the image's color components.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'channel_ids', type => 'int32array',
          desc => 'The list of channels contained in the image. The returned value must be freed with g_free()',
          array => { name => 'num_channels',
                     desc => 'The number of channels contained in the image' } }
    );

    %invoke = (
        code => <<'CODE'
{
  GList *list = gimp_image_get_channel_iter (image);

  num_channels = g_list_length (list);

  if (num_channels)
    {
      gint i;

      channel_ids = g_new (gint32, num_channels);

      for (i = 0; i < num_channels; i++, list = g_list_next (list))
        channel_ids[i] = gimp_item_get_ID (GIMP_ITEM (list->data));
    }
}
CODE
    );
}

sub image_get_vectors {
    $blurb = 'Returns the list of vectors contained in the specified image.';

    $help = <<HELP;
This procedure returns the list of vectors contained in the specified image.
HELP

    &simon_pdb_misc('2005', '2.4');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'vector_ids', type => 'int32array',
          desc => 'The list of vectors contained in the image. The returned value must be freed with g_free()',
          array => { name => 'num_vectors',
                     desc => 'The number of vectors contained in the image' } }
    );

    %invoke = (
        code => <<'CODE'
{
  GList *list = gimp_image_get_vectors_iter (image);

  num_vectors = g_list_length (list);

  if (num_vectors)
    {
      gint i;

      vector_ids = g_new (gint32, num_vectors);

      for (i = 0; i < num_vectors; i++, list = g_list_next (list))
        vector_ids[i] = gimp_item_get_ID (GIMP_ITEM (list->data));
    }
}
CODE
    );
}

sub image_unset_active_channel {
    $blurb = 'Unsets the active channel in the specified image.';

    $help = <<'HELP';
If an active channel exists, it is unset. There then exists no active
channel, and if desired, one can be set through a call to 'Set Active
Channel'. No error is returned in the case of no existing active
channel.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    %invoke = (
        code => <<'CODE'
{
  gimp_image_unset_active_channel (image);
}
CODE
    );
}

sub image_pick_color {
    $blurb = <<'BLURB';
Determine the color at the given drawable coordinates
BLURB

    $help = <<'HELP';
This tool determines the color at the specified coordinates. The
returned color is an RGB triplet even for grayscale and indexed
drawables. If the coordinates lie outside of the extents of the
specified drawable, then an error is returned. If the drawable has an
alpha channel, the algorithm examines the alpha value of the drawable
at the coordinates. If the alpha value is completely transparent (0),
then an error is returned. If the sample_merged parameter is TRUE,
the data of the composite image will be used instead of that for the
specified drawable. This is equivalent to sampling for colors after
merging all visible layers. In the case of a merged sampling, the
supplied drawable is ignored.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'drawable', type => 'drawable', none_ok => 1,
          desc => 'The drawable to pick from' },
        { name => 'x', type => 'float',
          desc => 'x coordinate of upper-left corner of rectangle' },
        { name => 'y', type => 'float',
          desc => 'y coordinate of upper-left corner of rectangle' },
        { name => 'sample_merged', type => 'boolean',
          desc => 'Use the composite image, not the drawable' },
        { name => 'sample_average', type => 'boolean',
          desc => 'Average the color of all the pixels in a specified
                   radius' },
        { name => 'average_radius', type => '0 < float', no_validate => 1,
          desc => 'The radius of pixels to average' }
    );

    @outargs = (
        { name => 'color', type => 'color', has_alpha => 1, void_ret => 1,
          desc => 'The return color' }
    );

    %invoke = (
        headers => [ qw("core/gimpimage-pick-color.h" "core/gimppickable.h") ],
        code => <<'CODE'
{
  if (!sample_merged)
    if (!drawable || (gimp_item_get_image (GIMP_ITEM (drawable)) != image))
      success = FALSE;

  if (success && sample_average)
    {
      if (average_radius <= 0.0)
        success = FALSE;
    }

  if (success)
    {
      if (sample_merged)
        gimp_pickable_flush (GIMP_PICKABLE (image));
      else
        gimp_pickable_flush (GIMP_PICKABLE (drawable));

      success = gimp_image_pick_color (image,
                                       drawable,
                                       (gint) x, (gint) y,
                                       sample_merged,
                                       sample_average,
                                       average_radius,
                                       NULL,
                                       NULL,
                                       &color);
    }
}
CODE
    );
}

sub image_pick_correlate_layer {
    $blurb = 'Find the layer visible at the specified coordinates.';

    $help = <<'HELP';
This procedure finds the layer which is visible at the specified
coordinates.  Layers which do not qualify are those whose extents do
not pass within the specified coordinates, or which are transparent at
the specified coordinates.  This procedure will return -1 if no layer
is found.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'x', type => 'int32',
          desc => 'The x coordinate for the pick' },
        { name => 'y', type => 'int32',
          desc => 'The y coordinate for the pick' }
    );

    @outargs = (
        { name => 'layer', type => 'layer',
          desc => 'The layer found at the specified coordinates' }
    );

    %invoke = (
        headers => [ qw("core/gimpimage-pick-item.h") ],
        code => <<'CODE'
{
  layer = gimp_image_pick_layer (image, x, y);
}
CODE
    );
}

sub image_get_item_position {
    $blurb = 'Returns the position of the item in its level of its item tree.';

    $help = <<'HELP';
This procedure determines the position of the specified item in its
level in its item tree in the image. If the item doesn't exist in the
image, or the item is not part of an item tree, an error is returned.
HELP

    &mitch_pdb_misc('2010', '2.8');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'item', type => 'item',
          desc => 'The item' }
    );

    @outargs = (
        { name => 'position', type => 'int32',
          desc => "The position of the item in its level in the item tree" }
    );


    %invoke = (
        code => <<'CODE'
{
  if (gimp_pdb_item_is_in_tree (item, image, 0, error))
    position = gimp_item_get_index (item);
  else
    success = FALSE;
}
CODE
    );
}

sub image_raise_item {
    $blurb = "Raise the specified item in its level in its item tree";

    $help = <<'HELP';
This procedure raises the specified item one step in the item tree.
The procecure call will fail if there is no item above it.
HELP

    &mitch_pdb_misc('2010', '2.8');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'item', type => 'item',
          desc => 'The item to raise' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (gimp_pdb_item_is_in_tree (item, image, 0, error))
    success = gimp_image_raise_item (image, item, error);
  else
    success = FALSE;
}
CODE
    );
}

sub image_lower_item {
    $blurb = "Lower the specified item in its level in its item tree";

    $help = <<'HELP';
This procedure lowers the specified item one step in the item tree.
The procecure call will fail if there is no item below it.
HELP

    &mitch_pdb_misc('2010', '2.8');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'item', type => 'item',
          desc => 'The item to lower' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (gimp_pdb_item_is_in_tree (item, image, 0, error))
    success = gimp_image_lower_item (image, item, error);
  else
    success = FALSE;
}
CODE
    );
}

sub image_raise_item_to_top {
    $blurb = <<'BLURB';
Raise the specified item to the top of its level in its item tree
BLURB

    $help = <<'HELP';
This procedure raises the specified item to top of its level in the
item tree. It will not move the item if there is no item above it.
HELP

    &mitch_pdb_misc('2010', '2.8');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'item', type => 'item',
          desc => 'The item to raise to top' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (gimp_pdb_item_is_in_tree (item, image, 0, error))
    success = gimp_image_raise_item_to_top (image, item);
  else
    success = FALSE;
}
CODE
    );
}

sub image_lower_item_to_bottom {
    $blurb = <<'BLURB';
Lower the specified item to the bottom of its level in its item tree
BLURB

    $help = <<'HELP';
This procedure lowers the specified item to bottom of its level in the
item tree. It will not move the layer if there is no layer below it.
HELP

    &mitch_pdb_misc('2010', '2.8');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'item', type => 'item',
          desc => 'The item to lower to bottom' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (gimp_pdb_item_is_in_tree (item, image, 0, error))
    success = gimp_image_lower_item_to_bottom (image, item);
  else
    success = FALSE;
}
CODE
    );
}

sub image_reorder_item {
    $blurb = "Reorder the specified item within its item tree";

    $help = <<'HELP';
This procedure reorders the specified item within its item tree.
HELP

    &mitch_pdb_misc('2010', '2.8');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'item', type => 'item',
          desc => 'The item to reorder' },
        { name => 'parent', type => 'item', none_ok => 1,
          desc => 'The new parent item' },
        { name => 'position', type => 'int32',
          desc => 'The new position of the item' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (gimp_pdb_item_is_in_tree (item, image, 0, error) &&
      (parent == NULL ||
       (gimp_pdb_item_is_in_same_tree (item, parent, image, error) &&
        gimp_pdb_item_is_group (parent, error) &&
        gimp_pdb_item_is_not_ancestor (item, parent, error))))
    {
      success = gimp_image_reorder_item (image, item, parent, position,
                                         TRUE, NULL);
    }
  else
    success = FALSE;
}
CODE
    );
}

sub image_merge_visible_layers {
    $blurb = 'Merge the visible image layers into one.';

    $help = <<'HELP';
This procedure combines the visible layers into a single layer using
the specified merge type. A merge type of EXPAND_AS_NECESSARY expands
the final layer to encompass the areas of the visible layers. A merge
type of CLIP_TO_IMAGE clips the final layer to the extents of the
image. A merge type of CLIP_TO_BOTTOM_LAYER clips the final layer to
the size of the bottommost layer.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'merge_type',
          type => 'enum GimpMergeType (no GIMP_FLATTEN_IMAGE)',
          desc => 'The type of merge' }
    );

    @outargs = (
        { name => 'layer', type => 'layer',
          desc => 'The resulting layer' }
    );

    %invoke = (
        headers => [ qw("core/gimpimage-merge.h") ],
        code => <<'CODE'
{
  layer = gimp_image_merge_visible_layers (image, context, merge_type,
                                           FALSE, FALSE);

  if (! layer)
    success = FALSE;
}
CODE
    );
}

sub image_merge_down {
    $blurb = 'Merge the layer passed and the first visible layer below.';

    $help = <<'HELP';
This procedure combines the passed layer and the first visible layer
below it using the specified merge type. A merge type of
EXPAND_AS_NECESSARY expands the final layer to encompass the areas of
the visible layers. A merge type of CLIP_TO_IMAGE clips the final
layer to the extents of the image. A merge type of
CLIP_TO_BOTTOM_LAYER clips the final layer to the size of the
bottommost layer.
HELP

    &larry_pdb_misc('1998');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'merge_layer', type => 'layer',
          desc => 'The layer to merge down from' },
        { name => 'merge_type',
          type => 'enum GimpMergeType (no GIMP_FLATTEN_IMAGE)',
          desc => 'The type of merge' }
    );

    @outargs = (
        { name => 'layer', type => 'layer',
          desc => 'The resulting layer' }
    );

    %invoke = (
        headers => [ qw("core/gimpimage-merge.h") ],
        code => <<'CODE'
{
  if (gimp_pdb_item_is_attached (GIMP_ITEM (merge_layer), image, 0, error))
    {
      layer = gimp_image_merge_down (image, merge_layer, context, merge_type,
                                     error);

      if (! layer)
        success = FALSE;
    }
  else
    success = FALSE;
}
CODE
    );
}

sub image_flatten {
    $blurb = <<'BLURB';
Flatten all visible layers into a single layer. Discard all invisible layers.
BLURB

    $help = <<'HELP';
This procedure combines the visible layers in a manner analogous to merging
with the CLIP_TO_IMAGE merge type. Non-visible layers are discarded, and the
resulting image is stripped of its alpha channel.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
   );

    @outargs = (
        { name => 'layer', type => 'layer',
          desc => 'The resulting layer' }
    );

    %invoke = (
        headers => [ qw("core/gimpimage-merge.h") ],
        code => <<'CODE'
{
  layer = gimp_image_flatten (image, context, error);

  if (! layer)
    success = FALSE;
}
CODE
    );
}

sub image_insert_layer {
    $blurb = 'Add the specified layer to the image.';

    $help = <<'HELP';
This procedure adds the specified layer to the image at the given
position. If the specified parent is a valid layer group (See
gimp_item_is_group() and gimp_layer_group_new()) then the layer is
added inside the group. If the parent is 0, the layer is added inside
the main stack, outside of any group. The position argument specifies
the location of the layer inside the stack (or the group, if a valid
parent was supplied), starting from the top (0) and increasing.  If
the position is specified as -1 and the parent is specified as 0, then
the layer is inserted above the active layer, or inside the group if
the active layer is a layer group. The layer type must be compatible
with the image base type.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'layer', type => 'layer',
          desc => 'The layer' },
        { name => 'parent', type => 'layer', none_ok => 1,
          desc => 'The parent layer' },
        { name => 'position', type => 'int32',
          desc => 'The layer position' }
    );

    $invoke{code} = <<'CODE';
{
  if (gimp_pdb_item_is_floating (GIMP_ITEM (layer), image, error) &&
      gimp_pdb_image_is_base_type (image,
                                   gimp_drawable_get_base_type (GIMP_DRAWABLE (layer)),
                                   error) &&
      (parent == NULL ||
       (gimp_pdb_item_is_in_tree (GIMP_ITEM (parent), image, 0, error) &&
        gimp_pdb_item_is_group (GIMP_ITEM (parent), error))))
    {
      if (position == -1 && parent == NULL)
        parent = GIMP_IMAGE_ACTIVE_PARENT;

      success = gimp_image_add_layer (image, layer,
                                      parent, MAX (position, -1), TRUE);
    }
  else
    {
      success = FALSE;
    }
}
CODE
}

sub image_remove_layer {
    $blurb = 'Remove the specified layer from the image.';

    $help = <<'HELP';
This procedure removes the specified layer from the image. If the
layer doesn't exist, an error is returned. If there are no layers left
in the image, this call will fail. If this layer is the last layer
remaining, the image will become empty and have no active layer.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'layer', type => 'layer',
          desc => 'The layer' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (gimp_pdb_item_is_attached (GIMP_ITEM (layer), image, 0, error))
    gimp_image_remove_layer (image, layer, TRUE, NULL);
  else
    success = FALSE;
}
CODE
    );
}

sub image_freeze_layers {
    $blurb = "Freeze the image's layer list.";

    $help = <<'HELP';
This procedure freezes the layer list of the image, suppressing any
updates to the Layers dialog in response to changes to the image's
layers.  This can significantly improve performance while applying
changes affecting the layer list.


Each call to gimp_image_freeze_layers() should be matched by a
corresponding call to gimp_image_thaw_layers(), undoing its
effects.
HELP

    &ell_pdb_misc('2018', '2.10.2');

    @inargs = (
    { name => 'image', type => 'image',
      desc => 'The image' }
    );

    %invoke = (
    code => <<'CODE'
{
  GimpPlugIn    *plug_in   = gimp->plug_in_manager->current_plug_in;
  GimpContainer *container = gimp_image_get_layers (image);

  if (plug_in)
    success = gimp_plug_in_cleanup_layers_freeze (plug_in, image);

  if (success)
    gimp_container_freeze (container);
}
CODE
    );
}

sub image_thaw_layers {
    $blurb = "Thaw the image's layer list.";

    $help = <<'HELP';
This procedure thaws the layer list of the image, re-enabling
updates to the Layers dialog.


This procedure should match a corresponding call to
gimp_image_freeze_layers().
HELP

    &ell_pdb_misc('2018', '2.10.2');

    @inargs = (
    { name => 'image', type => 'image',
      desc => 'The image' }
    );

    %invoke = (
    code => <<'CODE'
{
  GimpPlugIn    *plug_in   = gimp->plug_in_manager->current_plug_in;
  GimpContainer *container = gimp_image_get_layers (image);

  if (plug_in)
    success = gimp_plug_in_cleanup_layers_thaw (plug_in, image);

  if (success)
    success = gimp_container_frozen (container);

  if (success)
    gimp_container_thaw (container);
}
CODE
    );
}

sub image_insert_channel {
    $blurb = 'Add the specified channel to the image.';

    $help = <<'HELP';
This procedure adds the specified channel to the image at the given
position. Since channel groups are not currently supported, the parent
argument must always be 0. The position argument specifies the
location of the channel inside the stack, starting from the top (0) and
increasing. If the position is specified as -1, then the channel is
inserted above the active channel.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'channel', type => 'channel',
          desc => 'The channel' },
        { name => 'parent', type => 'channel', none_ok => 1,
          desc => 'The parent channel' },
        { name => 'position', type => 'int32',
          desc => 'The channel position' }
    );

    $invoke{code} = <<'CODE';
{
  if (gimp_pdb_item_is_floating (GIMP_ITEM (channel), image, error) &&
      (parent == NULL ||
       (gimp_pdb_item_is_in_tree (GIMP_ITEM (parent), image, 0, error) &&
        gimp_pdb_item_is_group (GIMP_ITEM (parent), error))))
    {
      if (position == -1 && parent == NULL)
        parent = GIMP_IMAGE_ACTIVE_PARENT;

      success = gimp_image_add_channel (image, channel,
                                        parent, MAX (position, -1), TRUE);
    }
  else
    {
      success = FALSE;
    }
}
CODE
}

sub image_remove_channel {
    $blurb = 'Remove the specified channel from the image.';

    $help = <<'HELP';
This procedure removes the specified channel from the image. If the channel
doesn't exist, an error is returned.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'channel', type => 'channel',
          desc => 'The channel' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (gimp_pdb_item_is_attached (GIMP_ITEM (channel), image, 0, error))
    gimp_image_remove_channel (image, channel, TRUE, NULL);
  else
    success = FALSE;
}
CODE
    );
}

sub image_freeze_channels {
    $blurb = "Freeze the image's channel list.";

    &ell_pdb_misc('2018', '2.10.2');

    $help = <<'HELP';
This procedure freezes the channel list of the image, suppressing any
updates to the Channels dialog in response to changes to the image's
channels.  This can significantly improve performance while applying
changes affecting the channel list.


Each call to gimp_image_freeze_channels() should be matched by a
corresponding call to gimp_image_thaw_channels(), undoing its
effects.
HELP

    @inargs = (
    { name => 'image', type => 'image',
      desc => 'The image' }
    );

    %invoke = (
    code => <<'CODE'
{
  GimpPlugIn    *plug_in   = gimp->plug_in_manager->current_plug_in;
  GimpContainer *container = gimp_image_get_channels (image);

  if (plug_in)
    success = gimp_plug_in_cleanup_channels_freeze (plug_in, image);

  if (success)
    gimp_container_freeze (container);
}
CODE
    );
}

sub image_thaw_channels {
    $blurb = "Thaw the image's channel list.";

    &ell_pdb_misc('2018', '2.10.2');

    $help = <<'HELP';
This procedure thaws the channel list of the image, re-enabling
updates to the Channels dialog.


This procedure should match a corresponding call to
gimp_image_freeze_channels().
HELP

    @inargs = (
    { name => 'image', type => 'image',
      desc => 'The image' }
    );

    %invoke = (
    code => <<'CODE'
{
  GimpPlugIn    *plug_in   = gimp->plug_in_manager->current_plug_in;
  GimpContainer *container = gimp_image_get_channels (image);

  if (plug_in)
    success = gimp_plug_in_cleanup_channels_thaw (plug_in, image);

  if (success)
    success = gimp_container_frozen (container);

  if (success)
    gimp_container_thaw (container);
}
CODE
    );
}

sub image_insert_vectors {
    $blurb = 'Add the specified vectors to the image.';

    $help = <<'HELP';
This procedure adds the specified vectors to the image at the given
position. Since vectors groups are not currently supported, the parent
argument must always be 0. The position argument specifies the
location of the vectors inside the stack, starting from the top (0) and
increasing. If the position is specified as -1, then the vectors is
inserted above the active vectors.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'vectors', type => 'vectors',
          desc => 'The vectors' },
        { name => 'parent', type => 'vectors', none_ok => 1,
          desc => 'The parent vectors' },
        { name => 'position', type => 'int32',
          desc => 'The vectors position' }
    );

    $invoke{code} = <<'CODE';
{
  if (gimp_pdb_item_is_floating (GIMP_ITEM (vectors), image, error) &&
      (parent == NULL ||
       (gimp_pdb_item_is_in_tree (GIMP_ITEM (parent), image, 0, error) &&
        gimp_pdb_item_is_group (GIMP_ITEM (parent), error))))
    {
      if (position == -1 && parent == NULL)
        parent = GIMP_IMAGE_ACTIVE_PARENT;

      success = gimp_image_add_vectors (image, vectors,
                                        parent, MAX (position, -1), TRUE);
    }
  else
    {
      success = FALSE;
    }
}
CODE
}

sub image_remove_vectors {
    $blurb = 'Remove the specified path from the image.';

    $help = <<'HELP';
This procedure removes the specified path from the image. If the path
doesn't exist, an error is returned.
HELP

    &simon_pdb_misc('2005', '2.4');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'vectors', type => 'vectors',
          desc => 'The vectors object' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (gimp_pdb_item_is_attached (GIMP_ITEM (vectors), image, 0, error))
    gimp_image_remove_vectors (image, vectors, TRUE, NULL);
  else
    success = FALSE;
}
CODE
    );
}

sub image_freeze_vectors {
    $blurb = "Freeze the image's vectors list.";

    &ell_pdb_misc('2018', '2.10.2');

    $help = <<'HELP';
This procedure freezes the vectors list of the image, suppressing any
updates to the Paths dialog in response to changes to the image's
vectors.  This can significantly improve performance while applying
changes affecting the vectors list.


Each call to gimp_image_freeze_vectors() should be matched by a
corresponding call to gimp_image_thaw_vectors(), undoing its
effects.
HELP

    @inargs = (
    { name => 'image', type => 'image',
      desc => 'The image' }
    );

    %invoke = (
    code => <<'CODE'
{
  GimpPlugIn    *plug_in   = gimp->plug_in_manager->current_plug_in;
  GimpContainer *container = gimp_image_get_vectors (image);

  if (plug_in)
    success = gimp_plug_in_cleanup_vectors_freeze (plug_in, image);

  if (success)
    gimp_container_freeze (container);
}
CODE
    );
}

sub image_thaw_vectors {
    $blurb = "Thaw the image's vectors list.";

    &ell_pdb_misc('2018', '2.10.2');

    $help = <<'HELP';
This procedure thaws the vectors list of the image, re-enabling
updates to the Paths dialog.


This procedure should match a corresponding call to
gimp_image_freeze_vectors().
HELP

    @inargs = (
    { name => 'image', type => 'image',
      desc => 'The image' }
    );

    %invoke = (
    code => <<'CODE'
{
  GimpPlugIn    *plug_in   = gimp->plug_in_manager->current_plug_in;
  GimpContainer *container = gimp_image_get_vectors (image);

  if (plug_in)
    success = gimp_plug_in_cleanup_vectors_thaw (plug_in, image);

  if (success)
    success = gimp_container_frozen (container);

  if (success)
    gimp_container_thaw (container);
}
CODE
    );
}

sub image_get_active_drawable {
    $blurb = "Get the image's active drawable";

    $help = <<'HELP';
This procedure returns the ID of the image's active drawable. This can be
either a layer, a channel, or a layer mask. The active drawable is specified by
the active image channel. If that is -1, then by the active image layer. If the
active image layer has a layer mask and the layer mask is in edit mode, then
the layer mask is the active drawable.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'drawable', type => 'drawable',
          desc => 'The active drawable' }
    );

    %invoke = (
        code => <<'CODE'
{
  drawable = gimp_image_get_active_drawable (image);
}
CODE
    );
}

sub image_base_type {
    $blurb = 'Get the base type of the image.';

    $help = <<'HELP';
This procedure returns the image's base type. Layers in the image must be of
this subtype, but can have an optional alpha channel.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'base_type', type => 'enum GimpImageBaseType',
          desc => "The image's base type" }
    );

    %invoke = (
        code => <<'CODE'
{
  base_type = gimp_image_get_base_type (image);
}
CODE
    );
}

sub image_get_precision {
    $blurb = 'Get the precision of the image.';

    $help = <<'HELP';
This procedure returns the image's precision.
HELP

    &mitch_pdb_misc('2012', '2.10');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'precision', type => 'enum GimpPrecision',
          desc => "The image's precision" }
    );

    %invoke = (
        code => <<'CODE'
{
  if (gimp->plug_in_manager->current_plug_in)
    gimp_plug_in_enable_precision (gimp->plug_in_manager->current_plug_in);

  precision = gimp_image_get_precision (image);
}
CODE
    );
}

sub image_get_default_new_layer_mode {
    $blurb = 'Get the default mode for newly created layers of this image.';
    $help  = 'Returns the default mode for newly created layers of this image.';

    &mitch_pdb_misc('2017', '2.10');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
	{ name => 'mode', type => 'enum GimpLayerMode',
          default => 'GIMP_LAYER_MODE_NORMAL',
	  desc => 'The layer mode' }
    );

    %invoke = (
	code => <<'CODE'
{
  mode = gimp_image_get_default_new_layer_mode (image);
}
CODE
    );
}

sub image_get_colormap {
    $blurb = "Returns the image's colormap";

    $help = <<'HELP';
This procedure returns an actual pointer to the image's colormap, as well as
the number of bytes contained in the colormap. The actual number of colors in
the transmitted colormap will be 'num-bytes' / 3. If the image is not in
Indexed color mode, no colormap is returned.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'colormap', type => 'int8array', wrap => 1,
          desc => "The image's colormap. The returned value must be freed with g_free()",
          array => { name => 'num_bytes',
                     desc => 'Number of bytes in the colormap array' } }
    );

    %invoke = (
        headers => [ qw("core/gimpimage-colormap.h") ],
        code => <<'CODE'
{
  num_bytes = 3 * gimp_image_get_colormap_size (image);
  colormap = g_memdup (gimp_image_get_colormap (image), num_bytes);
}
CODE
    );
}

sub image_set_colormap {
    $blurb = "Sets the entries in the image's colormap.";

    $help = <<'HELP';
This procedure sets the entries in the specified image's colormap. The number
of entries is specified by the 'num-bytes' parameter and corresponds to the
number of INT8 triples that must be contained in the 'colormap' array. The
actual number of colors in the transmitted colormap is 'num-bytes' / 3.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'colormap', type => 'int8array', wrap => 1,
          desc => 'The new colormap values',
          array => { name => 'num_bytes', type => '0 <= int32 <= 768',
                     desc => 'Number of bytes in the colormap array' } }
    );

    %invoke = (
        headers => [ qw("core/gimpimage-colormap.h") ],
        code => <<'CODE'
{
  gimp_image_set_colormap (image, colormap, num_bytes / 3, TRUE);
}
CODE
    );
}

sub image_get_metadata {
    $blurb = "Returns the image's metadata.";
    $help  = 'Returns exif/iptc/xmp metadata from the image.';

    &std_pdb_misc('2013', '2.10');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
	{ name => 'metadata_string', type => 'string', wrap => 1,
	  desc => 'The exif/ptc/xmp metadata as a string'}
    );

    %invoke = (
	code => <<'CODE'
{
  GimpMetadata *metadata = gimp_image_get_metadata (image);

  if (metadata)
    metadata_string = gimp_metadata_serialize (metadata);
}
CODE
    );
}

sub image_set_metadata {
    $blurb = "Set the image's metadata.";
    $help  = 'Sets exif/iptc/xmp metadata on the image.';

    &std_pdb_misc('2013', '2.10');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
	{ name => 'metadata_string', type => 'string', wrap => 1,
	  desc => 'The exif/ptc/xmp metadata as a string' }
    );

    %invoke = (
	code => <<'CODE'
{
  GimpMetadata *metadata = gimp_metadata_deserialize (metadata_string);

  gimp_image_set_metadata (image, metadata, TRUE);

  if (metadata)
    g_object_unref (metadata);
}
CODE
    );
}

sub image_clean_all {
    $blurb = 'Set the image dirty count to 0.';

    $help = <<'HELP';
This procedure sets the specified image's dirty count to 0, allowing
operations to occur without having a 'dirtied' image. This is
especially useful for creating and loading images which should not
initially be considered dirty, even though layers must be created,
filled, and installed in the image. Note that save plug-ins must NOT
call this function themselves after saving the image.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    %invoke = (
        code => <<'CODE'
{
  gimp_image_clean_all (image);
}
CODE
    );
}

sub image_is_dirty {
    $blurb = 'Checks if the image has unsaved changes.';

    $help = <<'HELP';
This procedure checks the specified image's dirty count to see if it
needs to be saved. Note that saving the image does not automatically
set the dirty count to 0, you need to call gimp_image_clean_all() after
calling a save procedure to make the image clean.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'dirty', type => 'boolean',
          desc => 'TRUE if the image has unsaved changes.' }
    );

    %invoke = (
        code => <<'CODE'
{
  dirty = gimp_image_is_dirty (image);
}
CODE
    );
}

sub image_get_floating_sel {
    $blurb = 'Return the floating selection of the image.';

    $help = <<'HELP';
This procedure returns the image's floating selection, if it exists.
If it doesn't exist, -1 is returned as the layer ID.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'floating_sel', type => 'layer',
          desc => "The image's floating selection" }
    );

    %invoke = (
        code => <<'CODE'
{
  floating_sel = gimp_image_get_floating_selection (image);
}
CODE
    );
}

sub image_floating_sel_attached_to {
    $blurb = 'Return the drawable the floating selection is attached to.';

    $help = <<'HELP';
This procedure returns the drawable the image's floating selection is attached
to, if it exists. If it doesn't exist, -1 is returned as the drawable ID.
HELP

    &wolfgang_pdb_misc('1998');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'drawable', type => 'drawable',
          desc => 'The drawable the floating selection is attached to' }
    );

    %invoke = (
        code => <<'CODE'
{
  GimpLayer *floating_sel = gimp_image_get_floating_selection (image);

  if (floating_sel)
    drawable = gimp_layer_get_floating_sel_drawable (floating_sel);
  else
    drawable = NULL;
}
CODE
    );
}

sub image_width {
    $blurb = 'Return the width of the image';

    $help = <<'HELP';
This procedure returns the image's width. This value is independent of any of
the layers in this image. This is the "canvas" width.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'width', type => 'int32',
          desc => "The image's width" }
    );

    %invoke = (
        code => <<'CODE'
{
  width = gimp_image_get_width (image);
}
CODE
    );
}

sub image_height {
    $blurb = 'Return the height of the image';

    $help = <<'HELP';
This procedure returns the image's height. This value is independent of any of
the layers in this image. This is the "canvas" height.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'height', type => 'int32',
          desc => "The image's height" }
    );

    %invoke = (
        code => <<'CODE'
{
  height = gimp_image_get_height (image);
}
CODE
    );
}

sub image_get_active_layer {
    $blurb = "Returns the specified image's active layer.";

    $help = <<'HELP';
If there is an active layer, its ID will be returned, otherwise, -1.  If a
channel is currently active, then no layer will be. If a layer mask is active,
then this will return the associated layer.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'active_layer', type => 'layer',
          desc => 'The active layer' }
    );

    %invoke = (
        code => <<'CODE'
{
  active_layer = gimp_image_get_active_layer (image);
}
CODE
    );
}

sub image_set_active_layer {
    $blurb = "Sets the specified image's active layer.";

    $help = <<'HELP';
If the layer exists, it is set as the active layer in the image. Any
previous active layer or channel is set to inactive. An exception is a
previously existing floating selection, in which case this procedure
will return an execution error.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'active_layer', type => 'layer',
          desc => 'The new image active layer' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (gimp_image_set_active_layer (image, active_layer) != active_layer)
    success = FALSE;
}
CODE
    );
}

sub image_get_active_channel {
    $blurb = "Returns the specified image's active channel.";

    $help = <<'HELP';
If there is an active channel, this will return the channel ID, otherwise, -1.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'active_channel', type => 'channel',
          desc => 'The active channel' }
    );

    %invoke = (
        code => <<'CODE'
{
  active_channel = gimp_image_get_active_channel (image);
}
CODE
    );
}

sub image_set_active_channel {
    $blurb = "Sets the specified image's active channel.";

    $help = <<'HELP';
If the channel exists, it is set as the active channel in the
image. Any previous active channel or layer is set to inactive. An
exception is a previously existing floating selection, in which case
this procedure will return an execution error.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'active_channel', type => 'channel',
          desc => 'The new image active channel' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (gimp_image_set_active_channel (image, active_channel) != active_channel)
    success = FALSE;
}
CODE
    );
}

sub image_get_active_vectors {
    $blurb = "Returns the specified image's active vectors.";

    $help = <<'HELP';
If there is an active path, its ID will be returned, otherwise, -1.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'active_vectors', type => 'vectors',
          desc => 'The active vectors' }
    );

    %invoke = (
        code => <<'CODE'
{
  active_vectors = gimp_image_get_active_vectors (image);
}
CODE
    );
}

sub image_set_active_vectors {
    $blurb = "Sets the specified image's active vectors.";

    $help = <<'HELP';
If the path exists, it is set as the active path in the image.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'active_vectors', type => 'vectors',
          desc => 'The new image active vectors' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (gimp_image_set_active_vectors (image, active_vectors) != active_vectors)
    success = FALSE;
}
CODE
    );
}

sub image_get_selection {
    $blurb = "Returns the specified image's selection.";

    $help = <<'HELP';
This will always return a valid ID for a selection -- which is represented as a
channel internally.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'selection', type => 'selection',
          desc => 'The selection channel' }
    );

    %invoke = (
        code => <<'CODE'
{
  selection = GIMP_SELECTION (gimp_image_get_mask (image));

  if (! selection)
    success = FALSE;
}
CODE
    );
}

sub image_get_component_active {
    $blurb = "Returns if the specified image's image component is active.";

    $help = <<'HELP';
This procedure returns if the specified image's image component
(i.e. Red, Green, Blue intensity channels in an RGB image) is active
or inactive -- whether or not it can be modified. If the specified
component is not valid for the image type, an error is returned.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'component', type => 'enum GimpChannelType',
          desc => 'The image component' }
    );

    @outargs = (
        { name => 'active', type => 'boolean',
          desc => 'Component is active' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (component == GIMP_CHANNEL_GRAY)
    success = gimp_pdb_image_is_base_type (image, GIMP_GRAY, error);
  else if (component == GIMP_CHANNEL_INDEXED)
    success = gimp_pdb_image_is_base_type (image, GIMP_INDEXED, error);
  else
    success = gimp_pdb_image_is_base_type (image, GIMP_RGB, error);

  if (success)
    active = gimp_image_get_component_active (image, component);
}
CODE
    );
}

sub image_set_component_active {
    $blurb = "Sets if the specified image's image component is active.";

    $help = <<'HELP';
This procedure sets if the specified image's image component
(i.e. Red, Green, Blue intensity channels in an RGB image) is active
or inactive -- whether or not it can be modified. If the specified
component is not valid for the image type, an error is returned.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'component', type => 'enum GimpChannelType',
          desc => 'The image component' },
        { name => 'active', type => 'boolean',
          desc => 'Component is active' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (component == GIMP_CHANNEL_GRAY)
    success = gimp_pdb_image_is_base_type (image, GIMP_GRAY, error);
  else if (component == GIMP_CHANNEL_INDEXED)
    success = gimp_pdb_image_is_base_type (image, GIMP_INDEXED, error);
  else
    success = gimp_pdb_image_is_base_type (image, GIMP_RGB, error);

  if (success)
    gimp_image_set_component_active (image, component, active);
}
CODE
    );
}

sub image_get_component_visible {
    $blurb = "Returns if the specified image's image component is visible.";

    $help = <<'HELP';
This procedure returns if the specified image's image component
(i.e. Red, Green, Blue intensity channels in an RGB image) is visible
or invisible -- whether or not it can be seen. If the specified
component is not valid for the image type, an error is returned.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'component', type => 'enum GimpChannelType',
          desc => 'The image component' }
    );

    @outargs = (
        { name => 'visible', type => 'boolean',
          desc => 'Component is visible' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (component == GIMP_CHANNEL_GRAY)
    success = gimp_pdb_image_is_base_type (image, GIMP_GRAY, error);
  else if (component == GIMP_CHANNEL_INDEXED)
    success = gimp_pdb_image_is_base_type (image, GIMP_INDEXED, error);
  else
    success = gimp_pdb_image_is_base_type (image, GIMP_RGB, error);

  if (success)
    visible = gimp_image_get_component_visible (image, component);
}
CODE
    );
}

sub image_set_component_visible {
    $blurb = "Sets if the specified image's image component is visible.";

    $help = <<'HELP';
This procedure sets if the specified image's image component
(i.e. Red, Green, Blue intensity channels in an RGB image) is visible
or invisible -- whether or not it can be seen. If the specified
component is not valid for the image type, an error is returned.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'component', type => 'enum GimpChannelType',
          desc => 'The image component' },
        { name => 'visible', type => 'boolean',
          desc => 'Component is visible' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (component == GIMP_CHANNEL_GRAY)
    success = gimp_pdb_image_is_base_type (image, GIMP_GRAY, error);
  else if (component == GIMP_CHANNEL_INDEXED)
    success = gimp_pdb_image_is_base_type (image, GIMP_INDEXED, error);
  else
    success = gimp_pdb_image_is_base_type (image, GIMP_RGB, error);

  if (success)
    gimp_image_set_component_visible (image, component, visible);
}
CODE
    );
}

sub image_get_filename {
    $blurb = "Returns the specified image's filename.";

    $help = <<'HELP';
This procedure returns the specified image's filename in the
filesystem encoding. The image has a filename only if it was loaded or
imported from a file or has since been saved or exported. Otherwise,
this function returns %NULL. See also gimp_image_get_uri().
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'filename', type => 'string',
          desc => 'The filename. The returned value must be freed with g_free()' }
    );

    %invoke = (
        code => <<'CODE'
{
  GFile *file = gimp_image_get_any_file (image);
  if (file)
    filename = g_file_get_path (file);
}
CODE
    );
}

sub image_set_filename {
    $blurb = "Sets the specified image's filename.";

    $help = <<'HELP';
This procedure sets the specified image's filename. The filename
should be in the filesystem encoding.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'filename', type => 'string',
          desc => 'The new image filename', allow_non_utf8 => 1 }
    );

    %invoke = (
        code => <<'CODE'
{
  /*  verify that the filename can be converted to UTF-8 and back  */
  gchar *utf8 = g_filename_to_utf8 (filename, -1, NULL, NULL, error);

  if (utf8)
    {
      gchar *tmp = g_filename_from_utf8 (utf8, -1, NULL, NULL, error);

      if (tmp)
        g_free (tmp);
      else
        success = FALSE;

      g_free (utf8);
    }
  else
    success = FALSE;

  if (success)
    {
      GFile *file = NULL;

      if (filename && strlen (filename))
        file = file_utils_filename_to_file (image->gimp, filename, NULL);

      gimp_image_set_file (image, file);

      if (file)
        g_object_unref (file);
    }
}
CODE
    );
}

sub image_get_uri {
    $blurb = "Returns the URI for the specified image.";

    $help = <<'HELP';
This procedure returns the URI associated with the specified image.
The image has an URI only if it was loaded or imported from a file or
has since been saved or exported. Otherwise, this function returns
%NULL.  See also gimp-image-get-imported-uri to get the URI of the
current file if it was imported from a non-GIMP file format and not
yet saved, or gimp-image-get-exported-uri if the image has been
exported to a non-GIMP file format.
HELP

    &neo_pdb_misc('2009', '2.8');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'uri', type => 'string',
          desc => 'The URI. The returned value must be freed with g_free()' }
    );

    %invoke = (
        code => <<'CODE'
{
  GFile *file = gimp_image_get_any_file (image);
  if (file)
    uri = g_file_get_uri (file);
}
CODE
    );
}

sub image_get_xcf_uri {
    $blurb = "Returns the XCF URI for the specified image.";

    $help = <<'HELP';
This procedure returns the XCF URI associated with the image. If
there is no such URI, this procedure returns %NULL.
HELP

    $author = 'Eric Grivel <gimp@lumenssolutions.com>';
    $copyright = 'Eric Grivel';
    $date = '2011';
    $since = '2.8';

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'uri', type => 'string',
          desc => 'The imported URI. The returned value must be freed with g_free()' }
    );

    %invoke = (
        code => <<'CODE'
{
  GFile *file = gimp_image_get_file (image);
  if (file)
    uri = g_file_get_uri (file);
}
CODE
    );
}

sub image_get_imported_uri {
    $blurb = "Returns the imported URI for the specified image.";

    $help = <<'HELP';
This procedure returns the URI associated with the specified image
if the image was imported from a non-native Gimp format. If the
image was not imported, or has since been saved in the native Gimp
format, this procedure returns %NULL.
HELP

    $author = 'Eric Grivel <gimp@lumenssolutions.com>';
    $copyright = 'Eric Grivel';
    $date = '2011';
    $since = '2.8';

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'uri', type => 'string',
          desc => 'The imported URI. The returned value must be freed with g_free()' }
    );

    %invoke = (
        code => <<'CODE'
{
  GFile *file = gimp_image_get_imported_file (image);
  if (file)
    uri = g_file_get_uri (file);
}
CODE
    );
}

sub image_get_exported_uri {
    $blurb = "Returns the exported URI for the specified image.";

    $help = <<'HELP';
This procedure returns the URI associated with the specified image
if the image was exported a non-native GIMP format. If the
image was not exported, this procedure returns %NULL.
HELP

    $author = 'Eric Grivel <gimp@lumenssolutions.com>';
    $copyright = 'Eric Grivel';
    $date = '2011';
    $since = '2.8';

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'uri', type => 'string',
          desc => 'The exported URI. The returned value must be freed with g_free()' }
    );

    %invoke = (
        code => <<'CODE'
{
  GFile *file = gimp_image_get_exported_file (image);
  if (file)
    uri = g_file_get_uri (file);
}
CODE
    );
}

sub image_get_name {
    $blurb = "Returns the specified image's name.";
    $help  =  <<'HELP';
This procedure returns the image's name. If the image has a filename
or an URI, then the returned name contains the filename's or URI's
base name (the last component of the path). Otherwise it is the
translated string "Untitled". The returned name is formatted like the
image name in the image window title, it may contain '[]',
'(imported)' etc. and should only be used to label user interface
elements. Never use it to construct filenames.
HELP

    &std_pdb_misc;

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'name', type => 'string',
          desc => 'The name. The returned value must be freed with g_free()' }
    );

    %invoke = (
        code => <<'CODE'
{
  name = g_strdup (gimp_image_get_display_name (image));
}
CODE
    );
}

sub image_get_resolution {
    $blurb = "Returns the specified image's resolution.";

    $help = <<'HELP';
This procedure returns the specified image's resolution in dots per inch.
This value is independent of any of the layers in this image.
HELP

    &austin_pdb_misc('1998');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'xresolution', type => 'float', void_ret => 1,
          desc => 'The resolution in the x-axis, in dots per inch' },
        { name => 'yresolution', type => 'float',
          desc => 'The resolution in the y-axis, in dots per inch' }
    );

    %invoke = (
        code => <<'CODE'
{
  gimp_image_get_resolution (image, &xresolution, &yresolution);
}
CODE
    );
}

sub image_set_resolution {
    $blurb = "Sets the specified image's resolution.";

    $help = <<'HELP';
This procedure sets the specified image's resolution in dots per inch.
This value is independent of any of the layers in this image.
No scaling or resizing is performed.
HELP

    &austin_pdb_misc('1998');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'xresolution', type => 'float',
          desc => 'The new image resolution in the x-axis, in dots per inch' },
        { name => 'yresolution', type => 'float',
          desc => 'The new image resolution in the y-axis, in dots per inch' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (! FINITE (xresolution) ||
      xresolution < GIMP_MIN_RESOLUTION || xresolution > GIMP_MAX_RESOLUTION ||
      ! FINITE (yresolution) ||
      yresolution < GIMP_MIN_RESOLUTION || yresolution > GIMP_MAX_RESOLUTION)
    {
      g_set_error_literal (error, GIMP_PDB_ERROR,
                           GIMP_PDB_ERROR_INVALID_ARGUMENT,
                           _("Image resolution is out of bounds, "
                             "using the default resolution instead."));
      success = FALSE;
    }
  else
    {
      gimp_image_set_resolution (image, xresolution, yresolution);
    }
}
CODE
    );
}

sub image_get_unit {
    $blurb = "Returns the specified image's unit.";

    $help = <<'HELP';
This procedure returns the specified image's unit. This value is
independent of any of the layers in this image. See the gimp_unit_*()
procedure definitions for the valid range of unit IDs and a
description of the unit system.
HELP

    &mitch_pdb_misc('1998');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'unit', type => 'unit',
          desc => 'The unit' }
    );

    %invoke = (
        code => <<'CODE'
{
  unit = gimp_image_get_unit (image);
}
CODE
    );
}

sub image_set_unit {
    $blurb = "Sets the specified image's unit.";

    $help = <<'HELP';
This procedure sets the specified image's unit. No scaling or resizing
is performed. This value is independent of any of the layers in this
image. See the gimp_unit_*() procedure definitions for the valid range
of unit IDs and a description of the unit system.
HELP

    &mitch_pdb_misc('1998');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'unit', type => 'unit (min GIMP_UNIT_INCH)',
          desc => 'The new image unit' }
    );

    %invoke = (
        code => <<'CODE'
{
  gimp_image_set_unit (image, unit);
}
CODE
    );
}

sub image_get_tattoo_state {
    $blurb = 'Returns the tattoo state associated with the image.';

    $help = <<'HELP';
This procedure returns the tattoo state of the image. Use only by
save/load plug-ins that wish to preserve an images tattoo state. Using this
function at other times will produce unexpected results.
HELP

    &andy_pdb_misc('2000');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'tattoo_state', type => 'tattoo',
          desc => 'The tattoo state' }
    );

    %invoke = (
        code => <<'CODE'
{
  tattoo_state = gimp_image_get_tattoo_state (image);
}
CODE
    );
}

sub image_set_tattoo_state {
    $blurb = 'Set the tattoo state associated with the image.';

    $help = <<'HELP';
This procedure sets the tattoo state of the image. Use only by
save/load plug-ins that wish to preserve an images tattoo state. Using
this function at other times will produce unexpected results. A full
check of uniqueness of states in layers, channels and paths will be
performed by this procedure and a execution failure will be returned
if this fails. A failure will also be returned if the new tattoo state
value is less than the maximum tattoo value from all of the tattoos
from the paths, layers and channels. After the image data has been
loaded and all the tattoos have been set then this is the last
procedure that should be called. If effectively does a status check on
the tattoo values that have been set to make sure that all is OK.
HELP

    &andy_pdb_misc('2000');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'tattoo_state', type => 'tattoo',
          desc => 'The new image tattoo state' }
    );

    %invoke = (
        code => <<'CODE'
{
  gimp_image_set_tattoo_state (image, tattoo_state);
}
CODE
    );
}

sub image_get_layer_by_tattoo {
    $blurb = 'Find a layer with a given tattoo in an image.';

    $help = <<'HELP';
This procedure returns the layer with the given tattoo in the specified image.
HELP

    &jay_pdb_misc('1998');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'tattoo', type => 'tattoo',
          desc => 'The tattoo of the layer to find' }
    );

    @outargs = (
        { name => 'layer', type => 'layer',
          desc => 'The layer with the specified tattoo' }
    );

    %invoke = (
        code => <<'CODE'
{
  layer = gimp_image_get_layer_by_tattoo (image, tattoo);
}
CODE
    );
}

sub image_get_channel_by_tattoo {
    $blurb = 'Find a channel with a given tattoo in an image.';

    $help = <<'HELP';
This procedure returns the channel with the given tattoo in the specified image.
HELP

    &jay_pdb_misc('1998');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'tattoo', type => 'tattoo',
          desc => 'The tattoo of the channel to find' }
    );

    @outargs = (
        { name => 'channel', type => 'channel',
          desc => 'The channel with the specified tattoo' }
    );

    %invoke = (
        code => <<'CODE'
{
  channel = gimp_image_get_channel_by_tattoo (image, tattoo);
}
CODE
    );
}

sub image_get_vectors_by_tattoo {
    $blurb = 'Find a vectors with a given tattoo in an image.';

    $help = <<'HELP';
This procedure returns the vectors with the given tattoo in the
specified image.
HELP

    &simon_pdb_misc('2005', '2.6');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'tattoo', type => 'tattoo',
          desc => 'The tattoo of the vectors to find' }
    );

    @outargs = (
        { name => 'vectors', type => 'vectors',
          desc => 'The vectors with the specified tattoo' }
    );

    %invoke = (
        code => <<'CODE'
{
  vectors = gimp_image_get_vectors_by_tattoo (image, tattoo);
}
CODE
    );
}

sub image_get_layer_by_name {
    $blurb = 'Find a layer with a given name in an image.';

    $help = <<'HELP';
This procedure returns the layer with the given name in the specified image.
HELP

    &mitch_pdb_misc('2011', '2.8');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'name', type => 'string', non_empty => 1,
          desc => 'The name of the layer to find' }
    );

    @outargs = (
        { name => 'layer', type => 'layer',
          desc => 'The layer with the specified name' }
    );

    %invoke = (
        code => <<'CODE'
{
  layer = gimp_image_get_layer_by_name (image, name);
}
CODE
    );
}

sub image_get_channel_by_name {
    $blurb = 'Find a channel with a given name in an image.';

    $help = <<'HELP';
This procedure returns the channel with the given name in the specified image.
HELP

    &mitch_pdb_misc('2011', '2.8');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'name', type => 'string', non_empty => 1,
          desc => 'The name of the channel to find' }
    );

    @outargs = (
        { name => 'channel', type => 'channel',
          desc => 'The channel with the specified name' }
    );

    %invoke = (
        code => <<'CODE'
{
  channel = gimp_image_get_channel_by_name (image, name);
}
CODE
    );
}

sub image_get_vectors_by_name {
    $blurb = 'Find a vectors with a given name in an image.';

    $help = <<'HELP';
This procedure returns the vectors with the given name in the
specified image.
HELP

    &mitch_pdb_misc('2011', '2.8');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'name', type => 'string', non_empty => 1,
          desc => 'The name of the vectors to find' }
    );

    @outargs = (
        { name => 'vectors', type => 'vectors',
          desc => 'The vectors with the specified name' }
    );

    %invoke = (
        code => <<'CODE'
{
  vectors = gimp_image_get_vectors_by_name (image, name);
}
CODE
    );
}

sub image_attach_parasite {
    $blurb = 'Add a parasite to an image.';

    $help = <<'HELP';
This procedure attaches a parasite to an image. It has no return values.
HELP

    &jay_pdb_misc('1998', '2.8');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'parasite', type => 'parasite',
          desc => 'The parasite to attach to an image' }
    );

    %invoke = (
        code => <<'CODE'
{
  if (gimp_image_parasite_validate (image, parasite, error))
    gimp_image_parasite_attach (image, parasite);
  else
    success = FALSE;
}
CODE
    );
}

sub image_detach_parasite {
    $blurb = 'Removes a parasite from an image.';

    $help = <<'HELP';
This procedure detaches a parasite from an image. It has no return values.
HELP

    &jay_pdb_misc('1998', '2.8');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'name', type => 'string',
          desc => 'The name of the parasite to detach from an image.' }
    );

    %invoke = (
        code => <<'CODE'
{
  gimp_image_parasite_detach (image, name);
}
CODE
    );
}

sub image_get_parasite {
    $blurb = 'Look up a parasite in an image';

    $help = <<'HELP';
Finds and returns the parasite that was previously attached to an image.
HELP

    &jay_pdb_misc('1998', '2.8');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'name', type => 'string',
          desc => 'The name of the parasite to find' }
    );

    @outargs = (
        { name => 'parasite', type => 'parasite',
          desc => 'The found parasite' }
    );

    %invoke = (
        code => <<'CODE'
{
  parasite = gimp_parasite_copy (gimp_image_parasite_find (image, name));

  if (! parasite)
    success = FALSE;
}
CODE
    );
}

sub image_get_parasite_list {
    $blurb = 'List all parasites.';
    $help  = 'Returns a list of all currently attached parasites.';

    &marc_pdb_misc('1999', '2.8');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' }
    );

    @outargs = (
        { name => 'parasites', type => 'stringarray',
          desc => 'The names of currently attached parasites',
          array => { desc => 'The number of attached parasites' } }
    );

    %invoke = (
        code => <<'CODE'
{
  parasites = gimp_image_parasite_list (image, &num_parasites);
}
CODE
    );
}

sub image_thumbnail {
    $blurb = 'Get a thumbnail of an image.';

    $help = <<'HELP';
This function gets data from which a thumbnail of an image preview can
be created. Maximum x or y dimension is 1024 pixels. The pixels are
returned in RGB[A] or GRAY[A] format. The bpp return value gives the
number of bits per pixel in the image.
HELP

    &andy_pdb_misc('1999');

    @inargs = (
        { name => 'image', type => 'image',
          desc => 'The image' },
        { name => 'width', type => '1 <= int32 <= 1024',
          desc => 'The requested thumbnail width' },
        { name => 'height', type => '1 <= int32 <= 1024',
          desc => 'The requested thumbnail height' }
    );

    @outargs = (
        { name => 'actual_width', type => 'int32', void_ret => 1,
          desc => 'The previews width' },
        { name => 'actual_height', type => 'int32',
          desc => 'The previews height' },
        { name => 'bpp', type => 'int32',
          desc => 'The previews bpp' },
        { name => 'thumbnail_data', type => 'int8array', wrap => 1,
          desc => 'The thumbnail data',
          array => { name => 'thumbnail_data_count',
                     desc => 'The number of bytes in thumbnail data' } }
    );

    %invoke = (
        code => <<'CODE'
{
  GimpTempBuf *buf;
  gint         dwidth, dheight;

  gimp_assert (GIMP_VIEWABLE_MAX_PREVIEW_SIZE >= 1024);

  /* Adjust the width/height ratio */
  dwidth  = gimp_image_get_width  (image);
  dheight = gimp_image_get_height (image);

  if (dwidth > dheight)
    height = MAX (1, (width * dheight) / dwidth);
  else
    width  = MAX (1, (height * dwidth) / dheight);

  gimp_pickable_flush (GIMP_PICKABLE (image));

  buf = gimp_viewable_get_new_preview (GIMP_VIEWABLE (image), context,
                                       width, height);

  if (buf)
    {
      actual_width         = gimp_temp_buf_get_width  (buf);
      actual_height        = gimp_temp_buf_get_height (buf);
      bpp                  = babl_format_get_bytes_per_pixel (gimp_temp_buf_get_format (buf));
      thumbnail_data_count = gimp_temp_buf_get_data_size (buf);
      thumbnail_data       = g_memdup (gimp_temp_buf_get_data (buf),
                                       thumbnail_data_count);

      gimp_temp_buf_unref (buf);
    }
  else
    success = FALSE;
}
CODE
    );
}


$extra{app}->{code} = <<'CODE';
#if defined (HAVE_FINITE)
#define FINITE(x) finite(x)
#elif defined (HAVE_ISFINITE)
#define FINITE(x) isfinite(x)
#elif defined (G_OS_WIN32)
#define FINITE(x) _finite(x)
#else
#error "no FINITE() implementation available?!"
#endif
CODE

@headers = qw("libgimpmath/gimpmath.h"
              "libgimpbase/gimpbase.h"
              "gegl/gimp-babl.h"
              "core/gimp.h"
              "core/gimpcontainer.h"
              "core/gimpimage-metadata.h"
              "core/gimpprogress.h"
              "core/gimptempbuf.h"
              "file/file-utils.h"
              "plug-in/gimpplugin.h"
              "plug-in/gimpplugin-cleanup.h"
              "plug-in/gimppluginmanager.h"
              "gimppdbcontext.h"
              "gimppdberror.h"
              "gimppdb-utils.h"
              "gimp-intl.h");

@procs = qw(image_is_valid
            image_list
            image_new image_new_with_precision
            image_duplicate image_delete
            image_base_type
            image_get_precision
            image_get_default_new_layer_mode
            image_width image_height
            image_get_layers
            image_get_channels
            image_get_vectors
            image_get_active_drawable
            image_unset_active_channel
            image_get_floating_sel
            image_floating_sel_attached_to
            image_pick_color
            image_pick_correlate_layer
            image_insert_layer image_remove_layer
            image_freeze_layers image_thaw_layers
            image_insert_channel image_remove_channel
            image_freeze_channels image_thaw_channels
            image_insert_vectors image_remove_vectors
            image_freeze_vectors image_thaw_vectors
            image_get_item_position
            image_raise_item image_lower_item
            image_raise_item_to_top image_lower_item_to_bottom
            image_reorder_item
            image_flatten image_merge_visible_layers image_merge_down
            image_get_colormap image_set_colormap
            image_get_metadata image_set_metadata
            image_clean_all image_is_dirty
            image_thumbnail
            image_get_active_layer image_set_active_layer
            image_get_active_channel image_set_active_channel
            image_get_active_vectors image_set_active_vectors
            image_get_selection
            image_get_component_active image_set_component_active
            image_get_component_visible image_set_component_visible
            image_get_filename image_set_filename
            image_get_uri
            image_get_xcf_uri
            image_get_imported_uri
            image_get_exported_uri
            image_get_name
            image_get_resolution image_set_resolution
            image_get_unit image_set_unit
            image_get_tattoo_state image_set_tattoo_state
            image_get_layer_by_tattoo
            image_get_channel_by_tattoo
            image_get_vectors_by_tattoo
            image_get_layer_by_name
            image_get_channel_by_name
            image_get_vectors_by_name
            image_attach_parasite image_detach_parasite
            image_get_parasite
            image_get_parasite_list);

%exports = (app => [@procs], lib => [@procs]);

$desc = 'Image';
$doc_title = 'gimpimage';
$doc_short_desc = 'Operations on complete images.';
$doc_long_desc = 'Operations on complete images: creation, resizing/rescaling, and operations involving multiple layers.';

1;