/*
Method: Info#gravity=
Purpose: Convert a GravityType enum to a gravity option name and
store in the Info structure
*/
VALUE
Info_gravity_eq(VALUE self, VALUE grav)
{
Info *info;
GravityType gravity;
const char *option;
int x;
Data_Get_Struct(self, Info, info);
if (NIL_P(grav))
{
(void) RemoveImageOption(info, "gravity");
return self;
}
VALUE_TO_ENUM(grav, gravity, GravityType);
option = "Undefined";
for (x = 0; x < N_GRAVITY_OPTIONS; x++)
{
if (gravity == Gravity_Option[x].enumerator)
{
option = Gravity_Option[x].string;
break;
}
}
(void) SetImageOption(info, "gravity", option);
return self;
}
/*
Method: Info#dispose=
Purpose: Convert a DisposeType enumerator into the equivalent
dispose option string
*/
VALUE
Info_dispose_eq(VALUE self, VALUE disp)
{
Info *info;
DisposeType dispose;
const char *option;
int x;
Data_Get_Struct(self, Info, info);
if (NIL_P(disp))
{
(void) RemoveImageOption(info, "dispose");
return self;
}
VALUE_TO_ENUM(disp, dispose, DisposeType);
option = "Undefined";
for (x = 0; x < N_DISPOSE_OPTIONS; x++)
{
if (dispose == Dispose_Option[x].enumerator)
{
option = Dispose_Option[x].string;
break;
}
}
(void) SetImageOption(info, "dispose", option);
return self;
}
/*
Method: Info#image_type=
Purpose: Set the classification type
Raises: ArgumentError
*/
VALUE
Info_image_type_eq(VALUE self, VALUE type)
{
Info *info;
Data_Get_Struct(self, Info, info);
VALUE_TO_ENUM(type, info->type, ImageType);
return self;
}
/*
Method: Info#interlace=
Purpose: Set the interlace type
Raises: ArgumentError
*/
VALUE
Info_interlace_eq(VALUE self, VALUE inter)
{
Info *info;
Data_Get_Struct(self, Info, info);
VALUE_TO_ENUM(inter, info->interlace, InterlaceType);
return self;
}
/*
Method: Info#Orientation=
Purpose: Set the Orientation type
Raises: ArgumentError
*/
VALUE
Info_orientation_eq(VALUE self, VALUE inter)
{
Info *info;
Data_Get_Struct(self, Info, info);
VALUE_TO_ENUM(inter, info->orientation, OrientationType);
return self;
}
/*
Method: Info#units=
Purpose: Set the resolution type
Raises: ArgumentError
*/
VALUE
Info_units_eq(VALUE self, VALUE units)
{
Info *info;
Data_Get_Struct(self, Info, info);
VALUE_TO_ENUM(units, info->units, ResolutionType);
return self;
}
/*
Method: Info#colorspace=
Purpose: Set the colorspace type
Raises: ArgumentError
*/
VALUE
Info_colorspace_eq(VALUE self, VALUE colorspace)
{
Info *info;
Data_Get_Struct(self, Info, info);
VALUE_TO_ENUM(colorspace, info->colorspace, ColorspaceType);
return self;
}
/*
Method: Info#compression=
Purpose: Set the compression type
Raises: ArgumentError
*/
VALUE
Info_compression_eq(VALUE self, VALUE type)
{
Info *info;
Data_Get_Struct(self, Info, info);
VALUE_TO_ENUM(type, info->compression, CompressionType);
return self;
}
/*
Method: ImageList#composite_layers
Purpose: Equivalent to convert's -layers composite option
Notes: see mogrify.c
*/
VALUE
ImageList_composite_layers(int argc, VALUE *argv, VALUE self)
{
#if defined(HAVE_COMPOSITELAYERS)
volatile VALUE source_images;
Image *dest, *source, *new_images;
RectangleInfo geometry;
CompositeOperator operator = OverCompositeOp;
ExceptionInfo exception;
switch (argc)
{
case 2:
VALUE_TO_ENUM(argv[1], operator, CompositeOperator);
case 1:
source_images = argv[0];
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (expected 1 or 2, got %d)", argc);
break;
}
// Convert ImageLists to image sequences.
dest = images_from_imagelist(self);
new_images = clone_imagelist(dest);
rm_split(dest);
source = images_from_imagelist(source_images);
SetGeometry(new_images,&geometry);
(void) ParseAbsoluteGeometry(new_images->geometry, &geometry);
geometry.width = source->page.width != 0 ? source->page.width : source->columns;
geometry.height = source->page.height != 0 ? source->page.height : source->rows;
GravityAdjustGeometry(new_images->page.width != 0 ? new_images->page.width : new_images->columns
, new_images->page.height != 0 ? new_images->page.height : new_images->rows
, new_images->gravity, &geometry);
GetExceptionInfo(&exception);
CompositeLayers(new_images, operator, source, geometry.x, geometry.y, &exception);
rm_split(source);
rm_check_exception(&exception, new_images, DestroyOnError);
(void) DestroyExceptionInfo(&exception);
return rm_imagelist_from_images(new_images);
#else
self = self;
argc = argc;
argv = argv;
rm_not_implemented();
return (VALUE)0;
#endif
}
/**
* Font_stretch attribute writer.
*
* Ruby usage:
* - @verbatim Draw#font_stretch= @endverbatim
*
* @param self this object
* @param stretch the font_stretch
* @return stretch
*/
VALUE
Draw_font_stretch_eq(VALUE self, VALUE stretch)
{
Draw *draw;
rb_check_frozen(self);
Data_Get_Struct(self, Draw, draw);
VALUE_TO_ENUM(stretch, draw->info->stretch, StretchType);
return stretch;
}
/*
Method: Draw#font_style=
Purpose: font_style attribute writer
*/
VALUE
Draw_font_style_eq(VALUE self, VALUE style)
{
Draw *draw;
rb_check_frozen(self);
Data_Get_Struct(self, Draw, draw);
VALUE_TO_ENUM(style, draw->info->style, StyleType);
return self;
}
/*
Method: Draw#decorate=
Purpose: decorate attribute writer
*/
VALUE
Draw_decorate_eq(VALUE self, VALUE decorate)
{
Draw *draw;
rb_check_frozen(self);
Data_Get_Struct(self, Draw, draw);
VALUE_TO_ENUM(decorate, draw->info->decorate, DecorationType);
return self;
}
/*
Method: Draw#align=
Purpose: set the text alignment
*/
VALUE
Draw_align_eq(VALUE self, VALUE align)
{
Draw *draw;
rb_check_frozen(self);
Data_Get_Struct(self, Draw, draw);
VALUE_TO_ENUM(align, draw->info->align, AlignType);
return self;
}
/*
Method: Draw#gravity=
Purpose: gravity attribute writer
Notes: From Magick++'s Image.h header file:
Gravity affects text placement in bounding area according to rules:
NorthWestGravity text bottom-left corner placed at top-left
NorthGravity text bottom-center placed at top-center
NorthEastGravity text bottom-right corner placed at top-right
WestGravity text left-center placed at left-center
CenterGravity text center placed at center
EastGravity text right-center placed at right-center
SouthWestGravity text top-left placed at bottom-left
SouthGravity text top-center placed at bottom-center
SouthEastGravity text top-right placed at bottom-right
*/
VALUE
Draw_gravity_eq(VALUE self, VALUE grav)
{
Draw *draw;
rb_check_frozen(self);
Data_Get_Struct(self, Draw, draw);
VALUE_TO_ENUM(grav, draw->info->gravity, GravityType);
return self;
}
VALUE
Info_endian_eq(VALUE self, VALUE endian)
{
Info *info;
EndianType type = UndefinedEndian;
if (endian != Qnil)
{
VALUE_TO_ENUM(endian, type, EndianType);
}
Data_Get_Struct(self, Info, info);
info->endian = type;
return self;
}
/*
Method: Draw#font_weight=
Purpose: font_weight attribute writer
Notes: The font weight can be one of the font weight constants
or a number between 100 and 900
*/
VALUE
Draw_font_weight_eq(VALUE self, VALUE weight)
{
Draw *draw;
WeightType w;
rb_check_frozen(self);
Data_Get_Struct(self, Draw, draw);
if (FIXNUM_P(weight))
{
w = (WeightType) FIX2INT(weight);
if (w < 100 || w > 900)
{
rb_raise(rb_eArgError, "invalid font weight (%d given)", w);
}
draw->info->weight = w;
}
else
{
VALUE_TO_ENUM(weight, w, WeightType);
switch (w)
{
case AnyWeight:
draw->info->weight = 0;
break;
case NormalWeight:
draw->info->weight = 400;
break;
case BoldWeight:
draw->info->weight = 700;
break;
case BolderWeight:
if (draw->info->weight <= 800)
draw->info->weight += 100;
break;
case LighterWeight:
if (draw->info->weight >= 100)
draw->info->weight -= 100;
break;
default:
rb_raise(rb_eArgError, "unknown font weight");
break;
}
}
return self;
}
/**
* Equivalent to convert's -layers composite option.
*
* Ruby usage:
* - @verbatim ImageList#composite_layers(images) @endverbatim
* - @verbatim ImageList#composite_layers(images,operator) @endverbatim
*
* Notes:
* - Default operator is OverCompositeOp
*
* @param argc number of input arguments
* @param argv array of input arguments
* @param self this object
* @return a new imagelist
* @see mogrify.c in ImageMagick
*/
VALUE
ImageList_composite_layers(int argc, VALUE *argv, VALUE self)
{
VALUE source_images;
Image *dest, *source, *new_images;
RectangleInfo geometry;
CompositeOperator operator = OverCompositeOp;
ExceptionInfo *exception;
switch (argc)
{
case 2:
VALUE_TO_ENUM(argv[1], operator, CompositeOperator);
case 1:
source_images = argv[0];
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (expected 1 or 2, got %d)", argc);
break;
}
// Convert ImageLists to image sequences.
dest = images_from_imagelist(self);
new_images = clone_imagelist(dest);
rm_split(dest);
source = images_from_imagelist(source_images);
SetGeometry(new_images,&geometry);
(void) ParseAbsoluteGeometry(new_images->geometry, &geometry);
geometry.width = source->page.width != 0 ? source->page.width : source->columns;
geometry.height = source->page.height != 0 ? source->page.height : source->rows;
GravityAdjustGeometry(new_images->page.width != 0 ? new_images->page.width : new_images->columns
, new_images->page.height != 0 ? new_images->page.height : new_images->rows
, new_images->gravity, &geometry);
exception = AcquireExceptionInfo();
CompositeLayers(new_images, operator, source, geometry.x, geometry.y, exception);
rm_split(source);
rm_check_exception(exception, new_images, DestroyOnError);
(void) DestroyExceptionInfo(exception);
RB_GC_GUARD(source_images);
return rm_imagelist_from_images(new_images);
}
/**
* Call RemapImages.
*
* Ruby usage:
* - @verbatim ImageList#remap @endverbatim
* - @verbatim ImageList#remap(remap_image) @endverbatim
* - @verbatim ImageList#remap(remap_image, dither_method) @endverbatim
*
* Notes:
* - Default remap_image is nil
* - Default dither_method is RiemersmaDitherMethod
* - Modifies images in-place.
*
* @param argc number of input arguments
* @param argv array of input arguments
* @param self this object
* @see Image_remap
*/
VALUE
ImageList_remap(int argc, VALUE *argv, VALUE self)
{
#if defined(HAVE_REMAPIMAGES) || defined(HAVE_AFFINITYIMAGES)
Image *images, *remap_image = NULL;
QuantizeInfo quantize_info;
if (argc > 0 && argv[0] != Qnil)
{
VALUE t = rm_cur_image(argv[0]);
remap_image = rm_check_destroyed(t);
RB_GC_GUARD(t);
}
GetQuantizeInfo(&quantize_info);
if (argc > 1)
{
VALUE_TO_ENUM(argv[1], quantize_info.dither_method, DitherMethod);
quantize_info.dither = MagickTrue;
}
if (argc > 2)
{
rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc);
}
images = images_from_imagelist(self);
#if defined(HAVE_REMAPIMAGE)
(void) RemapImages(&quantize_info, images, remap_image);
#else
(void) AffinityImages(&quantize_info, images, remap_image);
#endif
rm_check_image_exception(images, RetainOnError);
rm_split(images);
return self;
#else
self = self;
argc = argc;
argv = argv;
rm_not_implemented();
return(VALUE)0;
#endif
}
/*
Method: ImageList#quantize(<number_colors<, colorspace<, dither<, tree_depth<, measure_error>>>>>)
defaults: 256, Magick::RGBColorspace, true, 0, false
Purpose: call QuantizeImages
Returns: a new ImageList with quantized images. 'scene' is set to the same
value as self.scene
*/
VALUE
ImageList_quantize(int argc, VALUE *argv, VALUE self)
{
Image *images, *new_images;
Image *new_image;
QuantizeInfo quantize_info;
ExceptionInfo exception;
volatile VALUE new_imagelist, scene;
GetQuantizeInfo(&quantize_info);
switch (argc)
{
case 5:
quantize_info.measure_error = (MagickBooleanType) RTEST(argv[4]);
case 4:
quantize_info.tree_depth = (unsigned long)NUM2INT(argv[3]);
case 3:
quantize_info.dither = (MagickBooleanType) RTEST(argv[2]);
case 2:
VALUE_TO_ENUM(argv[1], quantize_info.colorspace, ColorspaceType);
case 1:
quantize_info.number_colors = NUM2ULONG(argv[0]);
case 0:
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 to 5)", argc);
break;
}
if (imagelist_length(self) == 0L)
{
rb_raise(rb_eArgError, "no images in this image list");
}
// Convert image array to image sequence, clone image sequence.
GetExceptionInfo(&exception);
images = images_from_imagelist(self);
new_images = CloneImageList(images, &exception);
rm_split(images);
rm_check_exception(&exception, new_images, DestroyOnError);
(void) DestroyExceptionInfo(&exception);
rm_ensure_result(new_images);
(void) QuantizeImages(&quantize_info, new_images);
rm_check_exception(&exception, new_images, DestroyOnError);
// Create new ImageList object, convert mapped image sequence to images,
// append to images array.
new_imagelist = ImageList_new();
while ((new_image = ShiftImageList(&new_images)))
{
imagelist_push(new_imagelist, rm_image_new(new_image));
}
// Set @scene in new ImageList object to same value as in self.
scene = rb_iv_get(self, "@scene");
(void) rb_iv_set(new_imagelist, "@scene", scene);
return new_imagelist;
}
/**
* Implement the "image" drawing primitive.
*
* Ruby usage:
* - @verbatim Draw#composite(x,y,width,height,img) @endverbatim
* - @verbatim Draw#composite(x,y,width,height,img,operator) @endverbatim
*
* Notes:
* - Default operator is overComposite
* - The "img" argument can be either an ImageList object or an Image
* argument.
*
* @param argc number of input arguments
* @param argv array of input arguments
* @param self this object
* @return self
*/
VALUE
Draw_composite(int argc, VALUE *argv, VALUE self)
{
Draw *draw;
const char *op;
double x, y, width, height;
CompositeOperator cop;
VALUE image;
Image *comp_img;
struct TmpFile_Name *tmpfile_name;
char name[MaxTextExtent];
// Buffer for "image" primitive
char primitive[MaxTextExtent];
if (argc < 5 || argc > 6)
{
rb_raise(rb_eArgError, "wrong number of arguments (%d for 5 or 6)", argc);
}
// Retrieve the image to composite
image = rm_cur_image(argv[4]);
comp_img = rm_check_destroyed(image);
x = NUM2DBL(argv[0]);
y = NUM2DBL(argv[1]);
width = NUM2DBL(argv[2]);
height = NUM2DBL(argv[3]);
cop = OverCompositeOp;
if (argc == 6)
{
VALUE_TO_ENUM(argv[5], cop, CompositeOperator);
}
op = CommandOptionToMnemonic(MagickComposeOptions, cop);
if (rm_strcasecmp("Unrecognized", op) == 0)
{
rb_raise(rb_eArgError, "unknown composite operator (%d)", cop);
}
Data_Get_Struct(self, Draw, draw);
// Create a temp copy of the composite image
rm_write_temp_image(comp_img, name);
// Add the temp filename to the filename array.
// Use Magick storage since we need to keep the list around
// until destroy_Draw is called.
tmpfile_name = magick_malloc(sizeof(struct TmpFile_Name)+strlen(name));
strcpy(tmpfile_name->name, name);
tmpfile_name->next = draw->tmpfile_ary;
draw->tmpfile_ary = tmpfile_name;
// Form the drawing primitive
(void) snprintf(primitive, sizeof(primitive), "image %s %g,%g,%g,%g '%s'", op, x, y, width, height, name);
// Send "primitive" to self.
(void) rb_funcall(self, rb_intern("primitive"), 1, rb_str_new2(primitive));
RB_GC_GUARD(image);
return self;
}
/**
* Call QuantizeImages.
*
* Ruby usage:
* - @verbatim ImageList#quantize @endverbatim
* - @verbatim ImageList#quantize(number_colors) @endverbatim
* - @verbatim ImageList#quantize(number_colors, colorspace) @endverbatim
* - @verbatim ImageList#quantize(number_colors, colorspace, dither) @endverbatim
* - @verbatim ImageList#quantize(number_colors, colorspace, dither, tree_depth) @endverbatim
* - @verbatim ImageList#quantize(number_colors, colorspace, dither, tree_depth, measure_error) @endverbatim
*
* Notes:
* - Default number_colors is 256
* - Default coorspace is Magick::RGBColorsapce
* - Default dither is true
* - Default tree_depth is 0
* - Default measure_error is false
* - Sets \@scene to the same value as self.scene
*
* @param argc number of input arguments
* @param argv array of input arguments
* @param self this object
* @return a new ImageList with quantized images
*/
VALUE
ImageList_quantize(int argc, VALUE *argv, VALUE self)
{
Image *images, *new_images;
Image *new_image;
QuantizeInfo quantize_info;
ExceptionInfo *exception;
VALUE new_imagelist, scene;
GetQuantizeInfo(&quantize_info);
switch (argc)
{
case 5:
quantize_info.measure_error = (MagickBooleanType) RTEST(argv[4]);
case 4:
quantize_info.tree_depth = (unsigned long)NUM2INT(argv[3]);
case 3:
#if defined(HAVE_TYPE_DITHERMETHOD) && defined(HAVE_ENUM_NODITHERMETHOD)
if (rb_obj_is_kind_of(argv[2], Class_DitherMethod))
{
VALUE_TO_ENUM(argv[2], quantize_info.dither_method, DitherMethod);
quantize_info.dither = quantize_info.dither_method != NoDitherMethod;
}
#else
quantize_info.dither = (MagickBooleanType) RTEST(argv[2]);
#endif
case 2:
VALUE_TO_ENUM(argv[1], quantize_info.colorspace, ColorspaceType);
case 1:
quantize_info.number_colors = NUM2ULONG(argv[0]);
case 0:
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 to 5)", argc);
break;
}
// Convert image array to image sequence, clone image sequence.
exception = AcquireExceptionInfo();
images = images_from_imagelist(self);
new_images = CloneImageList(images, exception);
rm_split(images);
rm_check_exception(exception, new_images, DestroyOnError);
rm_ensure_result(new_images);
(void) QuantizeImages(&quantize_info, new_images);
rm_check_exception(exception, new_images, DestroyOnError);
(void) DestroyExceptionInfo(exception);
// Create new ImageList object, convert mapped image sequence to images,
// append to images array.
new_imagelist = ImageList_new();
while ((new_image = RemoveFirstImageFromList(&new_images)))
{
imagelist_push(new_imagelist, rm_image_new(new_image));
}
// Set @scene in new ImageList object to same value as in self.
scene = rb_iv_get(self, "@scene");
(void) rb_iv_set(new_imagelist, "@scene", scene);
RB_GC_GUARD(new_imagelist);
RB_GC_GUARD(scene);
return new_imagelist;
}
/**
* Equivalent to -layers option in ImageMagick 6.2.6.
*
* Ruby usage:
* - @verbatim ImageList#optimize_layers(method) @endverbatim
*
* @param self this object
* @param method the method to use
* @return a new imagelist
*/
VALUE
ImageList_optimize_layers(VALUE self, VALUE method)
{
Image *images, *new_images, *new_images2;
LAYERMETHODTYPE mthd;
ExceptionInfo *exception;
QuantizeInfo quantize_info;
new_images2 = NULL; // defeat "unused variable" message
exception = AcquireExceptionInfo();
#if defined(HAVE_TYPE_IMAGELAYERMETHOD)
VALUE_TO_ENUM(method, mthd, ImageLayerMethod);
#else
VALUE_TO_ENUM(method, mthd, MagickLayerMethod);
#endif
images = images_from_imagelist(self);
switch (mthd)
{
case CoalesceLayer:
new_images = CoalesceImages(images, exception);
break;
case DisposeLayer:
new_images = DisposeImages(images, exception);
break;
case OptimizeTransLayer:
new_images = clone_imagelist(images);
OptimizeImageTransparency(new_images, exception);
break;
case RemoveDupsLayer:
new_images = clone_imagelist(images);
RemoveDuplicateLayers(&new_images, exception);
break;
case RemoveZeroLayer:
new_images = clone_imagelist(images);
RemoveZeroDelayLayers(&new_images, exception);
break;
case CompositeLayer:
rm_split(images);
rb_raise(rb_eNotImpError, "Magick::CompositeLayer is not supported. Use the composite_layers method instead.");
break;
// In 6.3.4-ish, OptimizeImageLayer replaced OptimizeLayer
case OptimizeImageLayer:
new_images = OptimizeImageLayers(images, exception);
break;
// and OptimizeLayer became a "General Purpose, GIF Animation Optimizer" (ref. mogrify.c)
case OptimizeLayer:
new_images = CoalesceImages(images, exception);
rm_split(images);
rm_check_exception(exception, new_images, DestroyOnError);
new_images2 = OptimizeImageLayers(new_images, exception);
DestroyImageList(new_images);
rm_check_exception(exception, new_images2, DestroyOnError);
new_images = new_images2;
OptimizeImageTransparency(new_images, exception);
rm_check_exception(exception, new_images, DestroyOnError);
// mogrify supports -dither here. We don't.
#if defined(HAVE_REMAPIMAGE)
GetQuantizeInfo(&quantize_info);
(void) RemapImages(&quantize_info, new_images, NULL);
#else
(void) MapImages(new_images, NULL, 0);
#endif
break;
case OptimizePlusLayer:
new_images = OptimizePlusImageLayers(images, exception);
break;
case CompareAnyLayer:
case CompareClearLayer:
case CompareOverlayLayer:
new_images = CompareImageLayers(images, mthd, exception);
break;
#if defined(HAVE_ENUM_MOSAICLAYER)
case MosaicLayer:
new_images = MergeImageLayers(images, mthd, exception);
break;
#endif
#if defined(HAVE_ENUM_FLATTENLAYER)
case FlattenLayer:
new_images = MergeImageLayers(images, mthd, exception);
break;
#endif
#if defined(HAVE_ENUM_MERGELAYER)
case MergeLayer:
new_images = MergeImageLayers(images, mthd, exception);
break;
#endif
#if defined(HAVE_ENUM_TRIMBOUNDSLAYER)
case TrimBoundsLayer:
new_images = MergeImageLayers(images, mthd, exception);
break;
#endif
default:
rm_split(images);
rb_raise(rb_eArgError, "undefined layer method");
break;
}
rm_split(images);
rm_check_exception(exception, new_images, DestroyOnError);
(void) DestroyExceptionInfo(exception);
rm_ensure_result(new_images);
return rm_imagelist_from_images(new_images);
}
/*
Method: ImageList#optimize_layers
Purpose: Equivalent to -layers option in 6.2.6
Returns: a new imagelist
*/
VALUE
ImageList_optimize_layers(VALUE self, VALUE method)
{
Image *images, *new_images, *new_images2;
LAYERMETHODTYPE mthd;
ExceptionInfo exception;
new_images2 = NULL; // defeat "unused variable" message
GetExceptionInfo(&exception);
#if defined(HAVE_TYPE_IMAGELAYERMETHOD)
VALUE_TO_ENUM(method, mthd, ImageLayerMethod);
#else
VALUE_TO_ENUM(method, mthd, MagickLayerMethod);
#endif
images = images_from_imagelist(self);
switch (mthd)
{
case CoalesceLayer:
new_images = CoalesceImages(images, &exception);
break;
case DisposeLayer:
new_images = DisposeImages(images, &exception);
break;
#if defined(HAVE_ENUM_OPTIMIZETRANSLAYER)
case OptimizeTransLayer:
new_images = clone_imagelist(images);
OptimizeImageTransparency(new_images, &exception);
break;
#endif
#if defined(HAVE_ENUM_REMOVEDUPSLAYER)
case RemoveDupsLayer:
new_images = clone_imagelist(images);
RemoveDuplicateLayers(&new_images, &exception);
break;
#endif
#if defined(HAVE_ENUM_REMOVEZEROLAYER)
case RemoveZeroLayer:
new_images = clone_imagelist(images);
RemoveZeroDelayLayers(&new_images, &exception);
break;
#endif
#if defined(HAVE_ENUM_COMPOSITELAYER)
case CompositeLayer:
rb_raise(rb_eNotImpError, "Magick::CompositeLayer is not yet supported.");
break;
#endif
#if defined(HAVE_ENUM_OPTIMIZEIMAGELAYER)
// In 6.3.4-ish, OptimizeImageLayer replaced OptimizeLayer
case OptimizeImageLayer:
new_images = OptimizeImageLayers(images, &exception);
break;
// and OptimizeLayer became a "General Purpose, GIF Animation Optimizer" (ref. mogrify.c)
case OptimizeLayer:
new_images = CoalesceImages(images, &exception);
rm_split(images);
rm_check_exception(&exception, new_images, DestroyOnError);
new_images2 = OptimizeImageLayers(new_images, &exception);
DestroyImageList(new_images);
rm_check_exception(&exception, new_images2, DestroyOnError);
new_images = new_images2;
OptimizeImageTransparency(new_images, &exception);
rm_check_exception(&exception, new_images, DestroyOnError);
// mogrify supports -dither here. We don't.
(void) MapImages(new_images, NULL, 0);
break;
#else
case OptimizeLayer:
new_images = OptimizeImageLayers(images, &exception);
break;
#endif
case OptimizePlusLayer:
new_images = OptimizePlusImageLayers(images, &exception);
break;
case CompareAnyLayer:
case CompareClearLayer:
case CompareOverlayLayer:
new_images = CompareImageLayers(images, mthd, &exception);
break;
default:
rb_raise(rb_eArgError, "undefined layer method");
break;
}
rm_split(images);
rm_check_exception(&exception, new_images, DestroyOnError);
(void) DestroyExceptionInfo(&exception);
rm_ensure_result(new_images);
return rm_imagelist_from_images(new_images);
}
/*
Method: Draw#composite(x,y,width,height,img,operator=OverCompositeOp)
Purpose: Implement the "image" drawing primitive
Notes: The "img" argument can be either an ImageList object
or an Image argument.
*/
VALUE
Draw_composite(int argc, VALUE *argv, VALUE self)
{
Draw *draw;
const char *op = "Over";
double x, y, width, height;
CompositeOperator cop = OverCompositeOp;
volatile VALUE image;
Image *comp_img;
struct TmpFile_Name *tmpfile_name;
char name[MaxTextExtent];
// Buffer for "image" primitive
char primitive[MaxTextExtent];
if (argc < 5 || argc > 6)
{
rb_raise(rb_eArgError, "wrong number of arguments (%d for 5 or 6)", argc);
}
// Retrieve the image to composite
image = rm_cur_image(argv[4]);
(void) rm_check_destroyed(image);
x = NUM2DBL(argv[0]);
y = NUM2DBL(argv[1]);
width = NUM2DBL(argv[2]);
height = NUM2DBL(argv[3]);
// The default composition operator is "Over".
if (argc == 6)
{
VALUE_TO_ENUM(argv[5], cop, CompositeOperator);
switch (cop)
{
case AddCompositeOp:
op = "Add";
break;
case AtopCompositeOp:
op = "Atop";
break;
case BumpmapCompositeOp:
op = "Bumpmap";
break;
case ClearCompositeOp:
op = "Clear";
break;
case CopyBlueCompositeOp:
op = "CopyBlue";
break;
case CopyGreenCompositeOp:
op = "CopyGreen";
break;
case CopyOpacityCompositeOp:
op = "CopyOpacity";
break;
case CopyRedCompositeOp:
op = "CopyRed";
break;
case CopyCompositeOp:
op = "Copy";
break;
case DifferenceCompositeOp:
op = "Difference";
break;
case InCompositeOp:
op = "In";
break;
case MinusCompositeOp:
op = "Minus";
break;
case MultiplyCompositeOp:
op = "Multiply";
break;
case OutCompositeOp:
op = "Out";
break;
case OverCompositeOp:
op = "Over";
break;
case PlusCompositeOp:
op = "Plus";
break;
case SubtractCompositeOp:
op = "Subtract";
break;
case XorCompositeOp:
op = "Xor";
break;
default:
rb_raise(rb_eArgError, "unknown composite operator (%d)", cop);
break;
}
}
Data_Get_Struct(self, Draw, draw);
// Create a temp copy of the composite image
Data_Get_Struct(image, Image, comp_img);
rm_write_temp_image(comp_img, name);
// Add the temp filename to the filename array.
// Use Magick storage since we need to keep the list around
// until destroy_Draw is called.
tmpfile_name = magick_malloc(sizeof(struct TmpFile_Name)+strlen(name));
strcpy(tmpfile_name->name, name);
tmpfile_name->next = draw->tmpfile_ary;
draw->tmpfile_ary = tmpfile_name;
// Form the drawing primitive
(void) sprintf(primitive, "image %s %g,%g,%g,%g '%s'", op, x, y, width, height, name);
// Send "primitive" to self.
(void) rb_funcall(self, rb_intern("primitive"), 1, rb_str_new2(primitive));
return self;
}
