% July 1992 %
% %
% %
-% Copyright 1999-2009 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2010 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
#include "magick/color-private.h"
#include "magick/colorspace-private.h"
#include "magick/composite.h"
+#include "magick/draw.h"
#include "magick/effect.h"
#include "magick/exception.h"
#include "magick/exception-private.h"
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% Chop() removes a region of an image and collapses the image to occupy the
-% removed portion.
+% ChopImage() removes a region of an image and collapses the image to occupy
+% the removed portion.
%
% The format of the ChopImage method is:
%
{
#define ChopImageTag "Chop/Image"
+ CacheView
+ *chop_view,
+ *image_view;
+
Image
*chop_image;
- long
+ ssize_t
j,
y;
MagickBooleanType
- proceed;
+ proceed,
+ status;
RectangleInfo
extent;
- register long
+ register ssize_t
i;
- CacheView
- *chop_view,
- *image_view;
-
/*
Check chop geometry.
*/
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
assert(chop_info != (RectangleInfo *) NULL);
- if (((chop_info->x+(long) chop_info->width) < 0) ||
- ((chop_info->y+(long) chop_info->height) < 0) ||
- (chop_info->x > (long) image->columns) ||
- (chop_info->y > (long) image->rows))
+ if (((chop_info->x+(ssize_t) chop_info->width) < 0) ||
+ ((chop_info->y+(ssize_t) chop_info->height) < 0) ||
+ (chop_info->x > (ssize_t) image->columns) ||
+ (chop_info->y > (ssize_t) image->rows))
ThrowImageException(OptionWarning,"GeometryDoesNotContainImage");
extent=(*chop_info);
- if ((extent.x+(long) extent.width) > (long) image->columns)
- extent.width=(unsigned long) ((long) image->columns-extent.x);
- if ((extent.y+(long) extent.height) > (long) image->rows)
- extent.height=(unsigned long) ((long) image->rows-extent.y);
+ if ((extent.x+(ssize_t) extent.width) > (ssize_t) image->columns)
+ extent.width=(size_t) ((ssize_t) image->columns-extent.x);
+ if ((extent.y+(ssize_t) extent.height) > (ssize_t) image->rows)
+ extent.height=(size_t) ((ssize_t) image->rows-extent.y);
if (extent.x < 0)
{
- extent.width-=(unsigned long) (-extent.x);
+ extent.width-=(size_t) (-extent.x);
extent.x=0;
}
if (extent.y < 0)
{
- extent.height-=(unsigned long) (-extent.y);
+ extent.height-=(size_t) (-extent.y);
extent.y=0;
}
chop_image=CloneImage(image,image->columns-extent.width,image->rows-
/*
Extract chop image.
*/
+ status=MagickTrue;
i=0;
j=0;
image_view=AcquireCacheView(image);
chop_view=AcquireCacheView(chop_image);
- for (y=0; y < (long) extent.y; y++)
+ for (y=0; y < (ssize_t) extent.y; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict chop_indexes,
- *__restrict indexes;
+ *restrict chop_indexes,
+ *restrict indexes;
- register long
+ register ssize_t
x;
register PixelPacket
- *__restrict q;
+ *restrict q;
+ if (status == MagickFalse)
+ continue;
p=GetCacheViewVirtualPixels(image_view,0,i++,image->columns,1,exception);
q=QueueCacheViewAuthenticPixels(chop_view,0,j++,chop_image->columns,1,
exception);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
- break;
+ {
+ status=MagickFalse;
+ continue;
+ }
indexes=GetCacheViewAuthenticIndexQueue(image_view);
chop_indexes=GetCacheViewAuthenticIndexQueue(chop_view);
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- if ((x < extent.x) || (x >= (long) (extent.x+extent.width)))
+ if ((x < extent.x) || (x >= (ssize_t) (extent.x+extent.width)))
{
*q=(*p);
if (indexes != (IndexPacket *) NULL)
p++;
}
if (SyncCacheViewAuthenticPixels(chop_view,exception) == MagickFalse)
- break;
- proceed=SetImageProgress(image,ChopImageTag,y,chop_image->rows);
+ status=MagickFalse;
+ proceed=SetImageProgress(image,ChopImageTag,(MagickOffsetType) y,
+ chop_image->rows);
if (proceed == MagickFalse)
- break;
+ status=MagickFalse;
}
/*
Extract chop image.
*/
- i+=extent.height;
- for (y=0; y < (long) (image->rows-(extent.y+extent.height)); y++)
+ i+=(ssize_t) extent.height;
+ for (y=0; y < (ssize_t) (image->rows-(extent.y+extent.height)); y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict chop_indexes,
- *__restrict indexes;
+ *restrict chop_indexes,
+ *restrict indexes;
- register long
+ register ssize_t
x;
register PixelPacket
- *__restrict q;
+ *restrict q;
+ if (status == MagickFalse)
+ continue;
p=GetCacheViewVirtualPixels(image_view,0,i++,image->columns,1,exception);
q=QueueCacheViewAuthenticPixels(chop_view,0,j++,chop_image->columns,1,
exception);
if ((p == (PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
- break;
+ {
+ status=MagickFalse;
+ continue;
+ }
indexes=GetCacheViewAuthenticIndexQueue(image_view);
chop_indexes=GetCacheViewAuthenticIndexQueue(chop_view);
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- if ((x < extent.x) || (x >= (long) (extent.x+extent.width)))
+ if ((x < extent.x) || (x >= (ssize_t) (extent.x+extent.width)))
{
*q=(*p);
if (indexes != (IndexPacket *) NULL)
p++;
}
if (SyncCacheViewAuthenticPixels(chop_view,exception) == MagickFalse)
- break;
- proceed=SetImageProgress(image,ChopImageTag,y,chop_image->rows);
+ status=MagickFalse;
+ proceed=SetImageProgress(image,ChopImageTag,(MagickOffsetType) y,
+ chop_image->rows);
if (proceed == MagickFalse)
- break;
+ status=MagickFalse;
}
chop_view=DestroyCacheView(chop_view);
image_view=DestroyCacheView(image_view);
*cmyk_image,
*cmyk_images;
- long
+ ssize_t
y;
- register long
+ register ssize_t
i;
/*
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
cmyk_images=NewImageList();
- for (i=0; i < (long) GetImageListLength(images); i+=4)
+ for (i=0; i < (ssize_t) GetImageListLength(images); i+=4)
{
cmyk_image=CloneImage(images,images->columns,images->rows,MagickTrue,
exception);
if (SetImageStorageClass(cmyk_image,DirectClass) == MagickFalse)
break;
(void) SetImageColorspace(cmyk_image,CMYKColorspace);
- for (y=0; y < (long) images->rows; y++)
+ for (y=0; y < (ssize_t) images->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
- register long
+ register ssize_t
x;
register PixelPacket
- *__restrict q;
+ *restrict q;
p=GetVirtualPixels(images,0,y,images->columns,1,exception);
q=QueueAuthenticPixels(cmyk_image,0,y,cmyk_image->columns,1,exception);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
break;
- for (x=0; x < (long) images->columns; x++)
+ for (x=0; x < (ssize_t) images->columns; x++)
{
q->red=(Quantum) (QuantumRange-PixelIntensityToQuantum(p));
p++;
images=GetNextImageInList(images);
if (images == (Image *) NULL)
break;
- for (y=0; y < (long) images->rows; y++)
+ for (y=0; y < (ssize_t) images->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
- register long
+ register ssize_t
x;
register PixelPacket
- *__restrict q;
+ *restrict q;
p=GetVirtualPixels(images,0,y,images->columns,1,exception);
q=GetAuthenticPixels(cmyk_image,0,y,cmyk_image->columns,1,exception);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
break;
- for (x=0; x < (long) images->columns; x++)
+ for (x=0; x < (ssize_t) images->columns; x++)
{
q->green=(Quantum) (QuantumRange-PixelIntensityToQuantum(p));
p++;
images=GetNextImageInList(images);
if (images == (Image *) NULL)
break;
- for (y=0; y < (long) images->rows; y++)
+ for (y=0; y < (ssize_t) images->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
- register long
+ register ssize_t
x;
register PixelPacket
- *__restrict q;
+ *restrict q;
p=GetVirtualPixels(images,0,y,images->columns,1,exception);
q=GetAuthenticPixels(cmyk_image,0,y,cmyk_image->columns,1,exception);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
break;
- for (x=0; x < (long) images->columns; x++)
+ for (x=0; x < (ssize_t) images->columns; x++)
{
q->blue=(Quantum) (QuantumRange-PixelIntensityToQuantum(p));
p++;
images=GetNextImageInList(images);
if (images == (Image *) NULL)
break;
- for (y=0; y < (long) images->rows; y++)
+ for (y=0; y < (ssize_t) images->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict indexes;
+ *restrict indexes;
- register long
+ register ssize_t
x;
register PixelPacket
- *__restrict q;
+ *restrict q;
p=GetVirtualPixels(images,0,y,images->columns,1,exception);
q=GetAuthenticPixels(cmyk_image,0,y,cmyk_image->columns,1,exception);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
break;
indexes=GetAuthenticIndexQueue(cmyk_image);
- for (x=0; x < (long) images->columns; x++)
+ for (x=0; x < (ssize_t) images->columns; x++)
{
indexes[x]=(IndexPacket) (QuantumRange-PixelIntensityToQuantum(p));
p++;
{
#define CropImageTag "Crop/Image"
+ CacheView
+ *crop_view,
+ *image_view;
+
Image
*crop_image;
- long
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
RectangleInfo
bounding_box,
page;
- CacheView
- *crop_view,
- *image_view;
+ ssize_t
+ y;
/*
Check crop geometry.
page.width=bounding_box.width;
if (page.height == 0)
page.height=bounding_box.height;
- if (((bounding_box.x-page.x) >= (long) page.width) ||
- ((bounding_box.y-page.y) >= (long) page.height) ||
- ((page.x-bounding_box.x) > (long) image->columns) ||
- ((page.y-bounding_box.y) > (long) image->rows))
+ if (((bounding_box.x-page.x) >= (ssize_t) page.width) ||
+ ((bounding_box.y-page.y) >= (ssize_t) page.height) ||
+ ((page.x-bounding_box.x) > (ssize_t) image->columns) ||
+ ((page.y-bounding_box.y) > (ssize_t) image->rows))
{
/*
Crop is not within virtual canvas, return 1 pixel transparent image.
if (page.y < 0)
page.y=0;
}
- if ((unsigned long) (page.x+page.width) > image->columns)
+ if ((size_t) (page.x+page.width) > image->columns)
page.width=image->columns-page.x;
- if (geometry->width != 0)
- if (page.width > geometry->width)
- page.width=geometry->width;
- if ((unsigned long) (page.y+page.height) > image->rows)
+ if ((geometry->width != 0) && (page.width > geometry->width))
+ page.width=geometry->width;
+ if ((size_t) (page.y+page.height) > image->rows)
page.height=image->rows-page.y;
- if (geometry->height != 0)
- if (page.height > geometry->height)
- page.height=geometry->height;
+ if ((geometry->height != 0) && (page.height > geometry->height))
+ page.height=geometry->height;
bounding_box.x+=page.x;
bounding_box.y+=page.y;
if ((page.width == 0) || (page.height == 0))
return((Image *) NULL);
crop_image->page.width=image->page.width;
crop_image->page.height=image->page.height;
- if (((long) (bounding_box.x+bounding_box.width) > (long) image->page.width) ||
- ((long) (bounding_box.y+bounding_box.height) > (long) image->page.height))
+ if (((ssize_t) (bounding_box.x+bounding_box.width) > (ssize_t) image->page.width) ||
+ ((ssize_t) (bounding_box.y+bounding_box.height) > (ssize_t) image->page.height))
{
crop_image->page.width=bounding_box.width;
crop_image->page.height=bounding_box.height;
progress=0;
image_view=AcquireCacheView(image);
crop_view=AcquireCacheView(crop_image);
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(progress,status)
#endif
- for (y=0; y < (long) crop_image->rows; y++)
+ for (y=0; y < (ssize_t) crop_image->rows; y++)
{
register const IndexPacket
- *__restrict indexes;
+ *restrict indexes;
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict crop_indexes;
+ *restrict crop_indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
if (status == MagickFalse)
continue;
status=MagickFalse;
continue;
}
- (void) CopyMagickMemory(q,p,(size_t) crop_image->columns*sizeof(*q));
indexes=GetCacheViewVirtualIndexQueue(image_view);
- if (indexes != (IndexPacket *) NULL)
- {
- crop_indexes=GetCacheViewAuthenticIndexQueue(crop_view);
- if (crop_indexes != (IndexPacket *) NULL)
- (void) CopyMagickMemory(crop_indexes,indexes,(size_t)
- crop_image->columns*sizeof(*crop_indexes));
- }
+ crop_indexes=GetCacheViewAuthenticIndexQueue(crop_view);
+ (void) CopyMagickMemory(q,p,(size_t) crop_image->columns*sizeof(*p));
+ if ((indexes != (IndexPacket *) NULL) &&
+ (crop_indexes != (IndexPacket *) NULL))
+ (void) CopyMagickMemory(crop_indexes,indexes,(size_t) crop_image->columns*
+ sizeof(*crop_indexes));
if (SyncCacheViewAuthenticPixels(crop_view,exception) == MagickFalse)
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
MagickBooleanType
proceed;
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp critical (MagickCore_CropImage)
#endif
proceed=SetImageProgress(image,CropImageTag,progress++,image->rows);
{
#define ExcerptImageTag "Excerpt/Image"
+ CacheView
+ *excerpt_view,
+ *image_view;
+
Image
*excerpt_image;
- long
- progress,
- y;
-
MagickBooleanType
status;
- CacheView
- *excerpt_view,
- *image_view;
+ MagickOffsetType
+ progress;
+
+ ssize_t
+ y;
/*
Allocate excerpt image.
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(progress,status)
#endif
- for (y=0; y < (long) excerpt_image->rows; y++)
+ for (y=0; y < (ssize_t) excerpt_image->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict excerpt_indexes,
- *__restrict indexes;
+ *restrict excerpt_indexes,
+ *restrict indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
if (status == MagickFalse)
continue;
{
#define FlipImageTag "Flip/Image"
+ CacheView
+ *flip_view,
+ *image_view;
+
Image
*flip_image;
- long
- progress,
- y;
-
MagickBooleanType
status;
- CacheView
- *flip_view,
- *image_view;
+ MagickOffsetType
+ progress;
+
+ ssize_t
+ y;
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(progress,status)
#endif
- for (y=0; y < (long) flip_image->rows; y++)
+ for (y=0; y < (ssize_t) flip_image->rows; y++)
{
register const IndexPacket
- *__restrict indexes;
+ *restrict indexes;
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict flip_indexes;
+ *restrict flip_indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
if (status == MagickFalse)
continue;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
- q=QueueCacheViewAuthenticPixels(flip_view,0,(long) (flip_image->rows-y-1),
- flip_image->columns,1,exception);
+ q=QueueCacheViewAuthenticPixels(flip_view,0,(ssize_t) (flip_image->rows-y-
+ 1),flip_image->columns,1,exception);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
{
status=MagickFalse;
MagickBooleanType
proceed;
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp critical (MagickCore_FlipImage)
#endif
proceed=SetImageProgress(image,FlipImageTag,progress++,image->rows);
{
#define FlopImageTag "Flop/Image"
+ CacheView
+ *flop_view,
+ *image_view;
+
Image
*flop_image;
- long
- progress,
- y;
-
MagickBooleanType
status;
- CacheView
- *flop_view,
- *image_view;
+ MagickOffsetType
+ progress;
+
+ ssize_t
+ y;
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(progress,status)
#endif
- for (y=0; y < (long) flop_image->rows; y++)
+ for (y=0; y < (ssize_t) flop_image->rows; y++)
{
register const IndexPacket
- *__restrict indexes;
+ *restrict indexes;
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict flop_indexes;
+ *restrict flop_indexes;
- register long
+ register ssize_t
x;
register PixelPacket
- *__restrict q;
+ *restrict q;
if (status == MagickFalse)
continue;
q+=flop_image->columns;
indexes=GetCacheViewVirtualIndexQueue(image_view);
flop_indexes=GetCacheViewAuthenticIndexQueue(flop_view);
- for (x=0; x < (long) flop_image->columns; x++)
+ for (x=0; x < (ssize_t) flop_image->columns; x++)
{
(*--q)=(*p++);
if ((indexes != (const IndexPacket *) NULL) &&
%
% The format of the RollImage method is:
%
-% Image *RollImage(const Image *image,const long x_offset,
-% const long y_offset,ExceptionInfo *exception)
+% Image *RollImage(const Image *image,const ssize_t x_offset,
+% const ssize_t y_offset,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
*/
static inline MagickBooleanType CopyImageRegion(Image *destination,
- const Image *source,const unsigned long columns,const unsigned long rows,
- const long sx,const long sy,const long dx,const long dy,
+ const Image *source,const size_t columns,const size_t rows,
+ const ssize_t sx,const ssize_t sy,const ssize_t dx,const ssize_t dy,
ExceptionInfo *exception)
{
- long
+ CacheView
+ *source_view,
+ *destination_view;
+
+ ssize_t
y;
MagickBooleanType
status;
- CacheView
- *source_view,
- *destination_view;
-
status=MagickTrue;
source_view=AcquireCacheView(source);
destination_view=AcquireCacheView(destination);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(status)
#endif
- for (y=0; y < (long) rows; y++)
+ for (y=0; y < (ssize_t) rows; y++)
{
MagickBooleanType
sync;
+ register const IndexPacket
+ *restrict indexes;
+
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict indexes,
- *__restrict destination_indexes;
-
- register long
- x;
+ *restrict destination_indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
/*
Transfer scanline.
status=MagickFalse;
continue;
}
- indexes=GetCacheViewAuthenticIndexQueue(source_view);
- for (x=0; x < (long) columns; x++)
- *q++=(*p++);
+ indexes=GetCacheViewVirtualIndexQueue(source_view);
+ (void) CopyMagickMemory(q,p,(size_t) columns*sizeof(*p));
if (indexes != (IndexPacket *) NULL)
{
destination_indexes=GetCacheViewAuthenticIndexQueue(destination_view);
- for (x=0; x < (long) columns; x++)
- destination_indexes[x]=indexes[x];
+ if (destination_indexes != (IndexPacket *) NULL)
+ (void) CopyMagickMemory(destination_indexes,indexes,(size_t)
+ columns*sizeof(*indexes));
}
sync=SyncCacheViewAuthenticPixels(destination_view,exception);
if (sync == MagickFalse)
return(status);
}
-MagickExport Image *RollImage(const Image *image,const long x_offset,
- const long y_offset,ExceptionInfo *exception)
+MagickExport Image *RollImage(const Image *image,const ssize_t x_offset,
+ const ssize_t y_offset,ExceptionInfo *exception)
{
#define RollImageTag "Roll/Image"
offset.x=x_offset;
offset.y=y_offset;
while (offset.x < 0)
- offset.x+=image->columns;
- while (offset.x >= (long) image->columns)
- offset.x-=image->columns;
+ offset.x+=(ssize_t) image->columns;
+ while (offset.x >= (ssize_t) image->columns)
+ offset.x-=(ssize_t) image->columns;
while (offset.y < 0)
- offset.y+=image->rows;
- while (offset.y >= (long) image->rows)
- offset.y-=image->rows;
+ offset.y+=(ssize_t) image->rows;
+ while (offset.y >= (ssize_t) image->rows)
+ offset.y-=(ssize_t) image->rows;
/*
Roll image.
*/
- status=CopyImageRegion(roll_image,image,(unsigned long) offset.x,
- (unsigned long) offset.y,(long) image->columns-offset.x,(long) image->rows-
+ status=CopyImageRegion(roll_image,image,(size_t) offset.x,
+ (size_t) offset.y,(ssize_t) image->columns-offset.x,(ssize_t) image->rows-
offset.y,0,0,exception);
(void) SetImageProgress(image,RollImageTag,0,3);
status|=CopyImageRegion(roll_image,image,image->columns-offset.x,
- (unsigned long) offset.y,0,(long) image->rows-offset.y,offset.x,0,
+ (size_t) offset.y,0,(ssize_t) image->rows-offset.y,offset.x,0,
exception);
(void) SetImageProgress(image,RollImageTag,1,3);
- status|=CopyImageRegion(roll_image,image,(unsigned long) offset.x,image->rows-
- offset.y,(long) image->columns-offset.x,0,0,offset.y,exception);
+ status|=CopyImageRegion(roll_image,image,(size_t) offset.x,image->rows-
+ offset.y,(ssize_t) image->columns-offset.x,0,0,offset.y,exception);
(void) SetImageProgress(image,RollImageTag,2,3);
status|=CopyImageRegion(roll_image,image,image->columns-offset.x,image->rows-
offset.y,0,0,offset.x,offset.y,exception);
SetGeometry(image,&geometry);
geometry.width-=2*shave_info->width;
geometry.height-=2*shave_info->height;
- geometry.x=(long) shave_info->width+image->page.x;
- geometry.y=(long) shave_info->height+image->page.y;
+ geometry.x=(ssize_t) shave_info->width+image->page.x;
+ geometry.y=(ssize_t) shave_info->height+image->page.y;
shave_image=CropImage(image,&geometry,exception);
if (shave_image == (Image *) NULL)
return((Image *) NULL);
shave_image->page.width-=2*shave_info->width;
shave_image->page.height-=2*shave_info->height;
- shave_image->page.x-=shave_info->width;
- shave_image->page.y-=shave_info->height;
+ shave_image->page.x-=(ssize_t) shave_info->width;
+ shave_image->page.y-=(ssize_t) shave_info->height;
return(shave_image);
}
\f
{
#define SpliceImageTag "Splice/Image"
+ CacheView
+ *image_view,
+ *splice_view;
+
Image
*splice_image;
- long
- progress,
- y;
-
MagickBooleanType
proceed,
status;
+ MagickOffsetType
+ progress;
+
RectangleInfo
splice_geometry;
- register long
+ register ssize_t
i;
- CacheView
- *image_view,
- *splice_view;
+ ssize_t
+ y;
/*
Allocate splice image.
break;
case NorthGravity:
{
- splice_geometry.x+=splice_geometry.width/2;
+ splice_geometry.x+=(ssize_t) splice_geometry.width/2;
break;
}
case NorthEastGravity:
{
- splice_geometry.x+=splice_geometry.width;
+ splice_geometry.x+=(ssize_t) splice_geometry.width;
break;
}
case WestGravity:
{
- splice_geometry.y+=splice_geometry.width/2;
+ splice_geometry.y+=(ssize_t) splice_geometry.width/2;
break;
}
case StaticGravity:
case CenterGravity:
{
- splice_geometry.x+=splice_geometry.width/2;
- splice_geometry.y+=splice_geometry.height/2;
+ splice_geometry.x+=(ssize_t) splice_geometry.width/2;
+ splice_geometry.y+=(ssize_t) splice_geometry.height/2;
break;
}
case EastGravity:
{
- splice_geometry.x+=splice_geometry.width;
- splice_geometry.y+=splice_geometry.height/2;
+ splice_geometry.x+=(ssize_t) splice_geometry.width;
+ splice_geometry.y+=(ssize_t) splice_geometry.height/2;
break;
}
case SouthWestGravity:
{
- splice_geometry.y+=splice_geometry.height;
+ splice_geometry.y+=(ssize_t) splice_geometry.height;
break;
}
case SouthGravity:
{
- splice_geometry.x+=splice_geometry.width/2;
- splice_geometry.y+=splice_geometry.height;
+ splice_geometry.x+=(ssize_t) splice_geometry.width/2;
+ splice_geometry.y+=(ssize_t) splice_geometry.height;
break;
}
case SouthEastGravity:
{
- splice_geometry.x+=splice_geometry.width;
- splice_geometry.y+=splice_geometry.height;
+ splice_geometry.x+=(ssize_t) splice_geometry.width;
+ splice_geometry.y+=(ssize_t) splice_geometry.height;
break;
}
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(progress,status)
#endif
- for (y=0; y < (long) splice_geometry.y; y++)
+ for (y=0; y < (ssize_t) splice_geometry.y; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict indexes,
- *__restrict splice_indexes;
+ *restrict indexes,
+ *restrict splice_indexes;
- register long
+ register ssize_t
x;
register PixelPacket
- *__restrict q;
+ *restrict q;
if (status == MagickFalse)
continue;
splice_indexes=GetCacheViewAuthenticIndexQueue(splice_view);
for (x=0; x < splice_geometry.x; x++)
{
- q->red=p->red;
- q->green=p->green;
- q->blue=p->blue;
- q->opacity=OpaqueOpacity;
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
- q->opacity=p->opacity;
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
if (image->colorspace == CMYKColorspace)
splice_indexes[x]=(*indexes++);
p++;
q++;
}
- for ( ; x < (long) (splice_geometry.x+splice_geometry.width); x++)
+ for ( ; x < (ssize_t) (splice_geometry.x+splice_geometry.width); x++)
q++;
- for ( ; x < (long) splice_image->columns; x++)
+ for ( ; x < (ssize_t) splice_image->columns; x++)
{
- q->red=p->red;
- q->green=p->green;
- q->blue=p->blue;
- q->opacity=OpaqueOpacity;
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
- q->opacity=p->opacity;
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
if (image->colorspace == CMYKColorspace)
splice_indexes[x]=(*indexes++);
p++;
}
if (SyncCacheViewAuthenticPixels(splice_view,exception) == MagickFalse)
status=MagickFalse;
- proceed=SetImageProgress(image,SpliceImageTag,y,splice_image->rows);
+ proceed=SetImageProgress(image,SpliceImageTag,(MagickOffsetType) y,
+ splice_image->rows);
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(progress,status)
#endif
- for (y=(long) (splice_geometry.y+splice_geometry.height);
- y < (long) splice_image->rows; y++)
+ for (y=(ssize_t) (splice_geometry.y+splice_geometry.height);
+ y < (ssize_t) splice_image->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict indexes,
- *__restrict splice_indexes;
+ *restrict indexes,
+ *restrict splice_indexes;
- register long
+ register ssize_t
x;
register PixelPacket
- *__restrict q;
+ *restrict q;
if (status == MagickFalse)
continue;
- p=GetCacheViewVirtualPixels(image_view,0,y-splice_geometry.height,
+ p=GetCacheViewVirtualPixels(image_view,0,y-(ssize_t) splice_geometry.height,
image->columns,1,exception);
q=QueueCacheViewAuthenticPixels(splice_view,0,y,splice_image->columns,1,
exception);
splice_indexes=GetCacheViewAuthenticIndexQueue(splice_view);
for (x=0; x < splice_geometry.x; x++)
{
- q->red=p->red;
- q->green=p->green;
- q->blue=p->blue;
- q->opacity=OpaqueOpacity;
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
- q->opacity=p->opacity;
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
if (image->colorspace == CMYKColorspace)
splice_indexes[x]=(*indexes++);
p++;
q++;
}
- for ( ; x < (long) (splice_geometry.x+splice_geometry.width); x++)
+ for ( ; x < (ssize_t) (splice_geometry.x+splice_geometry.width); x++)
q++;
- for ( ; x < (long) splice_image->columns; x++)
+ for ( ; x < (ssize_t) splice_image->columns; x++)
{
- q->red=p->red;
- q->green=p->green;
- q->blue=p->blue;
- q->opacity=OpaqueOpacity;
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
- q->opacity=p->opacity;
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
if (image->colorspace == CMYKColorspace)
splice_indexes[x]=(*indexes++);
p++;
% final size of the image.
%
*/
+static inline ssize_t MagickRound(MagickRealType x)
+{
+ /*
+ Round the fraction to nearest integer.
+ */
+ if (x >= 0.0)
+ return((ssize_t) (x+0.5));
+ return((ssize_t) (x-0.5));
+}
+
MagickExport MagickBooleanType TransformImage(Image **image,
const char *crop_geometry,const char *image_geometry)
{
Image
+ *next,
*resize_image,
*transform_image;
+ ssize_t
+ x,
+ y;
+
MagickStatusType
flags;
RectangleInfo
geometry;
+ size_t
+ height,
+ width;
+
assert(image != (Image **) NULL);
assert((*image)->signature == MagickSignature);
if ((*image)->debug != MagickFalse)
crop_image=NewImageList();
flags=ParseGravityGeometry(transform_image,crop_geometry,&geometry,
&(*image)->exception);
- if (((geometry.width == 0) && (geometry.height == 0)) ||
- ((flags & XValue) != 0) || ((flags & YValue) != 0))
+ if ((flags & AreaValue) != 0)
{
- crop_image=CropImage(transform_image,&geometry,&(*image)->exception);
- if ((crop_image != (Image *) NULL) && ((flags & AspectValue) != 0))
+ PointInfo
+ delta,
+ offset;
+
+ RectangleInfo
+ crop;
+
+ /*
+ Crop into NxM tiles (@ flag) - AT.
+ */
+ if (geometry.width == 0)
+ geometry.width=1;
+ if (geometry.height == 0)
+ geometry.height=1;
+ width=transform_image->columns;
+ height=transform_image->rows;
+ if ((flags & AspectValue) == 0)
{
- crop_image->page.width=geometry.width;
- crop_image->page.height=geometry.height;
- crop_image->page.x-=geometry.x;
- crop_image->page.y-=geometry.y;
+ width-=(geometry.x < 0 ? -1 : 1)*geometry.x;
+ height-=(geometry.y < 0 ? -1 : 1)*geometry.y;
}
- }
- else
- if ((transform_image->columns > geometry.width) ||
- (transform_image->rows > geometry.height))
- {
- Image
- *next;
-
- long
- y;
-
- register long
- x;
-
- unsigned long
- height,
- width;
-
- /*
- Crop repeatedly to create uniform scenes.
- */
- if (transform_image->page.width == 0)
- transform_image->page.width=transform_image->columns;
- if (transform_image->page.height == 0)
- transform_image->page.height=transform_image->rows;
- width=geometry.width;
- if (width == 0)
- width=transform_image->page.width;
- height=geometry.height;
- if (height == 0)
- height=transform_image->page.height;
- next=NewImageList();
- for (y=0; y < (long) transform_image->page.height; y+=height)
+ else
{
- for (x=0; x < (long) transform_image->page.width; x+=width)
+ width+=(geometry.x < 0 ? -1 : 1)*geometry.x;
+ height+=(geometry.y < 0 ? -1 : 1)*geometry.y;
+ }
+ delta.x=(double) width/geometry.width;
+ delta.y=(double) height/geometry.height;
+ next=NewImageList();
+ for (offset.y=0; offset.y < (double) height; )
+ {
+ if ((flags & AspectValue) == 0)
{
- geometry.width=width;
- geometry.height=height;
- geometry.x=x;
- geometry.y=y;
- next=CropImage(transform_image,&geometry,&(*image)->exception);
- if (next == (Image *) NULL)
- break;
- AppendImageToList(&crop_image,next);
+ crop.y=(ssize_t) MagickRound((MagickRealType) (offset.y-
+ (geometry.y > 0 ? 0 : geometry.y)));
+ offset.y+=delta.y;
+ crop.height=(size_t) MagickRound((MagickRealType)
+ (offset.y+(geometry.y < 0 ? 0 : geometry.y)));
}
+ else
+ {
+ crop.y=(ssize_t) MagickRound((MagickRealType) (offset.y-
+ (geometry.y > 0 ? geometry.y : 0)));
+ offset.y+=delta.y;
+ crop.height=(size_t) MagickRound((MagickRealType)
+ (offset.y+(geometry.y < 0 ? geometry.y : 0)));
+ }
+ crop.height-=crop.y;
+ crop.y+=transform_image->page.y;
+ for (offset.x=0; offset.x < (double) width; )
+ {
+ if ((flags & AspectValue) == 0)
+ {
+ crop.x=(ssize_t) MagickRound((MagickRealType) (offset.x-
+ (geometry.x > 0 ? 0 : geometry.x)));
+ offset.x+=+delta.x;
+ crop.width=(size_t) MagickRound((MagickRealType)
+ (offset.x+(geometry.x < 0 ? 0 : geometry.x)));
+ }
+ else
+ {
+ crop.x=(ssize_t) MagickRound((MagickRealType) (offset.x-
+ (geometry.x > 0 ? geometry.x : 0)));
+ offset.x+=+delta.x;
+ crop.width=(size_t) MagickRound((MagickRealType)
+ (offset.x+(geometry.x < 0 ? geometry.x : 0)));
+ }
+ crop.width-=crop.x;
+ crop.x+=transform_image->page.x;
+ next=CropImage(transform_image,&crop,&(*image)->exception);
if (next == (Image *) NULL)
break;
+ AppendImageToList(&crop_image,next);
}
+ if (next == (Image *) NULL)
+ break;
}
+ }
+ else
+ if (((geometry.width == 0) && (geometry.height == 0)) ||
+ ((flags & XValue) != 0) || ((flags & YValue) != 0))
+ {
+ /*
+ Crop a single region at +X+Y.
+ */
+ crop_image=CropImage(transform_image,&geometry,
+ &(*image)->exception);
+ if ((crop_image != (Image *) NULL) && ((flags & AspectValue) != 0))
+ {
+ crop_image->page.width=geometry.width;
+ crop_image->page.height=geometry.height;
+ crop_image->page.x-=geometry.x;
+ crop_image->page.y-=geometry.y;
+ }
+ }
+ else
+ if ((transform_image->columns > geometry.width) ||
+ (transform_image->rows > geometry.height))
+ {
+ MagickBooleanType
+ proceed;
+
+ MagickProgressMonitor
+ progress_monitor;
+
+ MagickOffsetType
+ i;
+
+ MagickSizeType
+ number_images;
+
+ /*
+ Crop into tiles of fixed size WxH.
+ */
+ if (transform_image->page.width == 0)
+ transform_image->page.width=transform_image->columns;
+ if (transform_image->page.height == 0)
+ transform_image->page.height=transform_image->rows;
+ width=geometry.width;
+ if (width == 0)
+ width=transform_image->page.width;
+ height=geometry.height;
+ if (height == 0)
+ height=transform_image->page.height;
+ next=NewImageList();
+ proceed=MagickTrue;
+ i=0;
+ number_images=0;
+ for (y=0; y < (ssize_t) transform_image->page.height; y+=(ssize_t) height)
+ for (x=0; x < (ssize_t) transform_image->page.width; x+=(ssize_t) width)
+ number_images++;
+ for (y=0; y < (ssize_t) transform_image->page.height; y+=(ssize_t) height)
+ {
+ for (x=0; x < (ssize_t) transform_image->page.width; x+=(ssize_t) width)
+ {
+ progress_monitor=SetImageProgressMonitor(transform_image,
+ (MagickProgressMonitor) NULL,transform_image->client_data);
+ geometry.width=width;
+ geometry.height=height;
+ geometry.x=x;
+ geometry.y=y;
+ next=CropImage(transform_image,&geometry,&(*image)->exception);
+ (void) SetImageProgressMonitor(transform_image,
+ progress_monitor,transform_image->client_data);
+ proceed=SetImageProgress(transform_image,CropImageTag,i++,
+ number_images);
+ if (proceed == MagickFalse)
+ break;
+ if (next == (Image *) NULL)
+ break;
+ (void) SetImageProgressMonitor(next,progress_monitor,
+ next->client_data);
+ if (crop_image == (Image *) NULL)
+ crop_image=next;
+ else
+ {
+ next->previous=crop_image;
+ crop_image->next=next;
+ crop_image=crop_image->next;
+ }
+ }
+ if (next == (Image *) NULL)
+ break;
+ if (proceed == MagickFalse)
+ break;
+ }
+ }
if (crop_image == (Image *) NULL)
transform_image=CloneImage(*image,0,0,MagickTrue,&(*image)->exception);
else
MagickStatusType
status;
- register long
+ register ssize_t
i;
assert(images != (Image **) NULL);
{
#define TransposeImageTag "Transpose/Image"
+ CacheView
+ *image_view,
+ *transpose_view;
+
Image
*transpose_image;
- long
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
RectangleInfo
page;
- CacheView
- *image_view,
- *transpose_view;
+ ssize_t
+ y;
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(progress,status)
#endif
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict transpose_indexes,
- *__restrict indexes;
+ *restrict transpose_indexes,
+ *restrict indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
if (status == MagickFalse)
continue;
- p=GetCacheViewVirtualPixels(image_view,0,(long) image->rows-y-1,
+ p=GetCacheViewVirtualPixels(image_view,0,(ssize_t) image->rows-y-1,
image->columns,1,exception);
- q=QueueCacheViewAuthenticPixels(transpose_view,(long) (image->rows-y-1),0,
- 1,transpose_image->rows,exception);
+ q=QueueCacheViewAuthenticPixels(transpose_view,(ssize_t) (image->rows-y-1),
+ 0,1,transpose_image->rows,exception);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
{
status=MagickFalse;
Swap(page.width,page.height);
Swap(page.x,page.y);
if (page.width != 0)
- page.x=(long) (page.width-transpose_image->columns-page.x);
+ page.x=(ssize_t) (page.width-transpose_image->columns-page.x);
transpose_image->page=page;
if (status == MagickFalse)
transpose_image=DestroyImage(transpose_image);
{
#define TransverseImageTag "Transverse/Image"
+ CacheView
+ *image_view,
+ *transverse_view;
+
Image
*transverse_image;
- long
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
RectangleInfo
page;
- CacheView
- *image_view,
- *transverse_view;
+ ssize_t
+ y;
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(progress,status)
#endif
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
MagickBooleanType
sync;
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict transverse_indexes,
- *__restrict indexes;
+ *restrict transverse_indexes,
+ *restrict indexes;
- register long
+ register ssize_t
x;
register PixelPacket
- *__restrict q;
+ *restrict q;
if (status == MagickFalse)
continue;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
- q=QueueCacheViewAuthenticPixels(transverse_view,(long) (image->rows-y-
+ q=QueueCacheViewAuthenticPixels(transverse_view,(ssize_t) (image->rows-y-
1),0,1,transverse_image->rows,exception);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
{
continue;
}
q+=image->columns;
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
*--q=(*p++);
indexes=GetCacheViewAuthenticIndexQueue(image_view);
if (indexes != (IndexPacket *) NULL)
{
transverse_indexes=GetCacheViewAuthenticIndexQueue(transverse_view);
if (transverse_indexes != (IndexPacket *) NULL)
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
transverse_indexes[image->columns-x-1]=indexes[x];
}
sync=SyncCacheViewAuthenticPixels(transverse_view,exception);
Swap(page.width,page.height);
Swap(page.x,page.y);
if (page.height != 0)
- page.y=(long) (page.height-transverse_image->rows-page.y);
+ page.y=(ssize_t) (page.height-transverse_image->rows-page.y);
transverse_image->page=page;
if (status == MagickFalse)
transverse_image=DestroyImage(transverse_image);
projects / imagemagick / blobdiff