#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:
%
Image
*chop_image;
- long
+ ssize_t
j,
y;
MagickBooleanType
- proceed;
+ proceed,
+ status;
RectangleInfo
extent;
- register long
+ register ssize_t
i;
/*
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 chop_indexes,
*restrict indexes;
- register long
+ register ssize_t
x;
register PixelPacket
*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 chop_indexes,
*restrict indexes;
- register long
+ register ssize_t
x;
register PixelPacket
*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;
- register long
+ register ssize_t
x;
register PixelPacket
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;
- register long
+ register ssize_t
x;
register PixelPacket
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;
- register long
+ register ssize_t
x;
register PixelPacket
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;
register IndexPacket
*restrict indexes;
- register long
+ register ssize_t
x;
register PixelPacket
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++;
Image
*crop_image;
- long
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
RectangleInfo
bounding_box,
page;
+ 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;
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);
Image
*excerpt_image;
- long
- progress,
- y;
-
MagickBooleanType
status;
+ 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;
Image
*flip_image;
- long
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
+ ssize_t
+ y;
+
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
#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;
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);
Image
*flop_image;
- long
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
+ ssize_t
+ y;
+
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
#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;
register IndexPacket
*restrict flop_indexes;
- register long
+ register ssize_t
x;
register PixelPacket
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)
{
CacheView
*source_view,
*destination_view;
- long
+ ssize_t
y;
MagickBooleanType
#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;
register IndexPacket
- *restrict indexes,
*restrict destination_indexes;
- register long
- x;
-
register PixelPacket
*restrict q;
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
Image
*splice_image;
- long
- progress,
- y;
-
MagickBooleanType
proceed,
status;
+ MagickOffsetType
+ progress;
+
RectangleInfo
splice_geometry;
- register long
+ register ssize_t
i;
+ 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 indexes,
*restrict splice_indexes;
- register long
+ register ssize_t
x;
register PixelPacket
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++)
{
SetRedPixelComponent(q,GetRedPixelComponent(p));
SetGreenPixelComponent(q,GetGreenPixelComponent(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 indexes,
*restrict splice_indexes;
- register long
+ register ssize_t
x;
register PixelPacket
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);
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++)
{
SetRedPixelComponent(q,GetRedPixelComponent(p));
SetGreenPixelComponent(q,GetGreenPixelComponent(p));
% final size of the image.
%
*/
-static inline double MagickRound(double x)
+static inline ssize_t MagickRound(MagickRealType x)
{
- /* round the fraction to nearest integer */
+ /*
+ Round the fraction to nearest integer.
+ */
if (x >= 0.0)
- return((double) ((long) (x+0.5)));
- return((double) ((long) (x-0.5)));
+ 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);
- /* crop into NxM tiles (@ flag) - AT */
- if ((flags & AreaValue) != 0 )
+ if ((flags & AreaValue) != 0)
{
- Image
- *next;
-
- MagickRealType
- width, height, w_step, h_step, x, y;
+ PointInfo
+ delta,
+ offset;
RectangleInfo
crop;
- if ( geometry.width == 0 ) geometry.width = 1;
- if ( geometry.height == 0 ) geometry.height = 1;
-
- width=(MagickRealType)transform_image->columns;
- height=(MagickRealType)transform_image->rows;
+ /*
+ 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)
{
- width -= (MagickRealType)labs(geometry.x);
- height -= (MagickRealType)labs(geometry.y);
+ width-=(geometry.x < 0 ? -1 : 1)*geometry.x;
+ height-=(geometry.y < 0 ? -1 : 1)*geometry.y;
}
else
{
- width += (MagickRealType)labs(geometry.x);
- height += (MagickRealType)labs(geometry.y);
+ width+=(geometry.x < 0 ? -1 : 1)*geometry.x;
+ height+=(geometry.y < 0 ? -1 : 1)*geometry.y;
}
- w_step=width/geometry.width;
- h_step=height/geometry.height;
-
+ delta.x=(double) width/geometry.width;
+ delta.y=(double) height/geometry.height;
next=NewImageList();
- for (y=0.0; y < height; )
+ for (offset.y=0; offset.y < (double) height; )
{
if ((flags & AspectValue) == 0)
{
- crop.y=MagickRound(y-(geometry.y>0?0:geometry.y));
- y+=h_step;
- crop.height=MagickRound(y+(geometry.y<0?0:geometry.y));
+ 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=MagickRound(y-(geometry.y>0?geometry.y:0) );
- y+=h_step;
- crop.height=MagickRound(y+(geometry.y<0?geometry.y:0) );
+ 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;
- for (x=0.0; x < width; )
+ crop.height-=crop.y;
+ crop.y+=transform_image->page.y;
+ for (offset.x=0; offset.x < (double) width; )
{
if ((flags & AspectValue) == 0)
{
- crop.x=MagickRound(x-(geometry.x>0?0:geometry.x));
- x+=w_step;
- crop.width=MagickRound(x+(geometry.x<0?0:geometry.x));
+ 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=MagickRound(x-(geometry.x>0?geometry.x:0) );
- x+=w_step;
- crop.width=MagickRound(x+(geometry.x<0?geometry.x:0) );
+ 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.width-=crop.x;
+ crop.x+=transform_image->page.x;
next=CropImage(transform_image,&crop,&(*image)->exception);
if (next == (Image *) NULL)
break;
break;
}
}
- /* crop a single region at +X+Y */
- else if (((geometry.width == 0) && (geometry.height == 0)) ||
+ else
+ if (((geometry.width == 0) && (geometry.height == 0)) ||
((flags & XValue) != 0) || ((flags & YValue) != 0))
- {
- 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;
- }
- }
- /* crop into tiles of fixed size WxH */
- 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)
{
- for (x=0; x < (long) transform_image->page.width; x+=width)
- {
- 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);
- }
- if (next == (Image *) NULL)
- break;
- }
- }
+ /*
+ 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);
Image
*transpose_image;
- long
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
RectangleInfo
page;
+ ssize_t
+ y;
+
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
#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;
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);
Image
*transverse_image;
- long
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
RectangleInfo
page;
+ ssize_t
+ y;
+
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
#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;
*restrict transverse_indexes,
*restrict indexes;
- register long
+ register ssize_t
x;
register PixelPacket
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);