void InputZone::step()
{
if(m_recognized_characters.size() == 1)
m_characters.push_back(m_recognized_characters.front());
else
m_unrecognized_images.insert(m_images.size()-1);
m_recognized_characters.clear();
m_images.push_back(CompositeImage());
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% I m p o r t I m a g e P i x e l s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ImportImagePixels() accepts pixel data and stores in the image at the
% location you specify. The method returns True on success otherwise False
% if an error is encountered. The pixel data can be either char, short int,
% int, long, float, or double in the order specified by map.
%
% Suppose your want want to upload the first scanline of a 640x480 image from
% character data in red-green-blue order:
%
% ImportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels);
%
% The format of the ImportImagePixels method is:
%
% unsigned int ImportImagePixels(Image *image,const long x_offset,
% const long y_offset,const unsigned long columns,
% const unsigned long rows,const char *map,const StorageType type,
% const void *pixels)
%
% A description of each parameter follows:
%
% o image: The image.
%
% o x_offset, y_offset: Offset (from top left) on base image on which
% to composite image data.
%
% o map: This string reflects the expected ordering of the pixel array.
% It can be any combination or order of R = red, G = green, B = blue,
% A = alpha (same as Transparency), O = Opacity, T = Transparency,
% C = cyan, Y = yellow, M = magenta, K = black, or I = intensity
% (for grayscale). Specify "P" = pad, to skip over a quantum which is
% intentionally ignored. Creation of an alpha channel for CMYK images
% is currently not supported.
%
% o type: Define the data type of the pixels. Float and double types are
% normalized to [0..1] otherwise [0..MaxRGB]. Choose from these types:
% CharPixel, ShortPixel, IntegerPixel, LongPixel, FloatPixel, or
% DoublePixel.
%
% o pixels: This array of values contain the pixel components as defined by
% map and type. You must preallocate this array where the expected
% length varies depending on the values of width, height, map, and type.
%
%
*/
WandExport unsigned int ImportImagePixels(Image *image,const long x_offset,
const long y_offset,const unsigned long columns,const unsigned long rows,
const char *map,const StorageType type,const void *pixels)
{
Image
*constitute_image;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
constitute_image=
ConstituteImage(columns,rows,map,type,pixels,&image->exception);
if (constitute_image)
{
(void) CompositeImage(image,CopyCompositeOp,constitute_image,x_offset,
y_offset);
DestroyImage(constitute_image);
return (image->exception.severity == UndefinedException);
}
return (False);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d X C F I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ReadXCFImage() reads a GIMP (GNU Image Manipulation Program) image
% file and returns it. It allocates the memory necessary for the new Image
% structure and returns a pointer to the new image.
%
% The format of the ReadXCFImage method is:
%
% image=ReadXCFImage(image_info)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o exception: return any errors or warnings in this structure.
%
%
*/
static Image *ReadXCFImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
char
magick[14];
Image
*image;
int
foundPropEnd = 0;
MagickBooleanType
status;
MagickOffsetType
offset;
register ssize_t
i;
size_t
length;
ssize_t
count;
size_t
image_type;
XCFDocInfo
doc_info;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AcquireImage(image_info);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
count=ReadBlob(image,14,(unsigned char *) magick);
if ((count == 0) ||
(LocaleNCompare((char *) magick,"gimp xcf",8) != 0))
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
(void) ResetMagickMemory(&doc_info,0,sizeof(XCFDocInfo));
doc_info.exception=exception;
doc_info.width=ReadBlobMSBLong(image);
doc_info.height=ReadBlobMSBLong(image);
if ((doc_info.width > 262144) || (doc_info.height > 262144))
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
doc_info.image_type=ReadBlobMSBLong(image);
/*
Initialize image attributes.
*/
image->columns=doc_info.width;
image->rows=doc_info.height;
image_type=doc_info.image_type;
doc_info.file_size=GetBlobSize(image);
image->compression=NoCompression;
image->depth=8;
if (image_type == GIMP_RGB)
image->colorspace=RGBColorspace;
else
if (image_type == GIMP_GRAY)
image->colorspace=GRAYColorspace;
else
if (image_type == GIMP_INDEXED)
ThrowReaderException(CoderError,"ColormapTypeNotSupported");
(void) SetImageBackgroundColor(image);
image->matte=MagickTrue;
/*
Read properties.
*/
while ((foundPropEnd == MagickFalse) && (EOFBlob(image) == MagickFalse))
{
PropType prop_type = (PropType) ReadBlobMSBLong(image);
size_t prop_size = ReadBlobMSBLong(image);
switch (prop_type)
{
case PROP_END:
foundPropEnd=1;
break;
case PROP_COLORMAP:
{
/* Cannot rely on prop_size here--the value is set incorrectly
by some Gimp versions.
*/
size_t num_colours = ReadBlobMSBLong(image);
for (i=0; i < (ssize_t) (3L*num_colours); i++ )
(void) ReadBlobByte(image);
/*
if (info->file_version == 0)
{
gint i;
g_message (_("XCF warning: version 0 of XCF file format\n"
"did not save indexed colormaps correctly.\n"
"Substituting grayscale map."));
info->cp +=
xcf_read_int32 (info->fp, (guint32*) &gimage->num_cols, 1);
gimage->cmap = g_new (guchar, gimage->num_cols*3);
xcf_seek_pos (info, info->cp + gimage->num_cols);
for (i = 0; i<gimage->num_cols; i++)
{
gimage->cmap[i*3+0] = i;
gimage->cmap[i*3+1] = i;
gimage->cmap[i*3+2] = i;
}
}
else
{
info->cp +=
xcf_read_int32 (info->fp, (guint32*) &gimage->num_cols, 1);
gimage->cmap = g_new (guchar, gimage->num_cols*3);
info->cp +=
xcf_read_int8 (info->fp,
(guint8*) gimage->cmap, gimage->num_cols*3);
}
*/
break;
}
case PROP_COMPRESSION:
{
doc_info.compression = ReadBlobByte(image);
if ((doc_info.compression != COMPRESS_NONE) &&
(doc_info.compression != COMPRESS_RLE) &&
(doc_info.compression != COMPRESS_ZLIB) &&
(doc_info.compression != COMPRESS_FRACTAL))
ThrowReaderException(CorruptImageError,"UnrecognizedImageCompression");
}
break;
case PROP_GUIDES:
{
/* just skip it - we don't care about guides */
for (i=0; i < (ssize_t) prop_size; i++ )
if (ReadBlobByte(image) == EOF)
ThrowFileException(exception,CorruptImageError,
"UnexpectedEndOfFile",image->filename);
}
break;
case PROP_RESOLUTION:
{
/* float xres = (float) */ (void) ReadBlobMSBLong(image);
/* float yres = (float) */ (void) ReadBlobMSBLong(image);
/*
if (xres < GIMP_MIN_RESOLUTION || xres > GIMP_MAX_RESOLUTION ||
yres < GIMP_MIN_RESOLUTION || yres > GIMP_MAX_RESOLUTION)
{
g_message ("Warning, resolution out of range in XCF file");
xres = gimage->gimp->config->default_xresolution;
yres = gimage->gimp->config->default_yresolution;
}
*/
/* BOGUS: we don't write these yet because we aren't
reading them properly yet :(
image->x_resolution = xres;
image->y_resolution = yres;
*/
}
break;
case PROP_TATTOO:
{
/* we need to read it, even if we ignore it */
/*size_t tattoo_state = */ (void) ReadBlobMSBLong(image);
}
break;
case PROP_PARASITES:
{
/* BOGUS: we may need these for IPTC stuff */
for (i=0; i < (ssize_t) prop_size; i++ )
if (ReadBlobByte(image) == EOF)
ThrowFileException(exception,CorruptImageError,
"UnexpectedEndOfFile",image->filename);
/*
gssize_t base = info->cp;
GimpParasite *p;
while (info->cp - base < prop_size)
{
p = xcf_load_parasite (info);
gimp_image_parasite_attach (gimage, p);
gimp_parasite_free (p);
}
if (info->cp - base != prop_size)
g_message ("Error detected while loading an image's parasites");
*/
}
break;
case PROP_UNIT:
{
/* BOGUS: ignore for now... */
/*size_t unit = */ (void) ReadBlobMSBLong(image);
}
break;
case PROP_PATHS:
{
/* BOGUS: just skip it for now */
for (i=0; i< (ssize_t) prop_size; i++ )
if (ReadBlobByte(image) == EOF)
ThrowFileException(exception,CorruptImageError,
"UnexpectedEndOfFile",image->filename);
/*
PathList *paths = xcf_load_bzpaths (gimage, info);
gimp_image_set_paths (gimage, paths);
*/
}
break;
case PROP_USER_UNIT:
{
char unit_string[1000];
/*BOGUS: ignored for now */
/*float factor = (float) */ (void) ReadBlobMSBLong(image);
/* size_t digits = */ (void) ReadBlobMSBLong(image);
for (i=0; i<5; i++)
(void) ReadBlobStringWithLongSize(image, unit_string,
sizeof(unit_string));
}
break;
default:
{
int buf[16];
ssize_t amount;
/* read over it... */
while ((prop_size > 0) && (EOFBlob(image) == MagickFalse))
{
amount=(ssize_t) MagickMin(16, prop_size);
amount=(ssize_t) ReadBlob(image,(size_t) amount,(unsigned char *) &buf);
if (!amount)
ThrowReaderException(CorruptImageError,"CorruptImage");
prop_size -= (size_t) MagickMin(16,(size_t) amount);
}
}
break;
}
}
if (foundPropEnd == MagickFalse)
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
if ((image_info->ping != MagickFalse) && (image_info->number_scenes != 0))
{
; /* do nothing, were just pinging! */
}
else
{
int
current_layer = 0,
foundAllLayers = MagickFalse,
number_layers = 0;
MagickOffsetType
oldPos=TellBlob(image);
XCFLayerInfo
*layer_info;
/*
the read pointer
*/
do
{
ssize_t offset = (ssize_t) ReadBlobMSBLong(image);
if (offset == 0)
foundAllLayers=MagickTrue;
else
number_layers++;
if (EOFBlob(image) != MagickFalse)
{
ThrowFileException(exception,CorruptImageError,
"UnexpectedEndOfFile",image->filename);
break;
}
} while (foundAllLayers == MagickFalse);
offset=SeekBlob(image,oldPos,SEEK_SET); /* restore the position! */
if (offset < 0)
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
/* allocate our array of layer info blocks */
length=(size_t) number_layers;
layer_info=(XCFLayerInfo *) AcquireQuantumMemory(length,
sizeof(*layer_info));
if (layer_info == (XCFLayerInfo *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
(void) ResetMagickMemory(layer_info,0,number_layers*sizeof(XCFLayerInfo));
for ( ; ; )
{
MagickBooleanType
layer_ok;
MagickOffsetType
offset,
saved_pos;
/* read in the offset of the next layer */
offset=(MagickOffsetType) ReadBlobMSBLong(image);
/* if the offset is 0 then we are at the end
* of the layer list.
*/
if (offset == 0)
break;
/* save the current position as it is where the
* next layer offset is stored.
*/
saved_pos=TellBlob(image);
/* seek to the layer offset */
offset=SeekBlob(image,offset,SEEK_SET);
/* read in the layer */
layer_ok=ReadOneLayer(image,&doc_info,&layer_info[current_layer]);
if (layer_ok == MagickFalse)
{
int j;
for (j=0; j < current_layer; j++)
layer_info[j].image=DestroyImage(layer_info[j].image);
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
/* restore the saved position so we'll be ready to
* read the next offset.
*/
offset=SeekBlob(image, saved_pos, SEEK_SET);
current_layer++;
}
if (number_layers == 1)
{
/*
Composite the layer data onto the main image, dispose the layer.
*/
(void) CompositeImage(image,OverCompositeOp,layer_info[0].image,
layer_info[0].offset_x,layer_info[0].offset_y);
layer_info[0].image =DestroyImage( layer_info[0].image);
}
else
{
#if 0
{
/* NOTE: XCF layers are REVERSED from composite order! */
signed int j;
for (j=number_layers-1; j>=0; j--) {
/* BOGUS: need to consider layer blending modes!! */
if ( layer_info[j].visible ) { /* only visible ones, please! */
CompositeImage(image, OverCompositeOp, layer_info[j].image,
layer_info[j].offset_x, layer_info[j].offset_y );
layer_info[j].image =DestroyImage( layer_info[j].image );
/* Bob says that if we do this, we'll get REAL gray images! */
if ( image_type == GIMP_GRAY ) {
QuantizeInfo qi;
GetQuantizeInfo(&qi);
qi.colorspace = GRAYColorspace;
QuantizeImage( &qi, layer_info[j].image );
}
}
}
}
#else
{
/* NOTE: XCF layers are REVERSED from composite order! */
signed int j;
/* first we copy the last layer on top of the main image */
(void) CompositeImage(image,CopyCompositeOp,
layer_info[number_layers-1].image,
layer_info[number_layers-1].offset_x,
layer_info[number_layers-1].offset_y);
layer_info[number_layers-1].image=DestroyImage(
layer_info[number_layers-1].image);
/* now reverse the order of the layers as they are put
into subimages
*/
j=number_layers-2;
image->next=layer_info[j].image;
layer_info[j].image->previous=image;
layer_info[j].image->page.x=layer_info[j].offset_x;
layer_info[j].image->page.y=layer_info[j].offset_y;
layer_info[j].image->page.width=layer_info[j].width;
layer_info[j].image->page.height=layer_info[j].height;
for (j=number_layers-3; j>=0; j--)
{
if (j > 0)
layer_info[j].image->next=layer_info[j-1].image;
if (j < (number_layers-1))
layer_info[j].image->previous=layer_info[j+1].image;
layer_info[j].image->page.x=layer_info[j].offset_x;
layer_info[j].image->page.y=layer_info[j].offset_y;
layer_info[j].image->page.width=layer_info[j].width;
layer_info[j].image->page.height=layer_info[j].height;
}
}
#endif
}
layer_info=(XCFLayerInfo *) RelinquishMagickMemory(layer_info);
#if 0 /* BOGUS: do we need the channels?? */
while (MagickTrue)
{
/* read in the offset of the next channel */
info->cp += xcf_read_int32 (info->fp, &offset, 1);
/* if the offset is 0 then we are at the end
* of the channel list.
*/
if (offset == 0)
break;
/* save the current position as it is where the
* next channel offset is stored.
*/
saved_pos = info->cp;
/* seek to the channel offset */
xcf_seek_pos (info, offset);
/* read in the layer */
channel = xcf_load_channel (info, gimage);
if (channel == 0)
goto error;
num_successful_elements++;
/* add the channel to the image if its not the selection */
if (channel != gimage->selection_mask)
gimp_image_add_channel (gimage, channel, -1);
/* restore the saved position so we'll be ready to
* read the next offset.
*/
xcf_seek_pos (info, saved_pos);
}
#endif
}
(void) CloseBlob(image);
if (image_type == GIMP_GRAY)
image->type=GrayscaleType;
return(GetFirstImageInList(image));
}
static MagickBooleanType load_level(Image *image,XCFDocInfo *inDocInfo,
XCFLayerInfo *inLayerInfo)
{
ExceptionInfo
*exception;
int
destLeft = 0,
destTop = 0;
Image*
tile_image;
MagickBooleanType
status;
MagickOffsetType
saved_pos,
offset,
offset2;
register ssize_t
i;
size_t
width,
height,
ntiles,
ntile_rows,
ntile_cols,
tile_image_width,
tile_image_height;
/* start reading the data */
exception=inDocInfo->exception;
width=ReadBlobMSBLong(image);
height=ReadBlobMSBLong(image);
/* read in the first tile offset.
* if it is '0', then this tile level is empty
* and we can simply return.
*/
offset=(MagickOffsetType) ReadBlobMSBLong(image);
if (offset == 0)
return(MagickTrue);
/* Initialise the reference for the in-memory tile-compression
*/
ntile_rows=(height+TILE_HEIGHT-1)/TILE_HEIGHT;
ntile_cols=(width+TILE_WIDTH-1)/TILE_WIDTH;
ntiles=ntile_rows*ntile_cols;
for (i = 0; i < (ssize_t) ntiles; i++)
{
status=MagickFalse;
if (offset == 0)
ThrowBinaryException(CorruptImageError,"NotEnoughTiles",image->filename);
/* save the current position as it is where the
* next tile offset is stored.
*/
saved_pos=TellBlob(image);
/* read in the offset of the next tile so we can calculate the amount
of data needed for this tile*/
offset2=(MagickOffsetType)ReadBlobMSBLong(image);
/* if the offset is 0 then we need to read in the maximum possible
allowing for negative compression */
if (offset2 == 0)
offset2=(MagickOffsetType) (offset + TILE_WIDTH * TILE_WIDTH * 4* 1.5);
/* seek to the tile offset */
offset=SeekBlob(image, offset, SEEK_SET);
/* allocate the image for the tile
NOTE: the last tile in a row or column may not be a full tile!
*/
tile_image_width=(size_t) (destLeft == (int) ntile_cols-1 ?
(int) width % TILE_WIDTH : TILE_WIDTH);
if (tile_image_width == 0) tile_image_width=TILE_WIDTH;
tile_image_height = (size_t) (destTop == (int) ntile_rows-1 ?
(int) height % TILE_HEIGHT : TILE_HEIGHT);
if (tile_image_height == 0) tile_image_height=TILE_HEIGHT;
tile_image=CloneImage(inLayerInfo->image,tile_image_width,
tile_image_height,MagickTrue,exception);
/* read in the tile */
switch (inDocInfo->compression)
{
case COMPRESS_NONE:
if (load_tile(image,tile_image,inDocInfo,inLayerInfo,(size_t) (offset2-offset)) == 0)
status=MagickTrue;
break;
case COMPRESS_RLE:
if (load_tile_rle (image,tile_image,inDocInfo,inLayerInfo,
(int) (offset2-offset)) == 0)
status=MagickTrue;
break;
case COMPRESS_ZLIB:
ThrowBinaryException(CoderError,"ZipCompressNotSupported",
image->filename)
case COMPRESS_FRACTAL:
ThrowBinaryException(CoderError,"FractalCompressNotSupported",
image->filename)
}
/* composite the tile onto the layer's image, and then destroy it */
(void) CompositeImage(inLayerInfo->image,CopyCompositeOp,tile_image,
destLeft * TILE_WIDTH,destTop*TILE_HEIGHT);
tile_image=DestroyImage(tile_image);
/* adjust tile position */
destLeft++;
if (destLeft >= (int) ntile_cols)
{
destLeft = 0;
destTop++;
}
if (status != MagickFalse)
return(MagickFalse);
/* restore the saved position so we'll be ready to
* read the next offset.
*/
offset=SeekBlob(image, saved_pos, SEEK_SET);
/* read in the offset of the next tile */
offset=(MagickOffsetType) ReadBlobMSBLong(image);
}
if (offset != 0)
ThrowBinaryException(CorruptImageError,"CorruptImage",image->filename)
return(MagickTrue);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% F r a m e I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% FrameImage() adds a simulated three-dimensional border around the image.
% The color of the border is defined by the matte_color member of image.
% Members width and height of frame_info specify the border width of the
% vertical and horizontal sides of the frame. Members inner and outer
% indicate the width of the inner and outer shadows of the frame.
%
% The format of the FrameImage method is:
%
% Image *FrameImage(const Image *image,const FrameInfo *frame_info,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o frame_info: Define the width and height of the frame and its bevels.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
ExceptionInfo *exception)
{
#define FrameImageTag "Frame/Image"
CacheView
*image_view,
*frame_view;
Image
*frame_image;
MagickBooleanType
status;
MagickOffsetType
progress;
MagickPixelPacket
accentuate,
border,
highlight,
interior,
matte,
shadow,
trough;
register ssize_t
x;
size_t
bevel_width,
height,
width;
ssize_t
y;
/*
Check frame geometry.
*/
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(frame_info != (FrameInfo *) NULL);
if ((frame_info->outer_bevel < 0) || (frame_info->inner_bevel < 0))
ThrowImageException(OptionError,"FrameIsLessThanImageSize");
bevel_width=(size_t) (frame_info->outer_bevel+frame_info->inner_bevel);
width=frame_info->width-frame_info->x-bevel_width;
height=frame_info->height-frame_info->y-bevel_width;
if ((width < image->columns) || (height < image->rows))
ThrowImageException(OptionError,"FrameIsLessThanImageSize");
/*
Initialize framed image attributes.
*/
frame_image=CloneImage(image,frame_info->width,frame_info->height,MagickTrue,
exception);
if (frame_image == (Image *) NULL)
return((Image *) NULL);
if (SetImageStorageClass(frame_image,DirectClass) == MagickFalse)
{
InheritException(exception,&frame_image->exception);
frame_image=DestroyImage(frame_image);
return((Image *) NULL);
}
if (frame_image->matte_color.opacity != OpaqueOpacity)
frame_image->matte=MagickTrue;
frame_image->page=image->page;
if ((image->page.width != 0) && (image->page.height != 0))
{
frame_image->page.width+=frame_image->columns-image->columns;
frame_image->page.height+=frame_image->rows-image->rows;
}
/*
Initialize 3D effects color.
*/
GetMagickPixelPacket(frame_image,&interior);
SetMagickPixelPacket(frame_image,&image->border_color,(IndexPacket *) NULL,
&interior);
GetMagickPixelPacket(frame_image,&matte);
matte.colorspace=RGBColorspace;
SetMagickPixelPacket(frame_image,&image->matte_color,(IndexPacket *) NULL,
&matte);
GetMagickPixelPacket(frame_image,&border);
border.colorspace=RGBColorspace;
SetMagickPixelPacket(frame_image,&image->border_color,(IndexPacket *) NULL,
&border);
GetMagickPixelPacket(frame_image,&accentuate);
accentuate.red=(MagickRealType) (QuantumScale*((QuantumRange-
AccentuateModulate)*matte.red+(QuantumRange*AccentuateModulate)));
accentuate.green=(MagickRealType) (QuantumScale*((QuantumRange-
AccentuateModulate)*matte.green+(QuantumRange*AccentuateModulate)));
accentuate.blue=(MagickRealType) (QuantumScale*((QuantumRange-
AccentuateModulate)*matte.blue+(QuantumRange*AccentuateModulate)));
accentuate.opacity=matte.opacity;
GetMagickPixelPacket(frame_image,&highlight);
highlight.red=(MagickRealType) (QuantumScale*((QuantumRange-
HighlightModulate)*matte.red+(QuantumRange*HighlightModulate)));
highlight.green=(MagickRealType) (QuantumScale*((QuantumRange-
HighlightModulate)*matte.green+(QuantumRange*HighlightModulate)));
highlight.blue=(MagickRealType) (QuantumScale*((QuantumRange-
HighlightModulate)*matte.blue+(QuantumRange*HighlightModulate)));
highlight.opacity=matte.opacity;
GetMagickPixelPacket(frame_image,&shadow);
shadow.red=QuantumScale*matte.red*ShadowModulate;
shadow.green=QuantumScale*matte.green*ShadowModulate;
shadow.blue=QuantumScale*matte.blue*ShadowModulate;
shadow.opacity=matte.opacity;
GetMagickPixelPacket(frame_image,&trough);
trough.red=QuantumScale*matte.red*TroughModulate;
trough.green=QuantumScale*matte.green*TroughModulate;
trough.blue=QuantumScale*matte.blue*TroughModulate;
trough.opacity=matte.opacity;
if (image->colorspace == CMYKColorspace)
{
ConvertRGBToCMYK(&interior);
ConvertRGBToCMYK(&matte);
ConvertRGBToCMYK(&border);
ConvertRGBToCMYK(&accentuate);
ConvertRGBToCMYK(&highlight);
ConvertRGBToCMYK(&shadow);
ConvertRGBToCMYK(&trough);
}
status=MagickTrue;
progress=0;
image_view=AcquireCacheView(image);
frame_view=AcquireCacheView(frame_image);
height=(size_t) (frame_info->outer_bevel+(frame_info->y-bevel_width)+
frame_info->inner_bevel);
if (height != 0)
{
register IndexPacket
*restrict frame_indexes;
register ssize_t
x;
register PixelPacket
*restrict q;
/*
Draw top of ornamental border.
*/
q=QueueCacheViewAuthenticPixels(frame_view,0,0,frame_image->columns,
height,exception);
frame_indexes=GetCacheViewAuthenticIndexQueue(frame_view);
if (q != (PixelPacket *) NULL)
{
/*
Draw top of ornamental border.
*/
for (y=0; y < (ssize_t) frame_info->outer_bevel; y++)
{
for (x=0; x < (ssize_t) (frame_image->columns-y); x++)
{
if (x < y)
SetPixelPacket(frame_image,&highlight,q,frame_indexes);
else
SetPixelPacket(frame_image,&accentuate,q,frame_indexes);
q++;
frame_indexes++;
}
for ( ; x < (ssize_t) frame_image->columns; x++)
{
SetPixelPacket(frame_image,&shadow,q,frame_indexes);
q++;
frame_indexes++;
}
}
for (y=0; y < (ssize_t) (frame_info->y-bevel_width); y++)
{
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPacket(frame_image,&highlight,q,frame_indexes);
q++;
frame_indexes++;
}
width=frame_image->columns-2*frame_info->outer_bevel;
for (x=0; x < (ssize_t) width; x++)
{
SetPixelPacket(frame_image,&matte,q,frame_indexes);
q++;
frame_indexes++;
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPacket(frame_image,&shadow,q,frame_indexes);
q++;
frame_indexes++;
}
}
for (y=0; y < (ssize_t) frame_info->inner_bevel; y++)
{
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPacket(frame_image,&highlight,q,frame_indexes);
q++;
frame_indexes++;
}
for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
{
SetPixelPacket(frame_image,&matte,q,frame_indexes);
q++;
frame_indexes++;
}
width=image->columns+((size_t) frame_info->inner_bevel << 1)-
y;
for (x=0; x < (ssize_t) width; x++)
{
if (x < y)
SetPixelPacket(frame_image,&shadow,q,frame_indexes);
else
SetPixelPacket(frame_image,&trough,q,frame_indexes);
q++;
frame_indexes++;
}
for ( ; x < (ssize_t) (image->columns+2*frame_info->inner_bevel); x++)
{
SetPixelPacket(frame_image,&highlight,q,frame_indexes);
q++;
frame_indexes++;
}
width=frame_info->width-frame_info->x-image->columns-bevel_width;
for (x=0; x < (ssize_t) width; x++)
{
SetPixelPacket(frame_image,&matte,q,frame_indexes);
q++;
frame_indexes++;
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPacket(frame_image,&shadow,q,frame_indexes);
q++;
frame_indexes++;
}
}
(void) SyncCacheViewAuthenticPixels(frame_view,exception);
}
}
/*
Draw sides of ornamental border.
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register IndexPacket
*restrict frame_indexes;
register ssize_t
x;
register PixelPacket
*restrict q;
/*
Initialize scanline with matte color.
*/
if (status == MagickFalse)
continue;
q=QueueCacheViewAuthenticPixels(frame_view,0,frame_info->y+y,
frame_image->columns,1,exception);
if (q == (PixelPacket *) NULL)
{
status=MagickFalse;
continue;
}
frame_indexes=GetCacheViewAuthenticIndexQueue(frame_view);
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPacket(frame_image,&highlight,q,frame_indexes);
q++;
frame_indexes++;
}
for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
{
SetPixelPacket(frame_image,&matte,q,frame_indexes);
q++;
frame_indexes++;
}
for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)
{
SetPixelPacket(frame_image,&shadow,q,frame_indexes);
q++;
frame_indexes++;
}
/*
Set frame interior to interior color.
*/
if ((image->compose != CopyCompositeOp) &&
((image->compose != OverCompositeOp) || (image->matte != MagickFalse)))
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelPacket(frame_image,&interior,q,frame_indexes);
q++;
frame_indexes++;
}
else
{
register const IndexPacket
*indexes;
register const PixelPacket
*p;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
if (p == (const PixelPacket *) NULL)
{
status=MagickFalse;
continue;
}
indexes=GetCacheViewVirtualIndexQueue(image_view);
(void) CopyMagickMemory(q,p,image->columns*sizeof(*p));
if ((image->colorspace == CMYKColorspace) &&
(frame_image->colorspace == CMYKColorspace))
{
(void) CopyMagickMemory(frame_indexes,indexes,image->columns*
sizeof(*indexes));
frame_indexes+=image->columns;
}
q+=image->columns;
}
for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)
{
SetPixelPacket(frame_image,&highlight,q,frame_indexes);
q++;
frame_indexes++;
}
width=frame_info->width-frame_info->x-image->columns-bevel_width;
for (x=0; x < (ssize_t) width; x++)
{
SetPixelPacket(frame_image,&matte,q,frame_indexes);
q++;
frame_indexes++;
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPacket(frame_image,&shadow,q,frame_indexes);
q++;
frame_indexes++;
}
if (SyncCacheViewAuthenticPixels(frame_view,exception) == MagickFalse)
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp critical (MagickCore_FrameImage)
#endif
proceed=SetImageProgress(image,FrameImageTag,progress++,image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
height=(size_t) (frame_info->inner_bevel+frame_info->height-
frame_info->y-image->rows-bevel_width+frame_info->outer_bevel);
if (height != 0)
{
register IndexPacket
*restrict frame_indexes;
register ssize_t
x;
register PixelPacket
*restrict q;
/*
Draw bottom of ornamental border.
*/
q=QueueCacheViewAuthenticPixels(frame_view,0,(ssize_t) (frame_image->rows-
height),frame_image->columns,height,exception);
if (q != (PixelPacket *) NULL)
{
/*
Draw bottom of ornamental border.
*/
frame_indexes=GetCacheViewAuthenticIndexQueue(frame_view);
for (y=frame_info->inner_bevel-1; y >= 0; y--)
{
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPacket(frame_image,&highlight,q,frame_indexes);
q++;
frame_indexes++;
}
for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
{
SetPixelPacket(frame_image,&matte,q,frame_indexes);
q++;
frame_indexes++;
}
for (x=0; x < y; x++)
{
SetPixelPacket(frame_image,&shadow,q,frame_indexes);
q++;
frame_indexes++;
}
for ( ; x < (ssize_t) (image->columns+2*frame_info->inner_bevel); x++)
{
if (x >= (ssize_t) (image->columns+2*frame_info->inner_bevel-y))
SetPixelPacket(frame_image,&highlight,q,frame_indexes);
else
SetPixelPacket(frame_image,&accentuate,q,frame_indexes);
q++;
frame_indexes++;
}
width=frame_info->width-frame_info->x-image->columns-bevel_width;
for (x=0; x < (ssize_t) width; x++)
{
SetPixelPacket(frame_image,&matte,q,frame_indexes);
q++;
frame_indexes++;
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPacket(frame_image,&shadow,q,frame_indexes);
q++;
frame_indexes++;
}
}
height=frame_info->height-frame_info->y-image->rows-bevel_width;
for (y=0; y < (ssize_t) height; y++)
{
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPacket(frame_image,&highlight,q,frame_indexes);
q++;
frame_indexes++;
}
width=frame_image->columns-2*frame_info->outer_bevel;
for (x=0; x < (ssize_t) width; x++)
{
SetPixelPacket(frame_image,&matte,q,frame_indexes);
q++;
frame_indexes++;
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelPacket(frame_image,&shadow,q,frame_indexes);
q++;
frame_indexes++;
}
}
for (y=frame_info->outer_bevel-1; y >= 0; y--)
{
for (x=0; x < y; x++)
{
SetPixelPacket(frame_image,&highlight,q,frame_indexes);
q++;
frame_indexes++;
}
for ( ; x < (ssize_t) frame_image->columns; x++)
{
if (x >= (ssize_t) (frame_image->columns-y))
SetPixelPacket(frame_image,&shadow,q,frame_indexes);
else
SetPixelPacket(frame_image,&trough,q,frame_indexes);
q++;
frame_indexes++;
}
}
(void) SyncCacheViewAuthenticPixels(frame_view,exception);
}
}
frame_view=DestroyCacheView(frame_view);
image_view=DestroyCacheView(image_view);
if ((image->compose != CopyCompositeOp) &&
((image->compose != OverCompositeOp) || (image->matte != MagickFalse)))
{
x=(ssize_t) (frame_info->outer_bevel+(frame_info->x-bevel_width)+
frame_info->inner_bevel);
y=(ssize_t) (frame_info->outer_bevel+(frame_info->y-bevel_width)+
frame_info->inner_bevel);
(void) CompositeImage(frame_image,image->compose,image,x,y);
}
return(frame_image);
}
WandExport MagickBooleanType CompareImageCommand(ImageInfo *image_info,
int argc,char **argv,char **metadata,ExceptionInfo *exception)
{
#define DefaultDissimilarityThreshold 0.31830988618379067154
#define DestroyCompare() \
{ \
if (similarity_image != (Image *) NULL) \
similarity_image=DestroyImageList(similarity_image); \
if (difference_image != (Image *) NULL) \
difference_image=DestroyImageList(difference_image); \
DestroyImageStack(); \
for (i=0; i < (ssize_t) argc; i++) \
argv[i]=DestroyString(argv[i]); \
argv=(char **) RelinquishMagickMemory(argv); \
}
#define ThrowCompareException(asperity,tag,option) \
{ \
if (exception->severity < (asperity)) \
(void) ThrowMagickException(exception,GetMagickModule(),asperity,tag, \
"`%s'",option); \
DestroyCompare(); \
return(MagickFalse); \
}
#define ThrowCompareInvalidArgumentException(option,argument) \
{ \
(void) ThrowMagickException(exception,GetMagickModule(),OptionError, \
"InvalidArgument","`%s': %s",option,argument); \
DestroyCompare(); \
return(MagickFalse); \
}
char
*filename,
*option;
const char
*format;
ChannelType
channels;
double
dissimilarity_threshold,
distortion,
similarity_metric;
Image
*difference_image,
*image,
*reconstruct_image,
*similarity_image;
ImageStack
image_stack[MaxImageStackDepth+1];
MagickBooleanType
fire,
pend,
respect_parenthesis,
subimage_search;
MagickStatusType
status;
MetricType
metric;
RectangleInfo
offset;
register ssize_t
i;
ssize_t
j,
k;
/*
Set defaults.
*/
assert(image_info != (ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(exception != (ExceptionInfo *) NULL);
if (argc == 2)
{
option=argv[1];
if ((LocaleCompare("version",option+1) == 0) ||
(LocaleCompare("-version",option+1) == 0))
{
(void) FormatLocaleFile(stdout,"Version: %s\n",
GetMagickVersion((size_t *) NULL));
(void) FormatLocaleFile(stdout,"Copyright: %s\n",
GetMagickCopyright());
(void) FormatLocaleFile(stdout,"Features: %s\n\n",
GetMagickFeatures());
return(MagickFalse);
}
}
if (argc < 3)
return(CompareUsage());
channels=CompositeChannels;
difference_image=NewImageList();
similarity_image=NewImageList();
dissimilarity_threshold=DefaultDissimilarityThreshold;
distortion=0.0;
format=(char *) NULL;
j=1;
k=0;
metric=UndefinedMetric;
NewImageStack();
option=(char *) NULL;
pend=MagickFalse;
reconstruct_image=NewImageList();
respect_parenthesis=MagickFalse;
status=MagickTrue;
subimage_search=MagickFalse;
/*
Compare an image.
*/
ReadCommandlLine(argc,&argv);
status=ExpandFilenames(&argc,&argv);
if (status == MagickFalse)
ThrowCompareException(ResourceLimitError,"MemoryAllocationFailed",
GetExceptionMessage(errno));
for (i=1; i < (ssize_t) (argc-1); i++)
{
option=argv[i];
if (LocaleCompare(option,"(") == 0)
{
FireImageStack(MagickTrue,MagickTrue,pend);
if (k == MaxImageStackDepth)
ThrowCompareException(OptionError,"ParenthesisNestedTooDeeply",
option);
PushImageStack();
continue;
}
if (LocaleCompare(option,")") == 0)
{
FireImageStack(MagickTrue,MagickTrue,MagickTrue);
if (k == 0)
ThrowCompareException(OptionError,"UnableToParseExpression",option);
PopImageStack();
continue;
}
if (IsCommandOption(option) == MagickFalse)
{
Image
*images;
/*
Read input image.
*/
FireImageStack(MagickFalse,MagickFalse,pend);
filename=argv[i];
if ((LocaleCompare(filename,"--") == 0) && (i < (ssize_t) (argc-1)))
filename=argv[++i];
(void) CopyMagickString(image_info->filename,filename,MaxTextExtent);
images=ReadImages(image_info,exception);
status&=(images != (Image *) NULL) &&
(exception->severity < ErrorException);
if (images == (Image *) NULL)
continue;
AppendImageStack(images);
continue;
}
pend=image != (Image *) NULL ? MagickTrue : MagickFalse;
switch (*(option+1))
{
case 'a':
{
if (LocaleCompare("alpha",option+1) == 0)
{
ssize_t
type;
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
type=ParseCommandOption(MagickAlphaOptions,MagickFalse,argv[i]);
if (type < 0)
ThrowCompareException(OptionError,"UnrecognizedAlphaChannelType",
argv[i]);
break;
}
if (LocaleCompare("authenticate",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option);
}
case 'c':
{
if (LocaleCompare("cache",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
if (LocaleCompare("channel",option+1) == 0)
{
ssize_t
channel;
if (*option == '+')
break;
i++;
if (i == (ssize_t) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
channel=ParseChannelOption(argv[i]);
if (channel < 0)
ThrowCompareException(OptionError,"UnrecognizedChannelType",
argv[i]);
channels=(ChannelType) channel;
break;
}
if (LocaleCompare("colorspace",option+1) == 0)
{
ssize_t
colorspace;
if (*option == '+')
break;
i++;
if (i == (ssize_t) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
colorspace=ParseCommandOption(MagickColorspaceOptions,MagickFalse,
argv[i]);
if (colorspace < 0)
ThrowCompareException(OptionError,"UnrecognizedColorspace",
argv[i]);
break;
}
if (LocaleCompare("compose",option+1) == 0)
{
ssize_t
compose;
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
compose=ParseCommandOption(MagickComposeOptions,MagickFalse,
argv[i]);
if (compose < 0)
ThrowCompareException(OptionError,"UnrecognizedComposeOperator",
argv[i]);
break;
}
if (LocaleCompare("compress",option+1) == 0)
{
ssize_t
compress;
if (*option == '+')
break;
i++;
if (i == (ssize_t) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
compress=ParseCommandOption(MagickCompressOptions,MagickFalse,
argv[i]);
if (compress < 0)
ThrowCompareException(OptionError,"UnrecognizedImageCompression",
argv[i]);
break;
}
if (LocaleCompare("concurrent",option+1) == 0)
break;
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'd':
{
if (LocaleCompare("debug",option+1) == 0)
{
LogEventType
event_mask;
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
event_mask=SetLogEventMask(argv[i]);
if (event_mask == UndefinedEvents)
ThrowCompareException(OptionError,"UnrecognizedEventType",
argv[i]);
break;
}
if (LocaleCompare("decipher",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
if (LocaleCompare("define",option+1) == 0)
{
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
if (*option == '+')
{
const char
*define;
define=GetImageOption(image_info,argv[i]);
if (define == (const char *) NULL)
ThrowCompareException(OptionError,"NoSuchOption",argv[i]);
break;
}
break;
}
if (LocaleCompare("density",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
if (LocaleCompare("depth",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
if (LocaleCompare("dissimilarity-threshold",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
if (*option == '+')
dissimilarity_threshold=DefaultDissimilarityThreshold;
else
dissimilarity_threshold=StringToDouble(argv[i],(char **) NULL);
break;
}
if (LocaleCompare("duration",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'e':
{
if (LocaleCompare("encipher",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
if (LocaleCompare("extract",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'f':
{
if (LocaleCompare("format",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
format=argv[i];
break;
}
if (LocaleCompare("fuzz",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'h':
{
if ((LocaleCompare("help",option+1) == 0) ||
(LocaleCompare("-help",option+1) == 0))
return(CompareUsage());
if (LocaleCompare("highlight-color",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'i':
{
if (LocaleCompare("identify",option+1) == 0)
break;
if (LocaleCompare("interlace",option+1) == 0)
{
ssize_t
interlace;
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
interlace=ParseCommandOption(MagickInterlaceOptions,MagickFalse,
argv[i]);
if (interlace < 0)
ThrowCompareException(OptionError,"UnrecognizedInterlaceType",
argv[i]);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'l':
{
if (LocaleCompare("limit",option+1) == 0)
{
char
*p;
double
value;
ssize_t
resource;
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
resource=ParseCommandOption(MagickResourceOptions,MagickFalse,
argv[i]);
if (resource < 0)
ThrowCompareException(OptionError,"UnrecognizedResourceType",
argv[i]);
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
value=StringToDouble(argv[i],&p);
(void) value;
if ((p == argv[i]) && (LocaleCompare("unlimited",argv[i]) != 0))
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
if (LocaleCompare("list",option+1) == 0)
{
ssize_t
list;
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
list=ParseCommandOption(MagickListOptions,MagickFalse,argv[i]);
if (list < 0)
ThrowCompareException(OptionError,"UnrecognizedListType",argv[i]);
status=MogrifyImageInfo(image_info,(int) (i-j+1),(const char **)
argv+j,exception);
DestroyCompare();
return(status != 0 ? MagickFalse : MagickTrue);
}
if (LocaleCompare("log",option+1) == 0)
{
if (*option == '+')
break;
i++;
if ((i == (ssize_t) argc) || (strchr(argv[i],'%') == (char *) NULL))
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
if (LocaleCompare("lowlight-color",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'm':
{
if (LocaleCompare("matte",option+1) == 0)
break;
if (LocaleCompare("metric",option+1) == 0)
{
ssize_t
type;
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
type=ParseCommandOption(MagickMetricOptions,MagickTrue,argv[i]);
if (type < 0)
ThrowCompareException(OptionError,"UnrecognizedMetricType",
argv[i]);
metric=(MetricType) type;
break;
}
if (LocaleCompare("monitor",option+1) == 0)
break;
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'p':
{
if (LocaleCompare("passphrase",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
if (LocaleCompare("profile",option+1) == 0)
{
i++;
if (i == (ssize_t) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'q':
{
if (LocaleCompare("quality",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
if (LocaleCompare("quantize",option+1) == 0)
{
ssize_t
colorspace;
if (*option == '+')
break;
i++;
if (i == (ssize_t) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
colorspace=ParseCommandOption(MagickColorspaceOptions,
MagickFalse,argv[i]);
if (colorspace < 0)
ThrowCompareException(OptionError,"UnrecognizedColorspace",
argv[i]);
break;
}
if (LocaleCompare("quiet",option+1) == 0)
break;
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'r':
{
if (LocaleCompare("regard-warnings",option+1) == 0)
break;
if (LocaleNCompare("respect-parentheses",option+1,17) == 0)
{
respect_parenthesis=(*option == '-') ? MagickTrue : MagickFalse;
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 's':
{
if (LocaleCompare("sampling-factor",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
if (LocaleCompare("seed",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
if (LocaleCompare("set",option+1) == 0)
{
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
if (LocaleCompare("size",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
if (IsGeometry(argv[i]) == MagickFalse)
ThrowCompareInvalidArgumentException(option,argv[i]);
break;
}
if (LocaleCompare("subimage-search",option+1) == 0)
{
if (*option == '+')
{
subimage_search=MagickFalse;
break;
}
subimage_search=MagickTrue;
break;
}
if (LocaleCompare("synchronize",option+1) == 0)
break;
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 't':
{
if (LocaleCompare("taint",option+1) == 0)
break;
if (LocaleCompare("transparent-color",option+1) == 0)
{
if (*option == '+')
break;
i++;
if (i == (ssize_t) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
break;
}
if (LocaleCompare("type",option+1) == 0)
{
ssize_t
type;
if (*option == '+')
break;
i++;
if (i == (ssize_t) argc)
ThrowCompareException(OptionError,"MissingArgument",option);
type=ParseCommandOption(MagickTypeOptions,MagickFalse,argv[i]);
if (type < 0)
ThrowCompareException(OptionError,"UnrecognizedImageType",
argv[i]);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case 'v':
{
if (LocaleCompare("verbose",option+1) == 0)
break;
if ((LocaleCompare("version",option+1) == 0) ||
(LocaleCompare("-version",option+1) == 0))
{
(void) FormatLocaleFile(stdout,"Version: %s\n",
GetMagickVersion((size_t *) NULL));
(void) FormatLocaleFile(stdout,"Copyright: %s\n",
GetMagickCopyright());
(void) FormatLocaleFile(stdout,"Features: %s\n\n",
GetMagickFeatures());
break;
}
if (LocaleCompare("virtual-pixel",option+1) == 0)
{
ssize_t
method;
if (*option == '+')
break;
i++;
if (i == (ssize_t) (argc-1))
ThrowCompareException(OptionError,"MissingArgument",option);
method=ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,
argv[i]);
if (method < 0)
ThrowCompareException(OptionError,
"UnrecognizedVirtualPixelMethod",argv[i]);
break;
}
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
case '?':
break;
default:
ThrowCompareException(OptionError,"UnrecognizedOption",option)
}
fire=(GetCommandOptionFlags(MagickCommandOptions,MagickFalse,option) &
FireOptionFlag) == 0 ? MagickFalse : MagickTrue;
if (fire != MagickFalse)
FireImageStack(MagickTrue,MagickTrue,MagickTrue);
}
if (k != 0)
ThrowCompareException(OptionError,"UnbalancedParenthesis",argv[i]);
if (i-- != (ssize_t) (argc-1))
ThrowCompareException(OptionError,"MissingAnImageFilename",argv[i]);
if ((image == (Image *) NULL) || (GetImageListLength(image) < 2))
ThrowCompareException(OptionError,"MissingAnImageFilename",argv[i]);
FinalizeImageSettings(image_info,image,MagickTrue);
if ((image == (Image *) NULL) || (GetImageListLength(image) < 2))
ThrowCompareException(OptionError,"MissingAnImageFilename",argv[i]);
image=GetImageFromList(image,0);
reconstruct_image=GetImageFromList(image,1);
if (subimage_search != MagickFalse)
{
similarity_image=SimilarityMetricImage(image,reconstruct_image,metric,
&offset,&similarity_metric,exception);
if (similarity_metric > dissimilarity_threshold)
ThrowCompareException(ImageError,"ImagesTooDissimilar",image->filename);
}
if ((reconstruct_image->columns == image->columns) &&
(reconstruct_image->rows == image->rows))
difference_image=CompareImageChannels(image,reconstruct_image,channels,
metric,&distortion,exception);
else
if (similarity_image == (Image *) NULL)
ThrowCompareException(OptionError,"ImageWidthsOrHeightsDiffer",
image->filename)
else
{
Image
*composite_image;
/*
Determine if reconstructed image is a subimage of the image.
*/
composite_image=CloneImage(image,0,0,MagickTrue,exception);
if (composite_image == (Image *) NULL)
difference_image=CompareImageChannels(image,reconstruct_image,
channels,metric,&distortion,exception);
else
{
(void) CompositeImage(composite_image,CopyCompositeOp,
reconstruct_image,offset.x,offset.y);
difference_image=CompareImageChannels(image,composite_image,
channels,metric,&distortion,exception);
if (difference_image != (Image *) NULL)
{
difference_image->page.x=offset.x;
difference_image->page.y=offset.y;
}
composite_image=DestroyImage(composite_image);
}
if (difference_image != (Image *) NULL)
{
AppendImageToList(&difference_image,similarity_image);
similarity_image=(Image *) NULL;
}
}
if (difference_image == (Image *) NULL)
status=0;
else
{
if (image_info->verbose != MagickFalse)
(void) IsImagesEqual(image,reconstruct_image);
if (*difference_image->magick == '\0')
(void) CopyMagickString(difference_image->magick,image->magick,
MaxTextExtent);
if (image_info->verbose == MagickFalse)
{
switch (metric)
{
case FuzzErrorMetric:
case MeanAbsoluteErrorMetric:
case MeanSquaredErrorMetric:
case RootMeanSquaredErrorMetric:
case PeakAbsoluteErrorMetric:
{
(void) FormatLocaleFile(stderr,"%g (%g)",QuantumRange*distortion,
(double) distortion);
if ((reconstruct_image->columns != image->columns) ||
(reconstruct_image->rows != image->rows))
(void) FormatLocaleFile(stderr," @ %.20g,%.20g",(double)
difference_image->page.x,(double) difference_image->page.y);
(void) FormatLocaleFile(stderr,"\n");
break;
}
case AbsoluteErrorMetric:
case NormalizedCrossCorrelationErrorMetric:
case PeakSignalToNoiseRatioMetric:
{
(void) FormatLocaleFile(stderr,"%g",distortion);
if ((reconstruct_image->columns != image->columns) ||
(reconstruct_image->rows != image->rows))
(void) FormatLocaleFile(stderr," @ %.20g,%.20g",(double)
difference_image->page.x,(double) difference_image->page.y);
(void) FormatLocaleFile(stderr,"\n");
break;
}
case MeanErrorPerPixelMetric:
{
(void) FormatLocaleFile(stderr,"%g (%g, %g)",distortion,
image->error.normalized_mean_error,
image->error.normalized_maximum_error);
if ((reconstruct_image->columns != image->columns) ||
(reconstruct_image->rows != image->rows))
(void) FormatLocaleFile(stderr," @ %.20g,%.20g",(double)
difference_image->page.x,(double) difference_image->page.y);
(void) FormatLocaleFile(stderr,"\n");
break;
}
case UndefinedMetric:
break;
}
}
else
{
double
*channel_distortion;
channel_distortion=GetImageChannelDistortions(image,reconstruct_image,
metric,&image->exception);
(void) FormatLocaleFile(stderr,"Image: %s\n",image->filename);
if ((reconstruct_image->columns != image->columns) ||
(reconstruct_image->rows != image->rows))
(void) FormatLocaleFile(stderr,"Offset: %.20g,%.20g\n",(double)
difference_image->page.x,(double) difference_image->page.y);
(void) FormatLocaleFile(stderr," Channel distortion: %s\n",
CommandOptionToMnemonic(MagickMetricOptions,(ssize_t) metric));
switch (metric)
{
case FuzzErrorMetric:
case MeanAbsoluteErrorMetric:
case MeanSquaredErrorMetric:
case RootMeanSquaredErrorMetric:
case PeakAbsoluteErrorMetric:
{
switch (image->colorspace)
{
case RGBColorspace:
default:
{
(void) FormatLocaleFile(stderr," red: %g (%g)\n",
QuantumRange*channel_distortion[RedChannel],
channel_distortion[RedChannel]);
(void) FormatLocaleFile(stderr," green: %g (%g)\n",
QuantumRange*channel_distortion[GreenChannel],
channel_distortion[GreenChannel]);
(void) FormatLocaleFile(stderr," blue: %g (%g)\n",
QuantumRange*channel_distortion[BlueChannel],
channel_distortion[BlueChannel]);
if (image->matte != MagickFalse)
(void) FormatLocaleFile(stderr," alpha: %g (%g)\n",
QuantumRange*channel_distortion[OpacityChannel],
channel_distortion[OpacityChannel]);
break;
}
case CMYKColorspace:
{
(void) FormatLocaleFile(stderr," cyan: %g (%g)\n",
QuantumRange*channel_distortion[CyanChannel],
channel_distortion[CyanChannel]);
(void) FormatLocaleFile(stderr," magenta: %g (%g)\n",
QuantumRange*channel_distortion[MagentaChannel],
channel_distortion[MagentaChannel]);
(void) FormatLocaleFile(stderr," yellow: %g (%g)\n",
QuantumRange*channel_distortion[YellowChannel],
channel_distortion[YellowChannel]);
(void) FormatLocaleFile(stderr," black: %g (%g)\n",
QuantumRange*channel_distortion[BlackChannel],
channel_distortion[BlackChannel]);
if (image->matte != MagickFalse)
(void) FormatLocaleFile(stderr," alpha: %g (%g)\n",
QuantumRange*channel_distortion[OpacityChannel],
channel_distortion[OpacityChannel]);
break;
}
case GRAYColorspace:
{
(void) FormatLocaleFile(stderr," gray: %g (%g)\n",
QuantumRange*channel_distortion[GrayChannel],
channel_distortion[GrayChannel]);
if (image->matte != MagickFalse)
(void) FormatLocaleFile(stderr," alpha: %g (%g)\n",
QuantumRange*channel_distortion[OpacityChannel],
channel_distortion[OpacityChannel]);
break;
}
}
(void) FormatLocaleFile(stderr," all: %g (%g)\n",
QuantumRange*channel_distortion[CompositeChannels],
channel_distortion[CompositeChannels]);
break;
}
case AbsoluteErrorMetric:
case NormalizedCrossCorrelationErrorMetric:
case PeakSignalToNoiseRatioMetric:
{
switch (image->colorspace)
{
case RGBColorspace:
default:
{
(void) FormatLocaleFile(stderr," red: %g\n",
channel_distortion[RedChannel]);
(void) FormatLocaleFile(stderr," green: %g\n",
channel_distortion[GreenChannel]);
(void) FormatLocaleFile(stderr," blue: %g\n",
channel_distortion[BlueChannel]);
if (image->matte != MagickFalse)
(void) FormatLocaleFile(stderr," alpha: %g\n",
channel_distortion[OpacityChannel]);
break;
}
case CMYKColorspace:
{
(void) FormatLocaleFile(stderr," cyan: %g\n",
channel_distortion[CyanChannel]);
(void) FormatLocaleFile(stderr," magenta: %g\n",
channel_distortion[MagentaChannel]);
(void) FormatLocaleFile(stderr," yellow: %g\n",
channel_distortion[YellowChannel]);
(void) FormatLocaleFile(stderr," black: %g\n",
channel_distortion[BlackChannel]);
if (image->matte != MagickFalse)
(void) FormatLocaleFile(stderr," alpha: %g\n",
channel_distortion[OpacityChannel]);
break;
}
case GRAYColorspace:
{
(void) FormatLocaleFile(stderr," gray: %g\n",
channel_distortion[GrayChannel]);
if (image->matte != MagickFalse)
(void) FormatLocaleFile(stderr," alpha: %g\n",
channel_distortion[OpacityChannel]);
break;
}
}
(void) FormatLocaleFile(stderr," all: %g\n",
channel_distortion[CompositeChannels]);
break;
}
case MeanErrorPerPixelMetric:
{
(void) FormatLocaleFile(stderr," %g (%g, %g)\n",
channel_distortion[CompositeChannels],
image->error.normalized_mean_error,
image->error.normalized_maximum_error);
break;
}
case UndefinedMetric:
break;
}
channel_distortion=(double *) RelinquishMagickMemory(
channel_distortion);
}
status&=WriteImages(image_info,difference_image,argv[argc-1],exception);
if ((metadata != (char **) NULL) && (format != (char *) NULL))
{
char
*text;
text=InterpretImageProperties(image_info,difference_image,format);
if (text == (char *) NULL)
ThrowCompareException(ResourceLimitError,"MemoryAllocationFailed",
GetExceptionMessage(errno));
(void) ConcatenateString(&(*metadata),text);
(void) ConcatenateString(&(*metadata),"\n");
text=DestroyString(text);
}
difference_image=DestroyImageList(difference_image);
}
DestroyCompare();
return(status != 0 ? MagickTrue : MagickFalse);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% F r a m e I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% FrameImage() adds a simulated three-dimensional border around the image.
% The color of the border is defined by the matte_color member of image.
% Members width and height of frame_info specify the border width of the
% vertical and horizontal sides of the frame. Members inner and outer
% indicate the width of the inner and outer shadows of the frame.
%
% The format of the FrameImage method is:
%
% Image *FrameImage(const Image *image,const FrameInfo *frame_info,
% const CompositeOperator compose,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o frame_info: Define the width and height of the frame and its bevels.
%
% o compose: the composite operator.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
const CompositeOperator compose,ExceptionInfo *exception)
{
#define FrameImageTag "Frame/Image"
CacheView
*image_view,
*frame_view;
Image
*frame_image;
MagickBooleanType
status;
MagickOffsetType
progress;
PixelInfo
accentuate,
highlight,
interior,
matte,
shadow,
trough;
register ssize_t
x;
size_t
bevel_width,
height,
width;
ssize_t
y;
/*
Check frame geometry.
*/
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(frame_info != (FrameInfo *) NULL);
if ((frame_info->outer_bevel < 0) || (frame_info->inner_bevel < 0))
ThrowImageException(OptionError,"FrameIsLessThanImageSize");
bevel_width=(size_t) (frame_info->outer_bevel+frame_info->inner_bevel);
width=frame_info->width-frame_info->x-bevel_width;
height=frame_info->height-frame_info->y-bevel_width;
if ((width < image->columns) || (height < image->rows))
ThrowImageException(OptionError,"FrameIsLessThanImageSize");
/*
Initialize framed image attributes.
*/
frame_image=CloneImage(image,frame_info->width,frame_info->height,MagickTrue,
exception);
if (frame_image == (Image *) NULL)
return((Image *) NULL);
if (SetImageStorageClass(frame_image,DirectClass,exception) == MagickFalse)
{
frame_image=DestroyImage(frame_image);
return((Image *) NULL);
}
if ((IsGrayColorspace(image->colorspace) != MagickFalse) &&
(IsPixelInfoGray(&image->matte_color) == MagickFalse))
SetImageColorspace(frame_image,sRGBColorspace,exception);
if ((frame_image->border_color.matte != MagickFalse) &&
(frame_image->matte == MagickFalse))
(void) SetImageAlpha(frame_image,OpaqueAlpha,exception);
frame_image->page=image->page;
if ((image->page.width != 0) && (image->page.height != 0))
{
frame_image->page.width+=frame_image->columns-image->columns;
frame_image->page.height+=frame_image->rows-image->rows;
}
/*
Initialize 3D effects color.
*/
interior=image->border_color;
matte=image->matte_color;
accentuate=matte;
accentuate.red=(MagickRealType) (QuantumScale*((QuantumRange-
AccentuateModulate)*matte.red+(QuantumRange*AccentuateModulate)));
accentuate.green=(MagickRealType) (QuantumScale*((QuantumRange-
AccentuateModulate)*matte.green+(QuantumRange*AccentuateModulate)));
accentuate.blue=(MagickRealType) (QuantumScale*((QuantumRange-
AccentuateModulate)*matte.blue+(QuantumRange*AccentuateModulate)));
accentuate.black=(MagickRealType) (QuantumScale*((QuantumRange-
AccentuateModulate)*matte.black+(QuantumRange*AccentuateModulate)));
accentuate.alpha=matte.alpha;
highlight=matte;
highlight.red=(MagickRealType) (QuantumScale*((QuantumRange-
HighlightModulate)*matte.red+(QuantumRange*HighlightModulate)));
highlight.green=(MagickRealType) (QuantumScale*((QuantumRange-
HighlightModulate)*matte.green+(QuantumRange*HighlightModulate)));
highlight.blue=(MagickRealType) (QuantumScale*((QuantumRange-
HighlightModulate)*matte.blue+(QuantumRange*HighlightModulate)));
highlight.black=(MagickRealType) (QuantumScale*((QuantumRange-
HighlightModulate)*matte.black+(QuantumRange*HighlightModulate)));
highlight.alpha=matte.alpha;
shadow=matte;
shadow.red=QuantumScale*matte.red*ShadowModulate;
shadow.green=QuantumScale*matte.green*ShadowModulate;
shadow.blue=QuantumScale*matte.blue*ShadowModulate;
shadow.black=QuantumScale*matte.black*ShadowModulate;
shadow.alpha=matte.alpha;
trough=matte;
trough.red=QuantumScale*matte.red*TroughModulate;
trough.green=QuantumScale*matte.green*TroughModulate;
trough.blue=QuantumScale*matte.blue*TroughModulate;
trough.black=QuantumScale*matte.black*TroughModulate;
trough.alpha=matte.alpha;
status=MagickTrue;
progress=0;
image_view=AcquireCacheView(image);
frame_view=AcquireCacheView(frame_image);
height=(size_t) (frame_info->outer_bevel+(frame_info->y-bevel_width)+
frame_info->inner_bevel);
if (height != 0)
{
register ssize_t
x;
register Quantum
*restrict q;
/*
Draw top of ornamental border.
*/
q=QueueCacheViewAuthenticPixels(frame_view,0,0,frame_image->columns,
height,exception);
if (q != (Quantum *) NULL)
{
/*
Draw top of ornamental border.
*/
for (y=0; y < (ssize_t) frame_info->outer_bevel; y++)
{
for (x=0; x < (ssize_t) (frame_image->columns-y); x++)
{
if (x < y)
SetPixelInfoPixel(frame_image,&highlight,q);
else
SetPixelInfoPixel(frame_image,&accentuate,q);
q+=GetPixelChannels(frame_image);
}
for ( ; x < (ssize_t) frame_image->columns; x++)
{
SetPixelInfoPixel(frame_image,&shadow,q);
q+=GetPixelChannels(frame_image);
}
}
for (y=0; y < (ssize_t) (frame_info->y-bevel_width); y++)
{
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelInfoPixel(frame_image,&highlight,q);
q+=GetPixelChannels(frame_image);
}
width=frame_image->columns-2*frame_info->outer_bevel;
for (x=0; x < (ssize_t) width; x++)
{
SetPixelInfoPixel(frame_image,&matte,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelInfoPixel(frame_image,&shadow,q);
q+=GetPixelChannels(frame_image);
}
}
for (y=0; y < (ssize_t) frame_info->inner_bevel; y++)
{
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelInfoPixel(frame_image,&highlight,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
{
SetPixelInfoPixel(frame_image,&matte,q);
q+=GetPixelChannels(frame_image);
}
width=image->columns+((size_t) frame_info->inner_bevel << 1)-
y;
for (x=0; x < (ssize_t) width; x++)
{
if (x < y)
SetPixelInfoPixel(frame_image,&shadow,q);
else
SetPixelInfoPixel(frame_image,&trough,q);
q+=GetPixelChannels(frame_image);
}
for ( ; x < (ssize_t) (image->columns+2*frame_info->inner_bevel); x++)
{
SetPixelInfoPixel(frame_image,&highlight,q);
q+=GetPixelChannels(frame_image);
}
width=frame_info->width-frame_info->x-image->columns-bevel_width;
for (x=0; x < (ssize_t) width; x++)
{
SetPixelInfoPixel(frame_image,&matte,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelInfoPixel(frame_image,&shadow,q);
q+=GetPixelChannels(frame_image);
}
}
(void) SyncCacheViewAuthenticPixels(frame_view,exception);
}
}
/*
Draw sides of ornamental border.
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register ssize_t
x;
register Quantum
*restrict q;
size_t
width;
/*
Initialize scanline with matte color.
*/
if (status == MagickFalse)
continue;
q=QueueCacheViewAuthenticPixels(frame_view,0,frame_info->y+y,
frame_image->columns,1,exception);
if (q == (Quantum *) NULL)
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelInfoPixel(frame_image,&highlight,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
{
SetPixelInfoPixel(frame_image,&matte,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)
{
SetPixelInfoPixel(frame_image,&shadow,q);
q+=GetPixelChannels(frame_image);
}
/*
Set frame interior to interior color.
*/
if ((compose != CopyCompositeOp) && ((compose != OverCompositeOp) ||
(image->matte != MagickFalse)))
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelInfoPixel(frame_image,&interior,q);
q+=GetPixelChannels(frame_image);
}
else
{
register const Quantum
*p;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
SetPixelRed(frame_image,GetPixelRed(image,p),q);
if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
SetPixelGreen(frame_image,GetPixelGreen(image,p),q);
if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
SetPixelBlue(frame_image,GetPixelBlue(image,p),q);
if ((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0)
SetPixelBlack(frame_image,GetPixelBlack(image,p),q);
if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)
SetPixelAlpha(frame_image,GetPixelAlpha(image,p),q);
p+=GetPixelChannels(image);
q+=GetPixelChannels(frame_image);
}
}
for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)
{
SetPixelInfoPixel(frame_image,&highlight,q);
q+=GetPixelChannels(frame_image);
}
width=frame_info->width-frame_info->x-image->columns-bevel_width;
for (x=0; x < (ssize_t) width; x++)
{
SetPixelInfoPixel(frame_image,&matte,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelInfoPixel(frame_image,&shadow,q);
q+=GetPixelChannels(frame_image);
}
if (SyncCacheViewAuthenticPixels(frame_view,exception) == MagickFalse)
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp critical (MagickCore_FrameImage)
#endif
proceed=SetImageProgress(image,FrameImageTag,progress++,image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
height=(size_t) (frame_info->inner_bevel+frame_info->height-
frame_info->y-image->rows-bevel_width+frame_info->outer_bevel);
if (height != 0)
{
register ssize_t
x;
register Quantum
*restrict q;
/*
Draw bottom of ornamental border.
*/
q=QueueCacheViewAuthenticPixels(frame_view,0,(ssize_t) (frame_image->rows-
height),frame_image->columns,height,exception);
if (q != (Quantum *) NULL)
{
/*
Draw bottom of ornamental border.
*/
for (y=frame_info->inner_bevel-1; y >= 0; y--)
{
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelInfoPixel(frame_image,&highlight,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
{
SetPixelInfoPixel(frame_image,&matte,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < y; x++)
{
SetPixelInfoPixel(frame_image,&shadow,q);
q+=GetPixelChannels(frame_image);
}
for ( ; x < (ssize_t) (image->columns+2*frame_info->inner_bevel); x++)
{
if (x >= (ssize_t) (image->columns+2*frame_info->inner_bevel-y))
SetPixelInfoPixel(frame_image,&highlight,q);
else
SetPixelInfoPixel(frame_image,&accentuate,q);
q+=GetPixelChannels(frame_image);
}
width=frame_info->width-frame_info->x-image->columns-bevel_width;
for (x=0; x < (ssize_t) width; x++)
{
SetPixelInfoPixel(frame_image,&matte,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelInfoPixel(frame_image,&shadow,q);
q+=GetPixelChannels(frame_image);
}
}
height=frame_info->height-frame_info->y-image->rows-bevel_width;
for (y=0; y < (ssize_t) height; y++)
{
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelInfoPixel(frame_image,&highlight,q);
q+=GetPixelChannels(frame_image);
}
width=frame_image->columns-2*frame_info->outer_bevel;
for (x=0; x < (ssize_t) width; x++)
{
SetPixelInfoPixel(frame_image,&matte,q);
q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
SetPixelInfoPixel(frame_image,&shadow,q);
q+=GetPixelChannels(frame_image);
}
}
for (y=frame_info->outer_bevel-1; y >= 0; y--)
{
for (x=0; x < y; x++)
{
SetPixelInfoPixel(frame_image,&highlight,q);
q+=GetPixelChannels(frame_image);
}
for ( ; x < (ssize_t) frame_image->columns; x++)
{
if (x >= (ssize_t) (frame_image->columns-y))
SetPixelInfoPixel(frame_image,&shadow,q);
else
SetPixelInfoPixel(frame_image,&trough,q);
q+=GetPixelChannels(frame_image);
}
}
(void) SyncCacheViewAuthenticPixels(frame_view,exception);
}
}
frame_view=DestroyCacheView(frame_view);
image_view=DestroyCacheView(image_view);
if ((compose != CopyCompositeOp) && ((compose != OverCompositeOp) ||
(image->matte != MagickFalse)))
{
x=(ssize_t) (frame_info->outer_bevel+(frame_info->x-bevel_width)+
frame_info->inner_bevel);
y=(ssize_t) (frame_info->outer_bevel+(frame_info->y-bevel_width)+
frame_info->inner_bevel);
(void) CompositeImage(frame_image,image,compose,MagickTrue,x,y,
exception);
}
return(frame_image);
}
MagickExport MagickBooleanType SetImageAlphaChannel(Image *image,
const AlphaChannelOption alpha_type,ExceptionInfo *exception)
{
CacheView
*image_view;
MagickBooleanType
status;
ssize_t
y;
assert(image != (Image *) NULL);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(image->signature == MagickSignature);
status=MagickTrue;
switch (alpha_type)
{
case ActivateAlphaChannel:
{
image->alpha_trait=BlendPixelTrait;
break;
}
case AssociateAlphaChannel:
{
/*
Associate alpha.
*/
status=SetImageStorageClass(image,DirectClass,exception);
if (status == MagickFalse)
break;
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
magick_threads(image,image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
*restrict q;
register ssize_t
x;
if (status == MagickFalse)
continue;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
exception);
if (q == (Quantum *) NULL)
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
double
Sa;
register ssize_t
i;
if (GetPixelReadMask(image,q) == 0)
{
q+=GetPixelChannels(image);
continue;
}
Sa=QuantumScale*GetPixelAlpha(image,q);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
PixelChannel channel=GetPixelChannelChannel(image,i);
PixelTrait traits=GetPixelChannelTraits(image,channel);
if ((traits & UpdatePixelTrait) == 0)
continue;
q[i]=ClampToQuantum(Sa*q[i]);
}
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
}
image_view=DestroyCacheView(image_view);
image->alpha_trait=CopyPixelTrait;
return(status);
}
case BackgroundAlphaChannel:
{
/*
Set transparent pixels to background color.
*/
if (image->alpha_trait != BlendPixelTrait)
break;
status=SetImageStorageClass(image,DirectClass,exception);
if (status == MagickFalse)
break;
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
magick_threads(image,image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
*restrict q;
register ssize_t
x;
if (status == MagickFalse)
continue;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
exception);
if (q == (Quantum *) NULL)
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
if (GetPixelAlpha(image,q) == TransparentAlpha)
{
SetPixelInfoPixel(image,&image->background_color,q);
SetPixelChannel(image,AlphaPixelChannel,TransparentAlpha,q);
}
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
}
image_view=DestroyCacheView(image_view);
return(status);
}
case CopyAlphaChannel:
case ShapeAlphaChannel:
{
/*
Copy pixel intensity to the alpha channel.
*/
status=CompositeImage(image,image,IntensityCompositeOp,MagickTrue,0,0,
exception);
if (alpha_type == ShapeAlphaChannel)
(void) LevelImageColors(image,&image->background_color,
&image->background_color,MagickTrue,exception);
break;
}
case DeactivateAlphaChannel:
{
image->alpha_trait=CopyPixelTrait;
break;
}
case DisassociateAlphaChannel:
{
/*
Disassociate alpha.
*/
status=SetImageStorageClass(image,DirectClass,exception);
if (status == MagickFalse)
break;
image->alpha_trait=BlendPixelTrait;
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
magick_threads(image,image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
*restrict q;
register ssize_t
x;
if (status == MagickFalse)
continue;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
exception);
if (q == (Quantum *) NULL)
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
double
gamma,
Sa;
register ssize_t
i;
if (GetPixelReadMask(image,q) == 0)
{
q+=GetPixelChannels(image);
continue;
}
Sa=QuantumScale*GetPixelAlpha(image,q);
gamma=PerceptibleReciprocal(Sa);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
PixelChannel channel=GetPixelChannelChannel(image,i);
PixelTrait traits=GetPixelChannelTraits(image,channel);
if ((traits & UpdatePixelTrait) == 0)
continue;
q[i]=ClampToQuantum(gamma*q[i]);
}
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
}
image_view=DestroyCacheView(image_view);
return(status);
}
case DiscreteAlphaChannel:
{
image->alpha_trait=UpdatePixelTrait;
break;
}
case ExtractAlphaChannel:
{
status=CompositeImage(image,image,AlphaCompositeOp,MagickTrue,0,0,
exception);
image->alpha_trait=CopyPixelTrait;
break;
}
case OpaqueAlphaChannel:
{
status=SetImageAlpha(image,OpaqueAlpha,exception);
break;
}
case RemoveAlphaChannel:
{
/*
Remove transparency.
*/
if (image->alpha_trait != BlendPixelTrait)
break;
status=SetImageStorageClass(image,DirectClass,exception);
if (status == MagickFalse)
break;
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
magick_threads(image,image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
*restrict q;
register ssize_t
x;
if (status == MagickFalse)
continue;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
exception);
if (q == (Quantum *) NULL)
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
FlattenPixelInfo(image,&image->background_color,
image->background_color.alpha,q,(double)
GetPixelAlpha(image,q),q);
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
}
image_view=DestroyCacheView(image_view);
image->alpha_trait=image->background_color.alpha_trait;
return(status);
}
case SetAlphaChannel:
{
if (image->alpha_trait != BlendPixelTrait)
status=SetImageAlpha(image,OpaqueAlpha,exception);
break;
}
case TransparentAlphaChannel:
{
status=SetImageAlpha(image,TransparentAlpha,exception);
break;
}
case UndefinedAlphaChannel:
break;
}
if (status == MagickFalse)
return(status);
return(SyncImagePixelCache(image,exception));
}
MagickExport Image *MontageImageList(const ImageInfo *image_info,
const MontageInfo *montage_info,const Image *images,ExceptionInfo *exception)
{
#define MontageImageTag "Montage/Image"
#define TileImageTag "Tile/Image"
char
tile_geometry[MagickPathExtent],
*title;
const char
*value;
DrawInfo
*draw_info;
FrameInfo
frame_info;
Image
*image,
**image_list,
**master_list,
*montage,
*texture,
*tile_image,
*thumbnail;
ImageInfo
*clone_info;
MagickBooleanType
concatenate,
proceed,
status;
MagickOffsetType
tiles;
MagickProgressMonitor
progress_monitor;
MagickStatusType
flags;
register ssize_t
i;
RectangleInfo
bounds,
geometry,
extract_info;
size_t
border_width,
extent,
height,
images_per_page,
max_height,
number_images,
number_lines,
sans,
tiles_per_column,
tiles_per_page,
tiles_per_row,
title_offset,
total_tiles,
width;
ssize_t
bevel_width,
tile,
x,
x_offset,
y,
y_offset;
TypeMetric
metrics;
/*
Create image tiles.
*/
assert(images != (Image *) NULL);
assert(images->signature == MagickCoreSignature);
if (images->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
assert(montage_info != (MontageInfo *) NULL);
assert(montage_info->signature == MagickCoreSignature);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
number_images=GetImageListLength(images);
master_list=ImageListToArray(images,exception);
image_list=master_list;
image=image_list[0];
if (master_list == (Image **) NULL)
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
thumbnail=NewImageList();
for (i=0; i < (ssize_t) number_images; i++)
{
image=CloneImage(image_list[i],0,0,MagickTrue,exception);
if (image == (Image *) NULL)
break;
(void) ParseAbsoluteGeometry("0x0+0+0",&image->page);
progress_monitor=SetImageProgressMonitor(image,(MagickProgressMonitor) NULL,
image->client_data);
flags=ParseRegionGeometry(image,montage_info->geometry,&geometry,exception);
thumbnail=ThumbnailImage(image,geometry.width,geometry.height,exception);
if (thumbnail == (Image *) NULL)
break;
image_list[i]=thumbnail;
(void) SetImageProgressMonitor(image,progress_monitor,image->client_data);
proceed=SetImageProgress(image,TileImageTag,(MagickOffsetType) i,
number_images);
if (proceed == MagickFalse)
break;
image=DestroyImage(image);
}
if (i < (ssize_t) number_images)
{
if (thumbnail == (Image *) NULL)
i--;
for (tile=0; (ssize_t) tile <= i; tile++)
if (image_list[tile] != (Image *) NULL)
image_list[tile]=DestroyImage(image_list[tile]);
master_list=(Image **) RelinquishMagickMemory(master_list);
return((Image *) NULL);
}
/*
Sort image list by increasing tile number.
*/
for (i=0; i < (ssize_t) number_images; i++)
if (image_list[i]->scene == 0)
break;
if (i == (ssize_t) number_images)
qsort((void *) image_list,(size_t) number_images,sizeof(*image_list),
SceneCompare);
/*
Determine tiles per row and column.
*/
tiles_per_column=(size_t) sqrt((double) number_images);
tiles_per_row=(size_t) ceil((double) number_images/tiles_per_column);
x_offset=0;
y_offset=0;
if (montage_info->tile != (char *) NULL)
GetMontageGeometry(montage_info->tile,number_images,&x_offset,&y_offset,
&tiles_per_column,&tiles_per_row);
/*
Determine tile sizes.
*/
concatenate=MagickFalse;
SetGeometry(image_list[0],&extract_info);
extract_info.x=(ssize_t) montage_info->border_width;
extract_info.y=(ssize_t) montage_info->border_width;
if (montage_info->geometry != (char *) NULL)
{
/*
Initialize tile geometry.
*/
flags=GetGeometry(montage_info->geometry,&extract_info.x,&extract_info.y,
&extract_info.width,&extract_info.height);
concatenate=((flags & RhoValue) == 0) && ((flags & SigmaValue) == 0) ?
MagickTrue : MagickFalse;
}
border_width=montage_info->border_width;
bevel_width=0;
(void) ResetMagickMemory(&frame_info,0,sizeof(frame_info));
if (montage_info->frame != (char *) NULL)
{
char
absolute_geometry[MagickPathExtent];
frame_info.width=extract_info.width;
frame_info.height=extract_info.height;
(void) FormatLocaleString(absolute_geometry,MagickPathExtent,"%s!",
montage_info->frame);
flags=ParseMetaGeometry(absolute_geometry,&frame_info.outer_bevel,
&frame_info.inner_bevel,&frame_info.width,&frame_info.height);
if ((flags & HeightValue) == 0)
frame_info.height=frame_info.width;
if ((flags & XiValue) == 0)
frame_info.outer_bevel=(ssize_t) frame_info.width/2-1;
if ((flags & PsiValue) == 0)
frame_info.inner_bevel=frame_info.outer_bevel;
frame_info.x=(ssize_t) frame_info.width;
frame_info.y=(ssize_t) frame_info.height;
bevel_width=(ssize_t) MagickMax(frame_info.inner_bevel,
frame_info.outer_bevel);
border_width=(size_t) MagickMax((ssize_t) frame_info.width,
(ssize_t) frame_info.height);
}
for (i=0; i < (ssize_t) number_images; i++)
{
if (image_list[i]->columns > extract_info.width)
extract_info.width=image_list[i]->columns;
if (image_list[i]->rows > extract_info.height)
extract_info.height=image_list[i]->rows;
}
/*
Initialize draw attributes.
*/
clone_info=CloneImageInfo(image_info);
clone_info->background_color=montage_info->background_color;
clone_info->border_color=montage_info->border_color;
draw_info=CloneDrawInfo(clone_info,(DrawInfo *) NULL);
if (montage_info->font != (char *) NULL)
(void) CloneString(&draw_info->font,montage_info->font);
if (montage_info->pointsize != 0.0)
draw_info->pointsize=montage_info->pointsize;
draw_info->gravity=CenterGravity;
draw_info->stroke=montage_info->stroke;
draw_info->fill=montage_info->fill;
draw_info->text=AcquireString("");
(void) GetTypeMetrics(image_list[0],draw_info,&metrics,exception);
texture=NewImageList();
if (montage_info->texture != (char *) NULL)
{
(void) CopyMagickString(clone_info->filename,montage_info->texture,
MagickPathExtent);
texture=ReadImage(clone_info,exception);
}
/*
Determine the number of lines in an next label.
*/
title=InterpretImageProperties(clone_info,image_list[0],montage_info->title,
exception);
title_offset=0;
if (montage_info->title != (char *) NULL)
title_offset=(size_t) (2*(metrics.ascent-metrics.descent)*
MultilineCensus(title)+2*extract_info.y);
number_lines=0;
for (i=0; i < (ssize_t) number_images; i++)
{
value=GetImageProperty(image_list[i],"label",exception);
if (value == (const char *) NULL)
continue;
if (MultilineCensus(value) > number_lines)
number_lines=MultilineCensus(value);
}
/*
Allocate next structure.
*/
tile_image=AcquireImage((ImageInfo *) NULL,exception);
montage=AcquireImage(clone_info,exception);
montage->background_color=montage_info->background_color;
montage->scene=0;
images_per_page=(number_images-1)/(tiles_per_row*tiles_per_column)+1;
tiles=0;
total_tiles=(size_t) number_images;
for (i=0; i < (ssize_t) images_per_page; i++)
{
/*
Determine bounding box.
*/
tiles_per_page=tiles_per_row*tiles_per_column;
x_offset=0;
y_offset=0;
if (montage_info->tile != (char *) NULL)
GetMontageGeometry(montage_info->tile,number_images,&x_offset,&y_offset,
&sans,&sans);
tiles_per_page=tiles_per_row*tiles_per_column;
y_offset+=(ssize_t) title_offset;
max_height=0;
bounds.width=0;
bounds.height=0;
width=0;
for (tile=0; tile < (ssize_t) tiles_per_page; tile++)
{
if (tile < (ssize_t) number_images)
{
width=concatenate != MagickFalse ? image_list[tile]->columns :
extract_info.width;
if (image_list[tile]->rows > max_height)
max_height=image_list[tile]->rows;
}
x_offset+=(ssize_t) (width+2*(extract_info.x+border_width));
if (x_offset > (ssize_t) bounds.width)
bounds.width=(size_t) x_offset;
if (((tile+1) == (ssize_t) tiles_per_page) ||
(((tile+1) % tiles_per_row) == 0))
{
x_offset=0;
if (montage_info->tile != (char *) NULL)
GetMontageGeometry(montage_info->tile,number_images,&x_offset,&y,
&sans,&sans);
height=concatenate != MagickFalse ? max_height : extract_info.height;
y_offset+=(ssize_t) (height+(extract_info.y+(ssize_t) border_width)*2+
(metrics.ascent-metrics.descent+4)*number_lines+
(montage_info->shadow != MagickFalse ? 4 : 0));
if (y_offset > (ssize_t) bounds.height)
bounds.height=(size_t) y_offset;
max_height=0;
}
}
if (montage_info->shadow != MagickFalse)
bounds.width+=4;
/*
Initialize montage image.
*/
(void) CopyMagickString(montage->filename,montage_info->filename,
MagickPathExtent);
montage->columns=(size_t) MagickMax((ssize_t) bounds.width,1);
montage->rows=(size_t) MagickMax((ssize_t) bounds.height,1);
(void) SetImageBackgroundColor(montage,exception);
/*
Set montage geometry.
*/
montage->montage=AcquireString((char *) NULL);
tile=0;
extent=1;
while (tile < MagickMin((ssize_t) tiles_per_page,(ssize_t) number_images))
{
extent+=strlen(image_list[tile]->filename)+1;
tile++;
}
montage->directory=(char *) AcquireQuantumMemory(extent,
sizeof(*montage->directory));
if ((montage->montage == (char *) NULL) ||
(montage->directory == (char *) NULL))
{
if (montage->montage != (char *) NULL)
montage->montage=(char *) RelinquishMagickMemory(montage->montage);
if (montage->directory != (char *) NULL)
montage->directory=(char *) RelinquishMagickMemory(
montage->directory);
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
}
x_offset=0;
y_offset=0;
if (montage_info->tile != (char *) NULL)
GetMontageGeometry(montage_info->tile,number_images,&x_offset,&y_offset,
&sans,&sans);
y_offset+=(ssize_t) title_offset;
(void) FormatLocaleString(montage->montage,MagickPathExtent,
"%.20gx%.20g%+.20g%+.20g",(double) (extract_info.width+
(extract_info.x+border_width)*2),(double) (extract_info.height+
(extract_info.y+border_width)*2+(double) ((metrics.ascent-
metrics.descent+4)*number_lines+(montage_info->shadow != MagickFalse ? 4 :
0))),(double) x_offset,(double) y_offset);
*montage->directory='\0';
tile=0;
while (tile < MagickMin((ssize_t) tiles_per_page,(ssize_t) number_images))
{
(void) ConcatenateMagickString(montage->directory,
image_list[tile]->filename,extent);
(void) ConcatenateMagickString(montage->directory,"\n",extent);
tile++;
}
progress_monitor=SetImageProgressMonitor(montage,(MagickProgressMonitor)
NULL,montage->client_data);
if (texture != (Image *) NULL)
(void) TextureImage(montage,texture,exception);
if (montage_info->title != (char *) NULL)
{
DrawInfo
*draw_clone_info;
TypeMetric
tile_metrics;
/*
Annotate composite image with title.
*/
draw_clone_info=CloneDrawInfo(image_info,draw_info);
draw_clone_info->gravity=CenterGravity;
draw_clone_info->pointsize*=2.0;
(void) GetTypeMetrics(image_list[0],draw_clone_info,&tile_metrics,
exception);
(void) FormatLocaleString(tile_geometry,MagickPathExtent,
"%.20gx%.20g%+.20g%+.20g",(double) montage->columns,(double)
(tile_metrics.ascent-tile_metrics.descent),0.0,
(double) extract_info.y+4);
(void) CloneString(&draw_clone_info->geometry,tile_geometry);
(void) CloneString(&draw_clone_info->text,title);
(void) AnnotateImage(montage,draw_clone_info,exception);
draw_clone_info=DestroyDrawInfo(draw_clone_info);
}
(void) SetImageProgressMonitor(montage,progress_monitor,
montage->client_data);
/*
Copy tile to the composite.
*/
x_offset=0;
y_offset=0;
if (montage_info->tile != (char *) NULL)
GetMontageGeometry(montage_info->tile,number_images,&x_offset,&y_offset,
&sans,&sans);
x_offset+=extract_info.x;
y_offset+=(ssize_t) title_offset+extract_info.y;
max_height=0;
status=MagickTrue;
for (tile=0; tile < MagickMin((ssize_t) tiles_per_page,(ssize_t) number_images); tile++)
{
/*
Copy this tile to the composite.
*/
image=CloneImage(image_list[tile],0,0,MagickTrue,exception);
if (image == (Image *) NULL)
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
progress_monitor=SetImageProgressMonitor(image,
(MagickProgressMonitor) NULL,image->client_data);
width=concatenate != MagickFalse ? image->columns : extract_info.width;
if (image->rows > max_height)
max_height=image->rows;
height=concatenate != MagickFalse ? max_height : extract_info.height;
if (border_width != 0)
{
Image
*border_image;
RectangleInfo
border_info;
/*
Put a border around the image.
*/
border_info.width=border_width;
border_info.height=border_width;
if (montage_info->frame != (char *) NULL)
{
border_info.width=(width-image->columns+1)/2;
border_info.height=(height-image->rows+1)/2;
}
border_image=BorderImage(image,&border_info,image->compose,exception);
if (border_image != (Image *) NULL)
{
image=DestroyImage(image);
image=border_image;
}
if ((montage_info->frame != (char *) NULL) &&
(image->compose == DstOutCompositeOp))
{
(void) SetPixelChannelMask(image,AlphaChannel);
(void) NegateImage(image,MagickFalse,exception);
(void) SetPixelChannelMask(image,DefaultChannels);
}
}
/*
Gravitate as specified by the tile gravity.
*/
tile_image->columns=width;
tile_image->rows=height;
tile_image->gravity=montage_info->gravity;
if (image->gravity != UndefinedGravity)
tile_image->gravity=image->gravity;
(void) FormatLocaleString(tile_geometry,MagickPathExtent,
"%.20gx%.20g+0+0",(double) image->columns,(double) image->rows);
flags=ParseGravityGeometry(tile_image,tile_geometry,&geometry,exception);
x=(ssize_t) (geometry.x+border_width);
y=(ssize_t) (geometry.y+border_width);
if ((montage_info->frame != (char *) NULL) && (bevel_width > 0))
{
FrameInfo
frame_clone;
Image
*frame_image;
/*
Put an ornamental border around this tile.
*/
frame_clone=frame_info;
frame_clone.width=width+2*frame_info.width;
frame_clone.height=height+2*frame_info.height;
value=GetImageProperty(image,"label",exception);
if (value != (const char *) NULL)
frame_clone.height+=(size_t) ((metrics.ascent-metrics.descent+4)*
MultilineCensus(value));
frame_image=FrameImage(image,&frame_clone,image->compose,exception);
if (frame_image != (Image *) NULL)
{
image=DestroyImage(image);
image=frame_image;
}
x=0;
y=0;
}
if (LocaleCompare(image->magick,"NULL") != 0)
{
/*
Composite background with tile.
*/
if (montage_info->shadow != MagickFalse)
{
Image
*shadow_image;
/*
Shadow image.
*/
(void) QueryColorCompliance("#0000",AllCompliance,
&image->background_color,exception);
shadow_image=ShadowImage(image,80.0,2.0,5,5,exception);
if (shadow_image != (Image *) NULL)
{
(void) CompositeImage(shadow_image,image,OverCompositeOp,
MagickTrue,0,0,exception);
image=DestroyImage(image);
image=shadow_image;
}
}
(void) CompositeImage(montage,image,image->compose,MagickTrue,
x_offset+x,y_offset+y,exception);
value=GetImageProperty(image,"label",exception);
if (value != (const char *) NULL)
{
/*
Annotate composite tile with label.
*/
(void) FormatLocaleString(tile_geometry,MagickPathExtent,
"%.20gx%.20g%+.20g%+.20g",(double) ((montage_info->frame ?
image->columns : width)-2*border_width),(double)
(metrics.ascent-metrics.descent+4)*MultilineCensus(value),
(double) (x_offset+border_width),(double)
((montage_info->frame ? y_offset+height+border_width+4 :
y_offset+extract_info.height+border_width+
(montage_info->shadow != MagickFalse ? 4 : 0))+bevel_width));
(void) CloneString(&draw_info->geometry,tile_geometry);
(void) CloneString(&draw_info->text,value);
(void) AnnotateImage(montage,draw_info,exception);
}
}
x_offset+=(ssize_t) (width+2*(extract_info.x+border_width));
if (((tile+1) == (ssize_t) tiles_per_page) ||
(((tile+1) % tiles_per_row) == 0))
{
x_offset=extract_info.x;
y_offset+=(ssize_t) (height+(extract_info.y+border_width)*2+
(metrics.ascent-metrics.descent+4)*number_lines+
(montage_info->shadow != MagickFalse ? 4 : 0));
max_height=0;
}
if (images->progress_monitor != (MagickProgressMonitor) NULL)
{
proceed=SetImageProgress(image,MontageImageTag,tiles,total_tiles);
if (proceed == MagickFalse)
status=MagickFalse;
}
image_list[tile]=DestroyImage(image_list[tile]);
image=DestroyImage(image);
tiles++;
}
(void) status;
if ((i+1) < (ssize_t) images_per_page)
{
/*
Allocate next image structure.
*/
AcquireNextImage(clone_info,montage,exception);
if (GetNextImageInList(montage) == (Image *) NULL)
{
montage=DestroyImageList(montage);
return((Image *) NULL);
}
montage=GetNextImageInList(montage);
montage->background_color=montage_info->background_color;
image_list+=tiles_per_page;
number_images-=tiles_per_page;
}
}
tile_image=DestroyImage(tile_image);
if (texture != (Image *) NULL)
texture=DestroyImage(texture);
title=DestroyString(title);
master_list=(Image **) RelinquishMagickMemory(master_list);
draw_info=DestroyDrawInfo(draw_info);
clone_info=DestroyImageInfo(clone_info);
return(GetFirstImageInList(montage));
}
Image *subtract_image(Image *canvas_image, Image *img)
{
CompositeImage(img, CopyBlackCompositeOp, canvas_image, 0, 0);
SyncImagePixels(img);
return (img);
}
bool ScImgDataLoader_GMagick::loadPicture(const QString& fn, int /*page*/, int res, bool thumbnail)
{
if (!QFile::exists(fn))
return false;
bool valid = m_imageInfoRecord.isRequest;
QMap<int, ImageLoadRequest> req = m_imageInfoRecord.RequestProps;
initialize();
m_imageInfoRecord.RequestProps = req;
m_imageInfoRecord.isRequest = valid;
m_imageInfoRecord.type = ImageTypeOther;
m_imageInfoRecord.exifDataValid = false;
m_imageInfoRecord.layerInfo.clear();
m_imageInfoRecord.PDSpathData.clear();
initGraphicsMagick();
ExceptionInfo exception;
GetExceptionInfo(&exception);
ImageInfo *image_info = CloneImageInfo(0);
strcpy(image_info->filename, fn.toUtf8().data());
image_info->units = PixelsPerInchResolution;
Image *image = ReadImage(image_info, &exception);
if (exception.severity != UndefinedException)
CatchException(&exception);
if (!image)
{
qCritical() << "Failed to read image" << fn;
return false;
}
int width = image->columns;
int height = image->rows;
double xres = image->x_resolution;
double yres = image->y_resolution;
if (thumbnail)
image = FlattenImages(image, &exception);
else
{
struct PSDLayer layer;
layerCount = 0;
Image *flatten_image = CloneImage(image, 0, 0, true, &exception);
Image *next;
if ((flatten_image != (Image *) NULL) && (image->next != (Image *) NULL))
{
bool visible = true;
double opacity = 1.0;
QString compositeOp = blendModeToString(flatten_image->compose);
QString layerName = QString("layer%1").arg(layerCount+1);
if ((m_imageInfoRecord.isRequest) && (m_imageInfoRecord.RequestProps.contains(layerCount)))
opacity = m_imageInfoRecord.RequestProps[layerCount].opacity / 255.0;
if ((m_imageInfoRecord.isRequest) && (m_imageInfoRecord.RequestProps.contains(layerCount)))
visible = m_imageInfoRecord.RequestProps[layerCount].visible;
if ((m_imageInfoRecord.isRequest) && (m_imageInfoRecord.RequestProps.contains(layerCount)))
compositeOp = m_imageInfoRecord.RequestProps[layerCount].blend;
layer.layerName = layerName;
layer.channelType.clear();
layer.channelLen.clear();
layer.opacity = qRound(opacity * 255);
layer.blend = compositeOp;
layer.maskYpos = 0;
layer.maskXpos = 0;
layer.maskHeight = 0;
layer.maskWidth = 0;
layer.flags = visible ? 0 : 2;
QImage imt;
if (image->colorspace == CMYKColorspace)
{
RawImage r2_image;
readCMYK(flatten_image, &r2_image, width, height);
imt = r2_image.convertToQImage(true);
}
else
{
m_useRawImage = false;
imt = QImage(width, height, QImage::Format_ARGB32);
readRGB(flatten_image, &imt, width, height);
}
double sx = imt.width() / 40.0;
double sy = imt.height() / 40.0;
layer.thumb = sy < sx ? imt.scaled(qRound(imt.width() / sx), qRound(imt.height() / sx), Qt::IgnoreAspectRatio, Qt::SmoothTransformation) :
imt.scaled(qRound(imt.width() / sy), qRound(imt.height() / sy), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
m_imageInfoRecord.layerInfo.append(layer);
layerCount++;
if (!visible)
{
(void)CompositeImage(flatten_image, ClearCompositeOp, flatten_image, flatten_image->page.x, flatten_image->page.y);
}
for (next = image->next; next != (Image*)NULL; next = next->next)
{
visible = true;
opacity = 1.0;
compositeOp = blendModeToString(next->compose);
layerName = QString("layer%1").arg(layerCount+1);
if ((m_imageInfoRecord.isRequest) && (m_imageInfoRecord.RequestProps.contains(layerCount)))
opacity = m_imageInfoRecord.RequestProps[layerCount].opacity / 255.0;
if ((m_imageInfoRecord.isRequest) && (m_imageInfoRecord.RequestProps.contains(layerCount)))
visible = m_imageInfoRecord.RequestProps[layerCount].visible;
if ((m_imageInfoRecord.isRequest) && (m_imageInfoRecord.RequestProps.contains(layerCount)))
compositeOp = m_imageInfoRecord.RequestProps[layerCount].blend;
layer.layerName = layerName;
layer.channelType.clear();
layer.channelLen.clear();
layer.opacity = qRound(opacity * 255);
layer.blend = compositeOp;
layer.maskYpos = 0;
layer.maskXpos = 0;
layer.maskHeight = 0;
layer.maskWidth = 0;
layer.flags = visible ? 0 : 2;
if (image->colorspace == CMYKColorspace)
{
RawImage r2_image;
readCMYK(next, &r2_image, width, height);
imt = r2_image.convertToQImage(true);
}
else
{
m_useRawImage = false;
imt = QImage(width, height, QImage::Format_ARGB32);
readRGB(next, &imt, width, height);
}
double sx = imt.width() / 40.0;
double sy = imt.height() / 40.0;
layer.thumb = sy < sx ? imt.scaled(qRound(imt.width() / sx), qRound(imt.height() / sx), Qt::IgnoreAspectRatio, Qt::SmoothTransformation) :
imt.scaled(qRound(imt.width() / sy), qRound(imt.height() / sy), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
m_imageInfoRecord.layerInfo.append(layer);
layerCount++;
if (visible)
(void)CompositeImage(flatten_image, (CompositeOperator)blendModeToInt(compositeOp), next, next->page.x, next->page.y);
}
image = CloneImage(flatten_image, 0, 0, true, &exception);
}
}
if (image->colorspace == CMYKColorspace)
{
m_useRawImage = true;
if (!readCMYK(image, &r_image, width, height))
return false;
m_imageInfoRecord.colorspace = ColorSpaceCMYK;
m_pixelFormat = (r_image.channels() == 5) ? Format_CMYKA_8 : Format_CMYK_8;
}
else
{
m_useRawImage = false;
m_image = QImage(width, height, QImage::Format_ARGB32);
if (!readRGB(image, &m_image, width, height))
return false;
m_imageInfoRecord.colorspace = ColorSpaceRGB;
m_pixelFormat = Format_BGRA_8;
}
m_imageInfoRecord.exifDataValid = false;
if (thumbnail)
{
m_imageInfoRecord.exifDataValid = true;
m_imageInfoRecord.exifInfo.thumbnail = m_image;
m_imageInfoRecord.exifInfo.height = height;
m_imageInfoRecord.exifInfo.width = width;
}
m_imageInfoRecord.type = ImageTypeOther;
m_imageInfoRecord.xres = qMax(72, qRound(xres));
m_imageInfoRecord.yres = qMax(72, qRound(yres));
m_imageInfoRecord.BBoxX = 0;
m_imageInfoRecord.BBoxH = m_image.height();
m_imageInfoRecord.valid = true;
return true;
}
