/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d N U L L I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ReadNULLImage creates a constant image and initializes it to the
% X server color as specified by the filename. It allocates the memory
% necessary for the new Image structure and returns a pointer to the new
% image.
%
% The format of the ReadNULLImage method is:
%
% Image *ReadNULLImage(const ImageInfo *image_info,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o exception: return any errors or warnings in this structure.
%
*/
static Image *ReadNULLImage(const ImageInfo *image_info,
ExceptionInfo *exception)
{
Image
*image;
ssize_t
y;
MagickPixelPacket
background;
register IndexPacket
*indexes;
register ssize_t
x;
register PixelPacket
*q;
/*
Initialize Image structure.
*/
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);
if (image->columns == 0)
image->columns=1;
if (image->rows == 0)
image->rows=1;
image->matte=MagickTrue;
GetMagickPixelPacket(image,&background);
background.opacity=(MagickRealType) TransparentOpacity;
if (image->colorspace == CMYKColorspace)
ConvertRGBToCMYK(&background);
for (y=0; y < (ssize_t) image->rows; y++)
{
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
indexes=GetAuthenticIndexQueue(image);
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelPacket(image,&background,q,indexes);
q++;
indexes++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
return(GetFirstImageInList(image));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d N U L L I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ReadNULLImage creates a constant image and initializes it to the
% X server color as specified by the filename. It allocates the memory
% necessary for the new Image structure and returns a pointer to the new
% image.
%
% The format of the ReadNULLImage method is:
%
% Image *ReadNULLImage(const ImageInfo *image_info,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o exception: return any errors or warnings in this structure.
%
*/
static Image *ReadNULLImage(const ImageInfo *image_info,
ExceptionInfo *exception)
{
Image
*image;
PixelInfo
background;
register ssize_t
x;
register Quantum
*q;
ssize_t
y;
/*
Initialize Image structure.
*/
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,exception);
if (image->columns == 0)
image->columns=1;
if (image->rows == 0)
image->rows=1;
image->alpha_trait=BlendPixelTrait;
GetPixelInfo(image,&background);
background.alpha=(double) TransparentAlpha;
if (image->colorspace == CMYKColorspace)
ConvertRGBToCMYK(&background);
for (y=0; y < (ssize_t) image->rows; y++)
{
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelInfoPixel(image,&background,q);
q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
return(GetFirstImageInList(image));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S e t I m a g e A l p h a C h a n n e l %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% SetImageAlphaChannel() activates, deactivates, resets, or sets the alpha
% channel.
%
% The format of the SetImageAlphaChannel method is:
%
% MagickBooleanType SetImageAlphaChannel(Image *image,
% const AlphaChannelType alpha_type)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o alpha_type: The alpha channel type: ActivateAlphaChannel,
% CopyAlphaChannel, DeactivateAlphaChannel, ExtractAlphaChannel,
% OpaqueAlphaChannel, ResetAlphaChannel, SetAlphaChannel,
% ShapeAlphaChannel, and TransparentAlphaChannel.
%
*/
MagickExport MagickBooleanType SetImageAlphaChannel(Image *image,
const AlphaChannelType alpha_type)
{
MagickBooleanType
status;
assert(image != (Image *) NULL);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(image->signature == MagickSignature);
status=MagickTrue;
switch (alpha_type)
{
case ActivateAlphaChannel:
{
image->matte=MagickTrue;
break;
}
case BackgroundAlphaChannel:
{
CacheView
*image_view;
ExceptionInfo
*exception;
IndexPacket
index;
MagickBooleanType
status;
MagickPixelPacket
background;
PixelPacket
pixel;
ssize_t
y;
/*
Set transparent pixels to background color.
*/
if (image->matte == MagickFalse)
break;
if (SetImageStorageClass(image,DirectClass) == MagickFalse)
break;
GetMagickPixelPacket(image,&background);
SetMagickPixelPacket(image,&image->background_color,(const IndexPacket *)
NULL,&background);
if (image->colorspace == CMYKColorspace)
ConvertRGBToCMYK(&background);
index=0;
SetPixelPacket(image,&background,&pixel,&index);
status=MagickTrue;
exception=(&image->exception);
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 IndexPacket
*restrict indexes;
register PixelPacket
*restrict q;
register ssize_t
x;
if (status == MagickFalse)
continue;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
exception);
if (q == (PixelPacket *) NULL)
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
if (q->opacity == TransparentOpacity)
{
SetPixelRed(q,pixel.red);
SetPixelGreen(q,pixel.green);
SetPixelBlue(q,pixel.blue);
}
q++;
}
if (image->colorspace == CMYKColorspace)
{
indexes=GetCacheViewAuthenticIndexQueue(image_view);
for (x=0; x < (ssize_t) image->columns; x++)
SetPixelIndex(indexes+x,index);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
}
image_view=DestroyCacheView(image_view);
return(status);
}
case CopyAlphaChannel:
case ShapeAlphaChannel:
{
/*
Special usage case for SeparateImageChannel(): copy grayscale color to
the alpha channel.
*/
status=SeparateImageChannel(image,GrayChannels);
image->matte=MagickTrue; /* make sure transparency is now on! */
if (alpha_type == ShapeAlphaChannel)
{
MagickPixelPacket
background;
/*
Reset all color channels to background color.
*/
GetMagickPixelPacket(image,&background);
SetMagickPixelPacket(image,&(image->background_color),(IndexPacket *)
NULL,&background);
(void) LevelColorsImage(image,&background,&background,MagickTrue);
}
break;
}
case DeactivateAlphaChannel:
{
image->matte=MagickFalse;
break;
}
case ExtractAlphaChannel:
{
status=SeparateImageChannel(image,TrueAlphaChannel);
image->matte=MagickFalse;
break;
}
case RemoveAlphaChannel:
case FlattenAlphaChannel:
{
CacheView
*image_view;
ExceptionInfo
*exception;
IndexPacket
index;
MagickBooleanType
status;
MagickPixelPacket
background;
PixelPacket
pixel;
ssize_t
y;
/*
Flatten image pixels over the background pixels.
*/
if (image->matte == MagickFalse)
break;
if (SetImageStorageClass(image,DirectClass) == MagickFalse)
break;
GetMagickPixelPacket(image,&background);
SetMagickPixelPacket(image,&image->background_color,(const IndexPacket *)
NULL,&background);
if (image->colorspace == CMYKColorspace)
ConvertRGBToCMYK(&background);
index=0;
SetPixelPacket(image,&background,&pixel,&index);
status=MagickTrue;
exception=(&image->exception);
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 IndexPacket
*restrict indexes;
register PixelPacket
*restrict q;
register ssize_t
x;
if (status == MagickFalse)
continue;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
exception);
if (q == (PixelPacket *) NULL)
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
double
gamma,
opacity;
gamma=1.0-QuantumScale*QuantumScale*q->opacity*pixel.opacity;
opacity=(double) QuantumRange*(1.0-gamma);
gamma=PerceptibleReciprocal(gamma);
q->red=ClampToQuantum(gamma*MagickOver_((MagickRealType) q->red,
(MagickRealType) q->opacity,(MagickRealType) pixel.red,
(MagickRealType) pixel.opacity));
q->green=ClampToQuantum(gamma*MagickOver_((MagickRealType) q->green,
(MagickRealType) q->opacity,(MagickRealType) pixel.green,
(MagickRealType) pixel.opacity));
q->blue=ClampToQuantum(gamma*MagickOver_((MagickRealType) q->blue,
(MagickRealType) q->opacity,(MagickRealType) pixel.blue,
(MagickRealType) pixel.opacity));
q->opacity=ClampToQuantum(opacity);
q++;
}
if (image->colorspace == CMYKColorspace)
{
indexes=GetCacheViewAuthenticIndexQueue(image_view);
for (x=0; x < (ssize_t) image->columns; x++)
SetPixelIndex(indexes+x,index);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
}
image_view=DestroyCacheView(image_view);
return(status);
}
case ResetAlphaChannel: /* deprecated */
case OpaqueAlphaChannel:
{
status=SetImageOpacity(image,OpaqueOpacity);
break;
}
case SetAlphaChannel:
{
if (image->matte == MagickFalse)
status=SetImageOpacity(image,OpaqueOpacity);
break;
}
case TransparentAlphaChannel:
{
status=SetImageOpacity(image,TransparentOpacity);
break;
}
case UndefinedAlphaChannel:
break;
}
if (status == MagickFalse)
return(status);
return(SyncImagePixelCache(image,&image->exception));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% 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);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ Y S h e a r I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% YShearImage shears the image in the Y direction with a shear angle of
% 'degrees'. Positive angles shear counter-clockwise (right-hand rule), and
% negative angles shear clockwise. Angles are measured relative to a
% horizontal X-axis. Y shears will increase the height of an image creating
% 'empty' triangles on the top and bottom of the source image.
%
% The format of the YShearImage method is:
%
% void YShearImage(Image *image,const MagickRealType degrees,
% const unsigned long width,const unsigned long height,long x_offset,
% const long y_offset)
%
% A description of each parameter follows.
%
% o image: the image.
%
% o degrees: A MagickRealType representing the shearing angle along the Y
% axis.
%
% o width, height, x_offset, y_offset: Defines a region of the image
% to shear.
%
*/
static void YShearImage(Image *image,const MagickRealType degrees,
const unsigned long width,const unsigned long height,long x_offset,
const long y_offset)
{
#define YShearImageTag "YShear/Image"
enum {UP, DOWN}
direction;
IndexPacket
*indexes,
*shear_indexes;
long
step,
y;
MagickBooleanType
status;
MagickPixelPacket
background,
pixel,
source,
destination;
MagickRealType
area,
displacement;
register PixelPacket
*p,
*q;
register long
i;
assert(image != (Image *) NULL);
x_offset--;
for (y=0; y < (long) width; y++)
{
x_offset++;
displacement=degrees*(MagickRealType) (y-width/2.0);
if (displacement == 0.0)
continue;
if (displacement > 0.0)
direction=DOWN;
else
{
displacement*=(-1.0);
direction=UP;
}
step=(long) floor((double) displacement);
area=(MagickRealType) (displacement-step);
step++;
GetMagickPixelPacket(image,&background);
SetMagickPixelPacket(image,&image->background_color,(IndexPacket *) NULL,
&background);
if (image->colorspace == CMYKColorspace)
ConvertRGBToCMYK(&background);
pixel=background;
GetMagickPixelPacket(image,&source);
GetMagickPixelPacket(image,&destination);
switch (direction)
{
case UP:
{
/*
Transfer pixels top-to-bottom.
*/
if (step > y_offset)
break;
p=GetImagePixels(image,x_offset,0,1,image->rows);
if (p == (PixelPacket *) NULL)
break;
p+=y_offset;
indexes=GetIndexes(image);
indexes+=y_offset;
q=p-step;
shear_indexes=indexes-step;
for (i=0; i < (long) height; i++)
{
if ((y_offset+i) < step)
{
SetMagickPixelPacket(image,++p,++indexes,&pixel);
q++;
shear_indexes++;
continue;
}
SetMagickPixelPacket(image,p,indexes,&source);
MagickCompositeBlend(&pixel,(MagickRealType) pixel.opacity,&source,
(MagickRealType) p->opacity,area,&destination);
SetPixelPacket(image,&destination,q++,shear_indexes++);
SetMagickPixelPacket(image,p++,indexes++,&pixel);
}
MagickCompositeBlend(&pixel,(MagickRealType) pixel.opacity,&background,
(MagickRealType) background.opacity,area,&destination);
SetPixelPacket(image,&destination,q++,shear_indexes++);
for (i=0; i < (step-1); i++)
SetPixelPacket(image,&background,q++,shear_indexes++);
break;
}
case DOWN:
{
/*
Transfer pixels bottom-to-top.
*/
p=GetImagePixels(image,x_offset,0,1,image->rows);
if (p == (PixelPacket *) NULL)
break;
p+=y_offset+height;
indexes=GetIndexes(image);
indexes+=y_offset+height;
q=p+step;
shear_indexes=indexes+step;
for (i=0; i < (long) height; i++)
{
p--;
indexes--;
q--;
shear_indexes--;
if ((unsigned long) (y_offset+height+step-i) >= image->rows)
continue;
SetMagickPixelPacket(image,p,indexes,&source);
MagickCompositeBlend(&pixel,(MagickRealType) pixel.opacity,&source,
(MagickRealType) p->opacity,area,&destination);
SetPixelPacket(image,&destination,q,shear_indexes);
SetMagickPixelPacket(image,p,indexes,&pixel);
}
MagickCompositeBlend(&pixel,(MagickRealType) pixel.opacity,&background,
(MagickRealType) background.opacity,area,&destination);
SetPixelPacket(image,&destination,--q,--shear_indexes);
for (i=0; i < (step-1); i++)
SetPixelPacket(image,&background,--q,--shear_indexes);
break;
}
}
if (SyncImagePixels(image) == MagickFalse)
break;
if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
(QuantumTick(y,width) != MagickFalse))
{
status=image->progress_monitor(XShearImageTag,y,width,
image->client_data);
if (status == MagickFalse)
break;
}
}
}
static void XShearImage(Image *image,const MagickRealType degrees,
const unsigned long width,const unsigned long height,const long x_offset,
long y_offset)
{
#define XShearImageTag "XShear/Image"
enum {LEFT, RIGHT}
direction;
IndexPacket
*indexes,
*shear_indexes;
long
step,
y;
MagickBooleanType
status;
MagickPixelPacket
background,
pixel,
source,
destination;
MagickRealType
area,
displacement;
register long
i;
register PixelPacket
*p,
*q;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
y_offset--;
for (y=0; y < (long) height; y++)
{
y_offset++;
displacement=degrees*(MagickRealType) (y-height/2.0);
if (displacement == 0.0)
continue;
if (displacement > 0.0)
direction=RIGHT;
else
{
displacement*=(-1.0);
direction=LEFT;
}
step=(long) floor((double) displacement);
area=(MagickRealType) (displacement-step);
step++;
GetMagickPixelPacket(image,&background);
SetMagickPixelPacket(image,&image->background_color,(IndexPacket *) NULL,
&background);
if (image->colorspace == CMYKColorspace)
ConvertRGBToCMYK(&background);
pixel=background;
GetMagickPixelPacket(image,&source);
GetMagickPixelPacket(image,&destination);
switch (direction)
{
case LEFT:
{
/*
Transfer pixels left-to-right.
*/
if (step > x_offset)
break;
p=GetImagePixels(image,0,y_offset,image->columns,1);
if (p == (PixelPacket *) NULL)
break;
p+=x_offset;
indexes=GetIndexes(image);
indexes+=x_offset;
q=p-step;
shear_indexes=indexes-step;
for (i=0; i < (long) width; i++)
{
if ((x_offset+i) < step)
{
SetMagickPixelPacket(image,++p,++indexes,&pixel);
q++;
shear_indexes++;
continue;
}
SetMagickPixelPacket(image,p,indexes,&source);
MagickCompositeBlend(&pixel,(MagickRealType) pixel.opacity,&source,
(MagickRealType) p->opacity,area,&destination);
SetPixelPacket(image,&destination,q++,shear_indexes++);
SetMagickPixelPacket(image,p++,indexes++,&pixel);
}
MagickCompositeBlend(&pixel,(MagickRealType) pixel.opacity,&background,
(MagickRealType) background.opacity,area,&destination);
SetPixelPacket(image,&destination,q++,shear_indexes++);
for (i=0; i < (step-1); i++)
SetPixelPacket(image,&background,q++,shear_indexes++);
break;
}
case RIGHT:
{
/*
Transfer pixels right-to-left.
*/
p=GetImagePixels(image,0,y_offset,image->columns,1);
if (p == (PixelPacket *) NULL)
break;
p+=x_offset+width;
indexes=GetIndexes(image);
indexes+=x_offset+width;
q=p+step;
shear_indexes=indexes+step;
for (i=0; i < (long) width; i++)
{
p--;
indexes--;
q--;
shear_indexes--;
if ((unsigned long) (x_offset+width+step-i) >= image->columns)
continue;
SetMagickPixelPacket(image,p,indexes,&source);
MagickCompositeBlend(&pixel,(MagickRealType) pixel.opacity,&source,
(MagickRealType) p->opacity,area,&destination);
SetPixelPacket(image,&destination,q,shear_indexes);
SetMagickPixelPacket(image,p,indexes,&pixel);
}
MagickCompositeBlend(&pixel,(MagickRealType) pixel.opacity,&background,
(MagickRealType) background.opacity,area,&destination);
SetPixelPacket(image,&destination,--q,--shear_indexes);
for (i=0; i < (step-1); i++)
SetPixelPacket(image,&background,--q,--shear_indexes);
break;
}
}
if (SyncImagePixels(image) == MagickFalse)
break;
if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
(QuantumTick(y,height) != MagickFalse))
{
status=image->progress_monitor(XShearImageTag,y,height,
image->client_data);
if (status == MagickFalse)
break;
}
}
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% F l o o d f i l l P a i n t I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% FloodfillPaintImage() changes the color value of any pixel that matches
% target and is an immediate neighbor. If the method FillToBorderMethod is
% specified, the color value is changed for any neighbor pixel that does not
% match the bordercolor member of image.
%
% By default target must match a particular pixel color exactly.
% However, in many cases two colors may differ by a small amount. The
% fuzz member of image defines how much tolerance is acceptable to
% consider two colors as the same. For example, set fuzz to 10 and the
% color red at intensities of 100 and 102 respectively are now
% interpreted as the same color for the purposes of the floodfill.
%
% The format of the FloodfillPaintImage method is:
%
% MagickBooleanType FloodfillPaintImage(Image *image,
% const ChannelType channel,const DrawInfo *draw_info,
% const MagickPixelPacket target,const ssize_t x_offset,
% const ssize_t y_offset,const MagickBooleanType invert)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o channel: the channel(s).
%
% o draw_info: the draw info.
%
% o target: the RGB value of the target color.
%
% o x_offset,y_offset: the starting location of the operation.
%
% o invert: paint any pixel that does not match the target color.
%
*/
MagickExport MagickBooleanType FloodfillPaintImage(Image *image,
const ChannelType channel,const DrawInfo *draw_info,
const MagickPixelPacket *target,const ssize_t x_offset,const ssize_t y_offset,
const MagickBooleanType invert)
{
#define MaxStacksize (1UL << 15)
#define PushSegmentStack(up,left,right,delta) \
{ \
if (s >= (segment_stack+MaxStacksize)) \
ThrowBinaryException(DrawError,"SegmentStackOverflow",image->filename) \
else \
{ \
if ((((up)+(delta)) >= 0) && (((up)+(delta)) < (ssize_t) image->rows)) \
{ \
s->x1=(double) (left); \
s->y1=(double) (up); \
s->x2=(double) (right); \
s->y2=(double) (delta); \
s++; \
} \
} \
}
CacheView
*floodplane_view,
*image_view;
ExceptionInfo
*exception;
Image
*floodplane_image;
MagickBooleanType
skip;
MagickPixelPacket
fill,
pixel;
PixelPacket
fill_color;
register SegmentInfo
*s;
SegmentInfo
*segment_stack;
ssize_t
offset,
start,
x,
x1,
x2,
y;
/*
Check boundary conditions.
*/
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(draw_info != (DrawInfo *) NULL);
assert(draw_info->signature == MagickSignature);
if ((x_offset < 0) || (x_offset >= (ssize_t) image->columns))
return(MagickFalse);
if ((y_offset < 0) || (y_offset >= (ssize_t) image->rows))
return(MagickFalse);
if (SetImageStorageClass(image,DirectClass) == MagickFalse)
return(MagickFalse);
if (IsGrayColorspace(image->colorspace) != MagickFalse)
(void) TransformImageColorspace(image,sRGBColorspace);
if ((image->matte == MagickFalse) &&
(draw_info->fill.opacity != OpaqueOpacity))
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel);
/*
Set floodfill state.
*/
floodplane_image=CloneImage(image,0,0,MagickTrue,&image->exception);
if (floodplane_image == (Image *) NULL)
return(MagickFalse);
(void) SetImageAlphaChannel(floodplane_image,OpaqueAlphaChannel);
segment_stack=(SegmentInfo *) AcquireQuantumMemory(MaxStacksize,
sizeof(*segment_stack));
if (segment_stack == (SegmentInfo *) NULL)
{
floodplane_image=DestroyImage(floodplane_image);
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
}
/*
Push initial segment on stack.
*/
exception=(&image->exception);
x=x_offset;
y=y_offset;
start=0;
s=segment_stack;
PushSegmentStack(y,x,x,1);
PushSegmentStack(y+1,x,x,-1);
GetMagickPixelPacket(image,&fill);
GetMagickPixelPacket(image,&pixel);
image_view=AcquireVirtualCacheView(image,exception);
floodplane_view=AcquireAuthenticCacheView(floodplane_image,exception);
while (s > segment_stack)
{
register const IndexPacket
*restrict indexes;
register const PixelPacket
*restrict p;
register ssize_t
x;
register PixelPacket
*restrict q;
/*
Pop segment off stack.
*/
s--;
x1=(ssize_t) s->x1;
x2=(ssize_t) s->x2;
offset=(ssize_t) s->y2;
y=(ssize_t) s->y1+offset;
/*
Recolor neighboring pixels.
*/
p=GetCacheViewVirtualPixels(image_view,0,y,(size_t) (x1+1),1,exception);
q=GetCacheViewAuthenticPixels(floodplane_view,0,y,(size_t) (x1+1),1,
exception);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
break;
indexes=GetCacheViewVirtualIndexQueue(image_view);
p+=x1;
q+=x1;
for (x=x1; x >= 0; x--)
{
if (q->opacity == (Quantum) TransparentOpacity)
break;
SetMagickPixelPacket(image,p,indexes+x,&pixel);
if (IsMagickColorSimilar(&pixel,target) == invert)
break;
q->opacity=(Quantum) TransparentOpacity;
p--;
q--;
}
if (SyncCacheViewAuthenticPixels(floodplane_view,exception) == MagickFalse)
break;
skip=x >= x1 ? MagickTrue : MagickFalse;
if (skip == MagickFalse)
{
start=x+1;
if (start < x1)
PushSegmentStack(y,start,x1-1,-offset);
x=x1+1;
}
do
{
if (skip == MagickFalse)
{
if (x < (ssize_t) image->columns)
{
p=GetCacheViewVirtualPixels(image_view,x,y,image->columns-x,1,
exception);
q=GetCacheViewAuthenticPixels(floodplane_view,x,y,
image->columns-x,1,exception);
if ((p == (const PixelPacket *) NULL) ||
(q == (PixelPacket *) NULL))
break;
indexes=GetCacheViewVirtualIndexQueue(image_view);
for ( ; x < (ssize_t) image->columns; x++)
{
if (q->opacity == (Quantum) TransparentOpacity)
break;
SetMagickPixelPacket(image,p,indexes+x,&pixel);
if (IsMagickColorSimilar(&pixel,target) == invert)
break;
q->opacity=(Quantum) TransparentOpacity;
p++;
q++;
}
if (SyncCacheViewAuthenticPixels(floodplane_view,exception) == MagickFalse)
break;
}
PushSegmentStack(y,start,x-1,offset);
if (x > (x2+1))
PushSegmentStack(y,x2+1,x-1,-offset);
}
skip=MagickFalse;
x++;
if (x <= x2)
{
p=GetCacheViewVirtualPixels(image_view,x,y,(size_t) (x2-x+1),1,
exception);
q=GetCacheViewAuthenticPixels(floodplane_view,x,y,(size_t) (x2-x+1),1,
exception);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
break;
indexes=GetCacheViewVirtualIndexQueue(image_view);
for ( ; x <= x2; x++)
{
if (q->opacity == (Quantum) TransparentOpacity)
break;
SetMagickPixelPacket(image,p,indexes+x,&pixel);
if (IsMagickColorSimilar(&pixel,target) != invert)
break;
p++;
q++;
}
}
start=x;
} while (x <= x2);
}
for (y=0; y < (ssize_t) image->rows; y++)
{
register const PixelPacket
*restrict p;
register IndexPacket
*restrict indexes;
register ssize_t
x;
register PixelPacket
*restrict q;
/*
Tile fill color onto floodplane.
*/
p=GetCacheViewVirtualPixels(floodplane_view,0,y,image->columns,1,
exception);
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
break;
indexes=GetCacheViewAuthenticIndexQueue(image_view);
for (x=0; x < (ssize_t) image->columns; x++)
{
if (GetPixelOpacity(p) != OpaqueOpacity)
{
(void) GetFillColor(draw_info,x,y,&fill_color);
SetMagickPixelPacket(image,&fill_color,(IndexPacket *) NULL,&fill);
if (image->colorspace == CMYKColorspace)
ConvertRGBToCMYK(&fill);
if ((channel & RedChannel) != 0)
SetPixelRed(q,ClampToQuantum(fill.red));
if ((channel & GreenChannel) != 0)
SetPixelGreen(q,ClampToQuantum(fill.green));
if ((channel & BlueChannel) != 0)
SetPixelBlue(q,ClampToQuantum(fill.blue));
if ((channel & OpacityChannel) != 0)
SetPixelOpacity(q,ClampToQuantum(fill.opacity));
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
SetPixelIndex(indexes+x,ClampToQuantum(fill.index));
}
p++;
q++;
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
break;
}
floodplane_view=DestroyCacheView(floodplane_view);
image_view=DestroyCacheView(image_view);
segment_stack=(SegmentInfo *) RelinquishMagickMemory(segment_stack);
floodplane_image=DestroyImage(floodplane_image);
return(y == (ssize_t) image->rows ? MagickTrue : MagickFalse);
}
MagickExport Image *DistortImage(Image *image,const DistortImageMethod method,
const unsigned long number_arguments,const double *arguments,
MagickBooleanType bestfit, ExceptionInfo *exception)
{
#define DistortImageTag "Distort/Image"
double
coefficients[9],
validity;
Image
*distort_image;
register long
i,
x;
long
j,
y;
PointInfo
point; /* point to sample (center of filtered resample of area) */
MagickPixelPacket
pixel, /* pixel to assign to distorted image */
invalid; /* the color to assign when distort result is invalid */
register IndexPacket
*indexes;
register PixelPacket
*q;
ResampleFilter
*resample_filter;
ViewInfo
*distort_view;
MagickBooleanType
status;
RectangleInfo
geometry;
const char
*property;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
(void) ResetMagickMemory(coefficients,0,sizeof(coefficients));
/*
Convert input arguments into mapping coefficents for distortion
*/
switch (method)
{
case AffineDistortion:
{
double
**matrix;
PointInfo
*points;
/* Affine Distortion
u = c0*x + c2*y + c4
v = c1*x + c3*y + c5
Input Arguments are pairs of distorted coodinates (minimum 3 sets)
Which will be used to generate the coefficients of the above.
u1,v1, x1,y1, u2,v2, x2,y2, u3,v3, x3,y3, ...
*/
if (number_arguments != 12) { /* to be removed */
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"InvalidArgument","%s : '%s'","distort Affine",
"Needs 12 numbers");
return((Image *) NULL);
}
if (number_arguments%4 != 0) {
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"InvalidArgument","%s : '%s'","distort Affine",
"Requires pairs of coords (4 numbers U,V,X,Y)");
return((Image *) NULL);
}
if (number_arguments < 12) {
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"InvalidArgument","%s : '%s'","distort Affine",
"Minimum of 3 pairs of coords needed (12 numbers)");
return((Image *) NULL);
}
points=(PointInfo *) AcquireQuantumMemory((number_arguments)/2UL,
sizeof(*points));
if (points == (PointInfo *) NULL)
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
for (i=0; i < (long) number_arguments; i++)
if ((i % 2 ) == 0)
points[i/2].x=arguments[i];
else
points[i/2].y=arguments[i];
matrix = AcquireMagickMatrix(6UL,6UL);
if (matrix == (double **) NULL)
{
points=(PointInfo *) RelinquishMagickMemory(points);
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
}
status=SolveAffineDistortion(6UL,points,matrix,coefficients);
matrix = RelinquishMagickMatrix(matrix, 6UL);
points = (PointInfo *) RelinquishMagickMemory(points);
if ( status == MagickFalse ) {
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"InvalidArgument","%s : '%s'","distort Affine",
"Degenerate Result");
return((Image *) NULL);
}
break;
}
case AffineProjectionDistortion:
{
/*
Arguments: Affine Matrix (forward mapping)
sx, rx, ry, sy, tx, ty
*/
if (number_arguments != 6) {
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"InvalidArgument","%s : '%s'","distort AffineProjection",
"Needs 6 numbers");
return((Image *) NULL);
}
InvertAffineCoefficients(arguments, coefficients);
break;
}
case BilinearDistortion:
{
double
**matrix;
PointInfo
*points;
/* Bilinear Distortion (reversed)
u = c0*x + c1*y + c2*x*y + c3;
v = c4*x + c5*y + c6*x*y + c7;
Input Arguments are pairs of distorted coodinates (minimum 4 pairs)
Which will be used to generate the coefficients of the above.
u1,v1, x1,y1, u2,v2, x2,y2, u3,v3, x3,y3, u4,v4, x4,y4 ...
*/
if (number_arguments != 16) { /* to be removed */
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"InvalidArgument","%s : '%s'","distort Bilinear",
"Needs 16 numbers");
return((Image *) NULL);
}
if (number_arguments%4 != 0) {
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"InvalidArgument","%s : '%s'","distort Bilinear",
"Requires pairs of coords (4 numbers U,V,X,Y)");
return((Image *) NULL);
}
if (number_arguments < 16) {
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"InvalidArgument","%s : '%s'","distort Bilinear",
"Minimum of 4 pairs of coords needed (16 numbers)");
return((Image *) NULL);
}
points=(PointInfo *) AcquireQuantumMemory((number_arguments+1UL)/2UL,
sizeof(*points));
if (points == (PointInfo *) NULL)
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
for (i=0; i < (long) number_arguments; i++)
if ((i % 2 ) == 0)
points[i/2].x=arguments[i];
else
points[i/2].y=arguments[i];
matrix = AcquireMagickMatrix(8UL,8UL);
if (matrix == (double **) NULL)
{
points=(PointInfo *) RelinquishMagickMemory(points);
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
}
status=SolveBilinearDistortion(8UL,points,matrix,coefficients);
matrix = RelinquishMagickMatrix(matrix, 8UL);
points = (PointInfo *) RelinquishMagickMemory(points);
if ( status == MagickFalse ) {
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"InvalidArgument","%s : '%s'","distort Bilinear",
"Degenerate Result");
return((Image *) NULL);
}
break;
}
case PerspectiveDistortion:
{
double
**matrix;
PointInfo
*points;
/* Perspective Distortion (a ratio of affine distortions)
p c0*x + c1*y + c2
u = --- = ------------------
r c6*x + c7*y + 1
q c3*x + c4*y + c5
v = --- = ------------------
r c6*x + c7*y + 1
c8 = Sign of 'r', or the denominator affine, for the actual image.
This determines what part of the distorted image is 'ground'
side of the horizon, the other part is 'sky' or invalid.
Input Arguments are pairs of distorted coodinates (minimum 4 pairs)
Which will be used to generate the coefficients of the above.
u1,v1, x1,y1, u2,v2, x2,y2, u3,v3, x3,y3, u4,v4, x4,y4 ...
*/
if (number_arguments != 16) { /* to be removed */
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"InvalidArgument","%s : '%s'","distort Bilinear",
"Needs 16 numbers");
return((Image *) NULL);
}
if (number_arguments%4 != 0) {
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"InvalidArgument","%s : '%s'","distort Bilinear",
"Requires pairs of coords (4 numbers U,V,X,Y)");
return((Image *) NULL);
}
if (number_arguments < 16) {
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"InvalidArgument","%s : '%s'","distort Bilinear",
"Minimum of 4 pairs of coords needed (16 numbers)");
return((Image *) NULL);
}
points=(PointInfo *) AcquireQuantumMemory((number_arguments+1UL)/2UL,
sizeof(*points));
if (points == (PointInfo *) NULL)
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
for (i=0; i < (long) number_arguments; i++)
if ((i % 2 ) == 0)
points[i/2].x=arguments[i];
else
points[i/2].y=arguments[i];
matrix = AcquireMagickMatrix(8UL,8UL);
if (matrix == (double **) NULL)
{
points=(PointInfo *) RelinquishMagickMemory(points);
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
}
status=SolvePerspectiveDistortion(8UL,points,matrix,coefficients);
matrix = RelinquishMagickMatrix(matrix, 8UL);
points = (PointInfo *) RelinquishMagickMemory(points);
if ( status == MagickFalse ) {
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"InvalidArgument","%s : '%s'","distort Prespective",
"Degenerate Result");
return((Image *) NULL);
}
/*
What is the 'ground' of the perspective distortion.
Just find the sign of denomitor affine for any image coordinate.
This is a 9'th coefficient!
*/
coefficients[8] = coefficients[6]*arguments[number_arguments-2]
+ coefficients[7]*arguments[number_arguments-1] + 1.0;
coefficients[8] = (coefficients[8] < 0.0) ? -1.0 : +1.0;
break;
}
case PerspectiveProjectionDistortion:
{
/*
Arguments: Perspective Coefficents (forward mapping)
*/
if (number_arguments != 8) {
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"InvalidArgument","%s : '%s'",
"distort PerspectiveProjection", "Needs 8 numbers");
return((Image *) NULL);
}
InvertPerspectiveCoefficients(arguments, coefficients);
/*
What is the 'ground' of the perspective distortion? For a forward
mapped perspective the images 0,0 coord will map to c2,c5 in the
distorted image, so get the sign of denominator of that.
This is a 9'th coefficient!
*/
coefficients[8] = coefficients[6]*arguments[2]
+ coefficients[7]*arguments[5] + 1.0;
coefficients[8] = (coefficients[8] < 0.0) ? -1.0 : +1.0;
break;
}
case ScaleRotateTranslateDistortion:
{
double
cosine, sine,
x,y,sx,sy,a,nx,ny;
/*
Argument options, by number of arguments given:
7: x,y, sx,sy, a, nx,ny
6: x,y, s, a, nx,ny
5: x,y, sx,sy, a
4: x,y, s, a
3: x,y, a
2: s, a
1: a
Where actions are (in order of application)
x,y 'center' of transforms (default = image center)
sx,sy scale image by this amount (default = 1)
a angle of rotation (argument required)
nx,ny move 'center' here (default = no movement)
And convert to affine mapping coefficients
*/
x = nx = (double)image->columns/2.0;
y = ny = (double)image->rows/2.0;
if ( bestfit ) {
x = nx += (double)image->page.x;
y = ny += (double)image->page.y;
}
sx = sy = 1.0;
switch ( number_arguments ) {
case 0:
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"InvalidArgument","%s : '%s'",
"distort ScaleTranslateRotate",
"Needs at least 1 argument");
return((Image *) NULL);
case 1:
a = arguments[0];
break;
case 2:
sx = sy = arguments[0];
a = arguments[1];
break;
default:
x = nx = arguments[0];
y = ny = arguments[1];
switch ( number_arguments ) {
case 3:
a = arguments[2];
break;
case 4:
sx = sy = arguments[2];
a = arguments[3];
break;
case 5:
sx = arguments[2];
sy = arguments[3];
a = arguments[4];
break;
case 6:
sx = sy = arguments[2];
a = arguments[3];
nx = arguments[4];
ny = arguments[5];
break;
case 7:
sx = arguments[2];
sy = arguments[3];
a = arguments[4];
nx = arguments[5];
ny = arguments[6];
break;
default:
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"InvalidArgument","%s : '%s'",
"distort ScaleTranslateRotate",
"Too Many Arguments (7 or less)");
return((Image *) NULL);
}
break;
}
a=DegreesToRadians(a);
cosine=cos(a);
sine=sin(a);
coefficients[0]=cosine/sx;
coefficients[1]=(-sine)/sy;
coefficients[2]=sine/sx;
coefficients[3]=cosine/sy;
coefficients[4]=x-nx*coefficients[0]-ny*coefficients[2];
coefficients[5]=y-nx*coefficients[1]-ny*coefficients[3];
break;
}
case ArcDistortion:
{
/* Arc Distortion
Args: arc_width rotate top_edge_radius bottom_edge_radius
All but first argument are optional
arc_width The angle over which to arc the image side-to-side
rotate Angle to rotate image from vertical center
top_radius Set top edge of source image at this radius
bottom_radius Set bootom edge to this radius (radial scaling)
By default, if the radii arguments are nor provided the image radius
is calculated so the horizontal center-line is fits the given arc
without scaling.
The output image size is ALWAYS adjusted to contain the whole image,
and an offset is given to position image relative to the 0,0 point of
the origin, allowing users to use relative positioning onto larger
background (via -flatten).
The arguments are converted to these coefficents
c0: angle for center of source image
c1: angle scale for mapping to source image
c2: radius for top of source image
c3: radius scale for mapping source image
c4: centerline of arc within source image
Note the coefficents use a center angle, so asymptotic join is
furthest from both sides of the source image. This also means that
for arc angles greater than 360 the sides of the image will be
trimmed equally.
*/
if ( number_arguments >= 1 && arguments[0] < MagickEpsilon ) {
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"InvalidArgument","%s : '%s'", "distort Arc",
"Arc Angle Too Small");
return((Image *) NULL);
}
if ( number_arguments >= 3 && arguments[2] < MagickEpsilon ) {
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"InvalidArgument","%s : '%s'", "distort Arc",
"Outer Radius Too Small");
return((Image *) NULL);
}
coefficients[0] = -MagickPI/2.0;
if ( number_arguments >= 1 )
coefficients[1] = DegreesToRadians(arguments[0]);
else
coefficients[1] = MagickPI/2.0;
if ( number_arguments >= 2 )
coefficients[0] += DegreesToRadians(arguments[1]);
coefficients[0] -= MagickRound(coefficients[0]/(2.0*MagickPI))
*2.0*MagickPI;
coefficients[3] = 1.0*image->rows-1;
coefficients[2] = 1.0*image->columns/coefficients[1] + coefficients[3]/2.0;
if ( number_arguments >= 3 ) {
if ( number_arguments >= 4 )
coefficients[3] = arguments[2] - arguments[3];
else
coefficients[3] *= arguments[2]/coefficients[2];
coefficients[2] = arguments[2];
}
coefficients[4] = (1.0*image->columns-1.0)/2.0;
/* Always work out the 'best fit' for Arc Distort (required) */
bestfit = MagickTrue;
break;
}
default:
break;
}
/*
Determine the size and offset for a 'bestfit' destination.
Usally the four corners of the source image is enough.
*/
/* default output image bounds, when no 'bestfit' is requested */
geometry.width=image->columns;
geometry.height=image->rows;
geometry.x=0;
geometry.y=0;
point.x=0.0;
point.y=0.0;
if ( bestfit ) {
double
min_x,max_x,min_y,max_y;
/* defines to figure out the bounds of the distorted image */
#define InitalBounds(px,py) \
{ \
min_x = max_x = (px); \
min_y = max_y = (py); \
}
#define ExpandBounds(px,py) \
{ \
if ( (px) < min_x ) min_x = (px); \
if ( (px) > max_x ) max_x = (px); \
if ( (py) < min_y ) min_y = (py); \
if ( (py) > max_y ) max_y = (py); \
}
switch (method)
{
case AffineDistortion:
case AffineProjectionDistortion:
case ScaleRotateTranslateDistortion:
{ double inverse[6];
InvertAffineCoefficients(coefficients, inverse);
x = image->page.x; y = image->page.y;
point.x=inverse[0]*x+inverse[2]*y+inverse[4];
point.y=inverse[1]*x+inverse[3]*y+inverse[5];
InitalBounds( point.x, point.y );
x = image->page.x+image->columns-1; y = image->page.y;
point.x=inverse[0]*x+inverse[2]*y+inverse[4];
point.y=inverse[1]*x+inverse[3]*y+inverse[5];
ExpandBounds( point.x, point.y );
x = image->page.x; y = image->page.y+image->rows-1;
point.x=inverse[0]*x+inverse[2]*y+inverse[4];
point.y=inverse[1]*x+inverse[3]*y+inverse[5];
ExpandBounds( point.x, point.y );
x = image->page.x+image->columns-1;
y = image->page.y+image->rows-1;
point.x=inverse[0]*x+inverse[2]*y+inverse[4];
point.y=inverse[1]*x+inverse[3]*y+inverse[5];
ExpandBounds( point.x, point.y );
break;
}
case PerspectiveDistortion:
case PerspectiveProjectionDistortion:
{ double inverse[8], scale;
InvertPerspectiveCoefficients(coefficients, inverse);
x = image->page.x; y = image->page.y;
scale=inverse[6]*x+inverse[7]*y+1.0;
scale=1.0/( (fabs(scale) <= MagickEpsilon) ? 1.0 : scale );
point.x=scale*(inverse[0]*x+inverse[1]*y+inverse[2]);
point.y=scale*(inverse[3]*x+inverse[4]*y+inverse[5]);
InitalBounds( point.x, point.y );
x = image->page.x+image->columns-1; y = image->page.y;
scale=inverse[6]*x+inverse[7]*y+1.0;
scale=1.0/( (fabs(scale) <= MagickEpsilon) ? 1.0 : scale );
point.x=scale*(inverse[0]*x+inverse[1]*y+inverse[2]);
point.y=scale*(inverse[3]*x+inverse[4]*y+inverse[5]);
ExpandBounds( point.x, point.y );
x = image->page.x; y = image->page.y+image->rows-1;
scale=inverse[6]*x+inverse[7]*y+1.0;
scale=1.0/( (fabs(scale) <= MagickEpsilon) ? 1.0 : scale );
point.x=scale*(inverse[0]*x+inverse[1]*y+inverse[2]);
point.y=scale*(inverse[3]*x+inverse[4]*y+inverse[5]);
ExpandBounds( point.x, point.y );
x = image->page.x+image->columns-1;
y = image->page.y+image->rows-1;
scale=inverse[6]*x+inverse[7]*y+1.0;
scale=1.0/( (fabs(scale) <= MagickEpsilon) ? 1.0 : scale );
point.x=scale*(inverse[0]*x+inverse[1]*y+inverse[2]);
point.y=scale*(inverse[3]*x+inverse[4]*y+inverse[5]);
ExpandBounds( point.x, point.y );
break;
}
case ArcDistortion:
{ double a, ca, sa;
/* Forward Map Corners */
a = coefficients[0]-coefficients[1]/2; ca = cos(a); sa = sin(a);
point.x = coefficients[2]*ca;
point.y = coefficients[2]*sa;
InitalBounds( point.x, point.y );
point.x = (coefficients[2]-coefficients[3])*ca;
point.y = (coefficients[2]-coefficients[3])*sa;
ExpandBounds( point.x, point.y );
a = coefficients[0]+coefficients[1]/2; ca = cos(a); sa = sin(a);
point.x = coefficients[2]*ca;
point.y = coefficients[2]*sa;
ExpandBounds( point.x, point.y );
point.x = (coefficients[2]-coefficients[3])*ca;
point.y = (coefficients[2]-coefficients[3])*sa;
ExpandBounds( point.x, point.y );
/* orthogonal points along top of arc */
for( a=ceil((coefficients[0]-coefficients[1]/2.0)*2.0/MagickPI)
*MagickPI/2.0;
a<(coefficients[0]+coefficients[1]/2.0); a+=MagickPI/2.0 ) {
ca = cos(a); sa = sin(a);
point.x = coefficients[2]*ca;
point.y = coefficients[2]*sa;
ExpandBounds( point.x, point.y );
}
/*
Convert the angle_to_width and radius_to_height
to appropriate scaling factors, to allow faster processing
in the mapping function.
*/
coefficients[1] = 2.0*MagickPI*image->columns/coefficients[1];
coefficients[3] = 1.0*image->rows/coefficients[3];
break;
}
case BilinearDistortion:
default:
/* no bestfit available for this distortion YET */
bestfit = MagickFalse;
}
/* Set the output image geometry to the 'bestfit' of the image */
if ( bestfit ) {
geometry.x=(long) floor(min_x-MagickEpsilon);
geometry.y=(long) floor(min_y-MagickEpsilon);
geometry.width=(unsigned long) ceil(max_x-geometry.x+1+MagickEpsilon);
geometry.height=(unsigned long) ceil(max_y-geometry.y+1+MagickEpsilon);
}
}
/* User provided override of the output geometry */
property=GetImageArtifact(image,"distort:viewport");
if (property != (const char *) NULL)
(void) ParseAbsoluteGeometry(property, &geometry);
/*
Initialize the distort image attributes.
*/
distort_image=CloneImage(image,geometry.width,geometry.height,MagickTrue,
exception);
if (distort_image == (Image *) NULL)
return((Image *) NULL);
if (SetImageStorageClass(distort_image,DirectClass) == MagickFalse)
{
InheritException(exception,&distort_image->exception);
distort_image=DestroyImage(distort_image);
return((Image *) NULL);
}
distort_image->page.x=geometry.x;
distort_image->page.y=geometry.y;
if (distort_image->background_color.opacity != OpaqueOpacity)
distort_image->matte=MagickTrue;
/* Open Image views as needed. */
resample_filter=AcquireResampleFilter(image,exception);
GetMagickPixelPacket(distort_image,&pixel);
distort_view=OpenCacheView(distort_image);
/* Define constant scaling vectors for Affine Distortions */
switch (method)
{
case AffineDistortion:
case AffineProjectionDistortion:
case ScaleRotateTranslateDistortion:
ScaleResampleFilter( resample_filter,
coefficients[0], coefficients[2],
coefficients[1], coefficients[3] );
break;
default:
break;
}
/* Initialize default pixel validity
* negative: pixel is invalid output 'matte_color'
* 0.0 to 1.0: antialiased, mix with resample output
* 1.0 or greater: use resampled output.
*/
validity = 1.0;
GetMagickPixelPacket(distort_image,&invalid);
SetMagickPixelPacket(distort_image, &distort_image->matte_color,
(IndexPacket *) NULL, &invalid);
if (distort_image->colorspace == CMYKColorspace)
ConvertRGBToCMYK(&invalid); /* what about other color spaces? */
/* Sample the source image to each pixel in the distort image. */
for (j=0; j < (long) distort_image->rows; j++)
{
q=SetCacheView(distort_view,0,j,distort_image->columns,1);
if (q == (PixelPacket *) NULL)
break;
indexes=GetCacheViewIndexes(distort_view);
y = j+geometry.y;
for (i=0; i < (long) distort_image->columns; i++)
{
x = i+geometry.x;
switch (method)
{
case AffineDistortion:
case AffineProjectionDistortion:
case ScaleRotateTranslateDistortion:
{
point.x=coefficients[0]*x+coefficients[2]*y+coefficients[4];
point.y=coefficients[1]*x+coefficients[3]*y+coefficients[5];
/* Affine partical derivitives are constant -- set above */
break;
}
case BilinearDistortion:
{
point.x=coefficients[0]*x+coefficients[1]*y+coefficients[2]*x*y+
coefficients[3];
point.y=coefficients[4]*x+coefficients[5]*y+coefficients[6]*x*y+
coefficients[7];
/* Bilinear partical derivitives of scaling vectors */
ScaleResampleFilter( resample_filter,
coefficients[0] + coefficients[2]*y,
coefficients[1] + coefficients[2]*x,
coefficients[4] + coefficients[6]*y,
coefficients[5] + coefficients[6]*x );
break;
}
case PerspectiveDistortion:
case PerspectiveProjectionDistortion:
{
double
p,q,r,abs_r,abs_c6,abs_c7,scale;
/* perspective is a ratio of affines */
p=coefficients[0]*x+coefficients[1]*y+coefficients[2];
q=coefficients[3]*x+coefficients[4]*y+coefficients[5];
r=coefficients[6]*x+coefficients[7]*y+1.0;
/* Pixel Validity -- is it a 'sky' or 'ground' pixel */
validity = (r*coefficients[8] < 0.0) ? 0.0 : 1.0;
/* Determine horizon anti-aliase blending */
abs_r = fabs(r)*2;
abs_c6 = fabs(coefficients[6]);
abs_c7 = fabs(coefficients[7]);
if ( abs_c6 > abs_c7 ) {
if ( abs_r < abs_c6 )
validity = 0.5 - coefficients[8]*r/coefficients[6];
}
else if ( abs_r < abs_c7 )
validity = .5 - coefficients[8]*r/coefficients[7];
/* Perspective Sampling Point (if valid) */
if ( validity > 0.0 ) {
scale = 1.0/r;
point.x = p*scale;
point.y = q*scale;
/* Perspective Partial Derivatives or Scaling Vectors */
scale *= scale;
ScaleResampleFilter( resample_filter,
(r*coefficients[0] - p*coefficients[6])*scale,
(r*coefficients[1] - p*coefficients[7])*scale,
(r*coefficients[3] - q*coefficients[6])*scale,
(r*coefficients[4] - q*coefficients[7])*scale );
}
break;
}
case ArcDistortion:
{
double radius = sqrt((double) x*x+y*y);
point.x = (atan2((double)y,(double)x) - coefficients[0])/(2*MagickPI);
point.x -= MagickRound(point.x);
point.x = point.x*coefficients[1] + coefficients[4];
point.y = (coefficients[2] - radius) * coefficients[3];
/* Polar Distortion Partial Derivatives or Scaling Vectors
We give the deritives of du/dr, dv/dr and du/da, dv/da
rather than provide the complex du/dx,dv/dx and du/dy,dv/dy.
The result will be the same, but it is simplier to calculate.
*/
if ( radius > MagickEpsilon )
ScaleResampleFilter( resample_filter,
coefficients[1]/(2*MagickPI) / radius, 0, 0, coefficients[3] );
else
ScaleResampleFilter( resample_filter,
MagickHuge, 0, 0, coefficients[3] );
break;
}
default:
{
/*
Noop distortion (failsafe).
*/
point.x=(double) i;
point.y=(double) j;
break;
}
}
if ( bestfit && method != ArcDistortion ) {
point.x -= image->page.x;
point.y -= image->page.y;
}
if ( validity <= 0.0 ) {
/* result of distortion is an invalid pixel - don't resample */
SetPixelPacket(distort_image,&invalid,q,indexes);
}
else {
/* resample the source image to find its correct color */
pixel=ResamplePixelColor(resample_filter,point.x,point.y);
/* if validity between 0.0 and 1.0 mix result with invalid pixel */
if ( validity < 1.0 ) {
/* Do a blend of sample color and invalid pixel */
/* should this be a 'Blend', or an 'Over' compose */
MagickPixelCompositeBlend(&pixel, validity,
&invalid, (1.0-validity), &pixel);
}
SetPixelPacket(distort_image,&pixel,q,indexes);
}
q++;
indexes++;
}
if (SyncImagePixels(distort_image) == MagickFalse)
break;
if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
(QuantumTick(y,image->rows) != MagickFalse))
{
status=image->progress_monitor(DistortImageTag,y,image->rows,
image->client_data);
if (status == MagickFalse)
break;
}
}
distort_view=CloseCacheView(distort_view);
resample_filter=DestroyResampleFilter(resample_filter);
/* Arc does not return an offset unless 'bestfit' is in effect */
if ( method == ArcDistortion && !bestfit &&
property==(const char *)NULL ) {
distort_image->page.x = 0;
distort_image->page.y = 0;
}
return(distort_image);
}
MagickExport Image *CompareImageChannels(Image *image,
const Image *reconstruct_image,const ChannelType channel,
const MetricType metric,double *distortion,ExceptionInfo *exception)
{
Image
*difference_image;
long
y;
MagickPixelPacket
composite,
red,
source,
white;
MagickStatusType
difference;
register const IndexPacket
*indexes,
*reconstruct_indexes;
register const PixelPacket
*p,
*q;
register IndexPacket
*difference_indexes;
register long
x;
register PixelPacket
*r;
ViewInfo
*difference_view,
*image_view,
*reconstruct_view;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(reconstruct_image != (const Image *) NULL);
assert(reconstruct_image->signature == MagickSignature);
assert(distortion != (double *) NULL);
*distortion=0.0;
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
if ((reconstruct_image->columns != image->columns) ||
(reconstruct_image->rows != image->rows))
ThrowImageException(ImageError,"ImageSizeDiffers");
difference_image=CloneImage(image,image->columns,image->rows,MagickTrue,
exception);
if (difference_image == (Image *) NULL)
return((Image *) NULL);
if (SetImageStorageClass(difference_image,DirectClass) == MagickFalse)
{
InheritException(exception,&difference_image->exception);
difference_image=DestroyImage(difference_image);
return((Image *) NULL);
}
(void) QueryMagickColor("#f1001e",&red,exception);
(void) QueryMagickColor("#ffffff",&white,exception);
if (difference_image->colorspace == CMYKColorspace)
{
ConvertRGBToCMYK(&red);
ConvertRGBToCMYK(&white);
}
/*
Generate difference image.
*/
GetMagickPixelPacket(reconstruct_image,&source);
GetMagickPixelPacket(difference_image,&composite);
image_view=OpenCacheView(image);
reconstruct_view=OpenCacheView(reconstruct_image);
difference_view=OpenCacheView(difference_image);
for (y=0; y < (long) image->rows; y++)
{
p=AcquireCacheViewPixels(image_view,0,y,image->columns,1,exception);
q=AcquireCacheViewPixels(reconstruct_view,0,y,reconstruct_image->columns,1,
exception);
r=SetCacheView(difference_view,0,y,difference_image->columns,1);
if ((p == (const PixelPacket *) NULL) ||
(q == (const PixelPacket *) NULL) || (r == (PixelPacket *) NULL))
break;
indexes=AcquireCacheViewIndexes(image_view);
reconstruct_indexes=AcquireCacheViewIndexes(reconstruct_view);
difference_indexes=GetCacheViewIndexes(difference_view);
for (x=0; x < (long) image->columns; x++)
{
difference=MagickFalse;
if ((channel & RedChannel) != 0)
if (p->red != q->red)
difference=MagickTrue;
if ((channel & GreenChannel) != 0)
if (p->green != q->green)
difference=MagickTrue;
if ((channel & BlueChannel) != 0)
if (p->blue != q->blue)
difference=MagickTrue;
if ((channel & OpacityChannel) != 0)
if (p->opacity != q->opacity)
difference=MagickTrue;
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace) &&
(reconstruct_image->colorspace == CMYKColorspace))
if (indexes[x] != reconstruct_indexes[x])
difference=MagickTrue;
SetMagickPixelPacket(reconstruct_image,q,reconstruct_indexes+x,&source);
if (difference != MagickFalse)
MagickPixelCompositeOver(&source,7.5*QuantumRange/10.0,&red,
(MagickRealType) red.opacity,&composite);
else
MagickPixelCompositeOver(&source,7.5*QuantumRange/10.0,&white,
(MagickRealType) white.opacity,&composite);
SetPixelPacket(difference_image,&composite,r,difference_indexes+x);
p++;
q++;
r++;
}
if (SyncCacheView(difference_view) == MagickFalse)
break;
}
difference_view=CloseCacheView(difference_view);
reconstruct_view=CloseCacheView(reconstruct_view);
image_view=CloseCacheView(image_view);
(void) GetImageChannelDistortion(image,reconstruct_image,channel,metric,
distortion,exception);
return(difference_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% P a i n t F l o o d f i l l I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% PaintFloodfill() changes the color value of any pixel that matches
% target and is an immediate neighbor. If the method FillToBorderMethod is
% specified, the color value is changed for any neighbor pixel that does not
% match the bordercolor member of image.
%
% By default target must match a particular pixel color exactly.
% However, in many cases two colors may differ by a small amount. The
% fuzz member of image defines how much tolerance is acceptable to
% consider two colors as the same. For example, set fuzz to 10 and the
% color red at intensities of 100 and 102 respectively are now
% interpreted as the same color for the purposes of the floodfill.
%
% The format of the PaintFloodfillImage method is:
%
% MagickBooleanType PaintFloodfillImage(Image *image,
% const ChannelType channel,const MagickPixelPacket target,
% const long x_offset,const long y_offset,const DrawInfo *draw_info,
% const PaintMethod method)
%
% A description of each parameter follows:
%
% o image: The image.
%
% o channel: The channel(s).
%
% o target: The RGB value of the target color.
%
% o x_offset,y_offset: The starting location of the operation.
%
% o draw_info: The draw info.
%
% o method: Choose either FloodfillMethod or FillToBorderMethod.
%
*/
MagickExport MagickBooleanType PaintFloodfillImage(Image *image,
const ChannelType channel,const MagickPixelPacket *target,
const long x_offset,const long y_offset,const DrawInfo *draw_info,
const PaintMethod method)
{
#define MaxStacksize (1UL << 15)
#define PushSegmentStack(up,left,right,delta) \
{ \
if (s >= (segment_stack+MaxStacksize)) \
ThrowBinaryException(DrawError,"SegmentStackOverflow",image->filename) \
else \
{ \
if ((((up)+(delta)) >= 0) && (((up)+(delta)) < (long) image->rows)) \
{ \
s->x1=(double) (left); \
s->y1=(double) (up); \
s->x2=(double) (right); \
s->y2=(double) (delta); \
s++; \
} \
} \
}
Image
*floodplane_image;
long
offset,
start,
x1,
x2,
y;
MagickBooleanType
skip;
MagickPixelPacket
fill,
pixel;
PixelPacket
fill_color;
register const PixelPacket
*p;
register IndexPacket
*indexes;
register long
x;
register PixelPacket
*q;
register SegmentInfo
*s;
SegmentInfo
*segment_stack;
/*
Check boundary conditions.
*/
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(draw_info != (DrawInfo *) NULL);
assert(draw_info->signature == MagickSignature);
if ((x_offset < 0) || (x_offset >= (long) image->columns))
return(MagickFalse);
if ((y_offset < 0) || (y_offset >= (long) image->rows))
return(MagickFalse);
if (SetImageStorageClass(image,DirectClass) == MagickFalse)
return(MagickFalse);
if (image->matte == MagickFalse)
(void) SetImageOpacity(image,OpaqueOpacity);
/*
Set floodfill state.
*/
floodplane_image=CloneImage(image,image->columns,image->rows,MagickTrue,
&image->exception);
if (floodplane_image == (Image *) NULL)
return(MagickFalse);
(void) SetImageOpacity(floodplane_image,OpaqueOpacity);
segment_stack=(SegmentInfo *) AcquireQuantumMemory(MaxStacksize,
sizeof(*segment_stack));
if (segment_stack == (SegmentInfo *) NULL)
{
floodplane_image=DestroyImage(floodplane_image);
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
}
/*
Push initial segment on stack.
*/
x=x_offset;
y=y_offset;
start=0;
s=segment_stack;
PushSegmentStack(y,x,x,1);
PushSegmentStack(y+1,x,x,-1);
GetMagickPixelPacket(image,&fill);
GetMagickPixelPacket(image,&pixel);
while (s > segment_stack)
{
/*
Pop segment off stack.
*/
s--;
x1=(long) s->x1;
x2=(long) s->x2;
offset=(long) s->y2;
y=(long) s->y1+offset;
/*
Recolor neighboring pixels.
*/
p=AcquireImagePixels(image,0,y,(unsigned long) (x1+1),1,&image->exception);
q=GetImagePixels(floodplane_image,0,y,(unsigned long) (x1+1),1);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
break;
indexes=GetIndexes(image);
p+=x1;
q+=x1;
for (x=x1; x >= 0; x--)
{
if (q->opacity == (Quantum) TransparentOpacity)
break;
SetMagickPixelPacket(image,p,indexes+x,&pixel);
if (method == FloodfillMethod)
{
if (IsMagickColorSimilar(&pixel,target) == MagickFalse)
break;
}
else
if (IsMagickColorSimilar(&pixel,target) != MagickFalse)
break;
q->opacity=(Quantum) TransparentOpacity;
p--;
q--;
}
if (SyncImagePixels(floodplane_image) == MagickFalse)
break;
skip=x >= x1 ? MagickTrue : MagickFalse;
if (skip == MagickFalse)
{
start=x+1;
if (start < x1)
PushSegmentStack(y,start,x1-1,-offset);
x=x1+1;
}
do
{
if (skip == MagickFalse)
{
if (x < (long) image->columns)
{
p=AcquireImagePixels(image,x,y,image->columns-x,1,
&image->exception);
q=GetImagePixels(floodplane_image,x,y,image->columns-x,1);
if ((p == (const PixelPacket *) NULL) ||
(q == (PixelPacket *) NULL))
break;
indexes=GetIndexes(image);
for ( ; x < (long) image->columns; x++)
{
if (q->opacity == (Quantum) TransparentOpacity)
break;
SetMagickPixelPacket(image,p,indexes+x,&pixel);
if (method == FloodfillMethod)
{
if (IsMagickColorSimilar(&pixel,target) == MagickFalse)
break;
}
else
if (IsMagickColorSimilar(&pixel,target) != MagickFalse)
break;
q->opacity=(Quantum) TransparentOpacity;
p++;
q++;
}
if (SyncImagePixels(floodplane_image) == MagickFalse)
break;
}
PushSegmentStack(y,start,x-1,offset);
if (x > (x2+1))
PushSegmentStack(y,x2+1,x-1,-offset);
}
skip=MagickFalse;
x++;
if (x <= x2)
{
p=AcquireImagePixels(image,x,y,(unsigned long) (x2-x+1),1,
&image->exception);
q=GetImagePixels(floodplane_image,x,y,(unsigned long) (x2-x+1),1);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
break;
indexes=GetIndexes(image);
for ( ; x <= x2; x++)
{
if (q->opacity == (Quantum) TransparentOpacity)
break;
SetMagickPixelPacket(image,p,indexes+x,&pixel);
if (method == FloodfillMethod)
{
if (IsMagickColorSimilar(&pixel,target) != MagickFalse)
break;
}
else
if (IsMagickColorSimilar(&pixel,target) == MagickFalse)
break;
p++;
q++;
}
}
start=x;
} while (x <= x2);
}
for (y=0; y < (long) image->rows; y++)
{
/*
Tile fill color onto floodplane.
*/
p=AcquireImagePixels(floodplane_image,0,y,image->columns,1,
&image->exception);
q=GetImagePixels(image,0,y,image->columns,1);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
break;
indexes=GetIndexes(image);
for (x=0; x < (long) image->columns; x++)
{
if (p->opacity != OpaqueOpacity)
{
fill_color=GetFillColor(draw_info,x,y);
SetMagickPixelPacket(image,&fill_color,(IndexPacket *) NULL,&fill);
if (image->colorspace == CMYKColorspace)
ConvertRGBToCMYK(&fill);
if ((channel & RedChannel) != 0)
q->red=RoundToQuantum(fill.red);
if ((channel & GreenChannel) != 0)
q->green=RoundToQuantum(fill.green);
if ((channel & BlueChannel) != 0)
q->blue=RoundToQuantum(fill.blue);
if ((channel & OpacityChannel) != 0)
q->opacity=RoundToQuantum(fill.opacity);
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
indexes[x]=RoundToQuantum(fill.index);
}
p++;
q++;
}
if (SyncImagePixels(image) == MagickFalse)
break;
}
segment_stack=(SegmentInfo *) RelinquishMagickMemory(segment_stack);
floodplane_image=DestroyImage(floodplane_image);
return(y == (long) image->rows ? MagickTrue : MagickFalse);
}
