% July 1992 %
% %
% %
-% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2012 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 %
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- chop_view=AcquireCacheView(chop_image);
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
+ image_view=AcquireVirtualCacheView(image,exception);
+ chop_view=AcquireAuthenticCacheView(chop_image,exception);
+#if defined(MAGICKCORE_OPENMP_SUPPORT) && defined(NoBenefitFromParallelism)
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ dynamic_number_threads(image,image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) extent.y; y++)
{
{
if ((x < extent.x) || (x >= (ssize_t) (extent.x+extent.width)))
{
- SetPixelRed(chop_image,GetPixelRed(image,p),q);
- SetPixelGreen(chop_image,GetPixelGreen(image,p),q);
- SetPixelBlue(chop_image,GetPixelBlue(image,p),q);
- if (image->colorspace == CMYKColorspace)
- SetPixelBlack(chop_image,GetPixelBlack(image,p),q);
+ register ssize_t
+ i;
+
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel
+ channel;
+
+ PixelTrait
+ chop_traits,
+ traits;
+
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ chop_traits=GetPixelChannelTraits(chop_image,channel);
+ if ((traits == UndefinedPixelTrait) ||
+ (chop_traits == UndefinedPixelTrait))
+ continue;
+ SetPixelChannel(chop_image,channel,p[i],q);
+ }
q+=GetPixelChannels(chop_image);
}
p+=GetPixelChannels(image);
MagickBooleanType
proceed;
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_ChopImage)
+#if defined(MAGICKCORE_OPENMP_SUPPORT) && defined(NoBenefitFromParallelism)
+ #pragma omp critical (MagickCore_ChopImage)
#endif
proceed=SetImageProgress(image,ChopImageTag,progress++,image->rows);
if (proceed == MagickFalse)
/*
Extract chop image.
*/
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
+#if defined(MAGICKCORE_OPENMP_SUPPORT) && defined(NoBenefitFromParallelism)
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ dynamic_number_threads(image,image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) (image->rows-(extent.y+extent.height)); y++)
{
{
if ((x < extent.x) || (x >= (ssize_t) (extent.x+extent.width)))
{
- SetPixelRed(chop_image,GetPixelRed(image,p),q);
- SetPixelGreen(chop_image,GetPixelGreen(image,p),q);
- SetPixelBlue(chop_image,GetPixelBlue(image,p),q);
- p+=GetPixelChannels(image);
+ register ssize_t
+ i;
+
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel
+ channel;
+
+ PixelTrait
+ chop_traits,
+ traits;
+
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ chop_traits=GetPixelChannelTraits(chop_image,channel);
+ if ((traits == UndefinedPixelTrait) ||
+ (chop_traits == UndefinedPixelTrait))
+ continue;
+ SetPixelChannel(chop_image,channel,p[i],q);
+ }
q+=GetPixelChannels(chop_image);
}
p+=GetPixelChannels(image);
MagickBooleanType
proceed;
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_ChopImage)
+#if defined(MAGICKCORE_OPENMP_SUPPORT) && defined(NoBenefitFromParallelism)
+ #pragma omp critical (MagickCore_ChopImage)
#endif
proceed=SetImageProgress(image,ChopImageTag,progress++,image->rows);
if (proceed == MagickFalse)
*cmyk_images;
register ssize_t
- i;
+ j;
ssize_t
y;
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
cmyk_images=NewImageList();
- for (i=0; i < (ssize_t) GetImageListLength(images); i+=4)
+ for (j=0; j < (ssize_t) GetImageListLength(images); j+=4)
{
+ register ssize_t
+ i;
+
cmyk_image=CloneImage(images,images->columns,images->rows,MagickTrue,
exception);
if (cmyk_image == (Image *) NULL)
if (SetImageStorageClass(cmyk_image,DirectClass,exception) == MagickFalse)
break;
(void) SetImageColorspace(cmyk_image,CMYKColorspace,exception);
- image_view=AcquireCacheView(images);
- cmyk_view=AcquireCacheView(cmyk_image);
- for (y=0; y < (ssize_t) images->rows; y++)
- {
- register const Quantum
- *restrict p;
-
- register ssize_t
- x;
-
- register Quantum
- *restrict q;
-
- p=GetCacheViewVirtualPixels(image_view,0,y,images->columns,1,exception);
- q=QueueCacheViewAuthenticPixels(cmyk_view,0,y,cmyk_image->columns,1,
- exception);
- if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
- break;
- for (x=0; x < (ssize_t) images->columns; x++)
- {
- SetPixelRed(cmyk_image,QuantumRange-GetPixelIntensity(images,p),q);
- p+=GetPixelChannels(images);
- q+=GetPixelChannels(cmyk_image);
- }
- if (SyncCacheViewAuthenticPixels(cmyk_view,exception) == MagickFalse)
- break;
- }
- cmyk_view=DestroyCacheView(cmyk_view);
- image_view=DestroyCacheView(image_view);
- images=GetNextImageInList(images);
- if (images == (Image *) NULL)
- break;
- image_view=AcquireCacheView(images);
- cmyk_view=AcquireCacheView(cmyk_image);
- for (y=0; y < (ssize_t) images->rows; y++)
+ for (i=0; i < 4; i++)
{
- register const Quantum
- *restrict p;
-
- register ssize_t
- x;
-
- register Quantum
- *restrict q;
-
- p=GetCacheViewVirtualPixels(image_view,0,y,images->columns,1,exception);
- q=GetCacheViewAuthenticPixels(cmyk_view,0,y,cmyk_image->columns,1,
- exception);
- if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
- break;
- for (x=0; x < (ssize_t) images->columns; x++)
+ image_view=AcquireVirtualCacheView(images,exception);
+ cmyk_view=AcquireAuthenticCacheView(cmyk_image,exception);
+ for (y=0; y < (ssize_t) images->rows; y++)
{
- SetPixelGreen(cmyk_image,QuantumRange-GetPixelIntensity(images,p),q);
- p+=GetPixelChannels(images);
- q+=GetPixelChannels(cmyk_image);
- }
- if (SyncCacheViewAuthenticPixels(cmyk_view,exception) == MagickFalse)
- break;
- }
- cmyk_view=DestroyCacheView(cmyk_view);
- image_view=DestroyCacheView(image_view);
- images=GetNextImageInList(images);
- if (images == (Image *) NULL)
- break;
- image_view=AcquireCacheView(images);
- cmyk_view=AcquireCacheView(cmyk_image);
- for (y=0; y < (ssize_t) images->rows; y++)
- {
- register const Quantum
- *restrict p;
+ register const Quantum
+ *restrict p;
- register ssize_t
- x;
+ register ssize_t
+ x;
- register Quantum
- *restrict q;
+ register Quantum
+ *restrict q;
- p=GetCacheViewVirtualPixels(image_view,0,y,images->columns,1,exception);
- q=GetCacheViewAuthenticPixels(cmyk_view,0,y,cmyk_image->columns,1,
- exception);
- if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
- break;
- for (x=0; x < (ssize_t) images->columns; x++)
- {
- SetPixelBlue(cmyk_image,QuantumRange-GetPixelIntensity(images,p),q);
- p+=GetPixelChannels(images);
- q+=GetPixelChannels(cmyk_image);
- }
- if (SyncCacheViewAuthenticPixels(cmyk_view,exception) == MagickFalse)
- break;
- }
- cmyk_view=DestroyCacheView(cmyk_view);
- image_view=DestroyCacheView(image_view);
- images=GetNextImageInList(images);
- if (images == (Image *) NULL)
- break;
- image_view=AcquireCacheView(images);
- cmyk_view=AcquireCacheView(cmyk_image);
- for (y=0; y < (ssize_t) images->rows; y++)
- {
- register const Quantum
- *restrict p;
-
- register ssize_t
- x;
-
- register Quantum
- *restrict q;
+ p=GetCacheViewVirtualPixels(image_view,0,y,images->columns,1,exception);
+ q=QueueCacheViewAuthenticPixels(cmyk_view,0,y,cmyk_image->columns,1,
+ exception);
+ if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
+ break;
+ for (x=0; x < (ssize_t) images->columns; x++)
+ {
+ Quantum
+ pixel;
- p=GetCacheViewVirtualPixels(image_view,0,y,images->columns,1,exception);
- q=GetCacheViewAuthenticPixels(cmyk_view,0,y,cmyk_image->columns,1,
- exception);
- if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
- break;
- for (x=0; x < (ssize_t) images->columns; x++)
- {
- SetPixelBlack(cmyk_image,QuantumRange-GetPixelIntensity(images,p),q);
- p+=GetPixelChannels(images);
- q+=GetPixelChannels(cmyk_image);
+ pixel=QuantumRange-GetPixelIntensity(images,p);
+ switch (i)
+ {
+ case 0: SetPixelCyan(cmyk_image,pixel,q); break;
+ case 1: SetPixelMagenta(cmyk_image,pixel,q); break;
+ case 2: SetPixelYellow(cmyk_image,pixel,q); break;
+ case 3: SetPixelBlack(cmyk_image,pixel,q); break;
+ default: break;
+ }
+ p+=GetPixelChannels(images);
+ q+=GetPixelChannels(cmyk_image);
+ }
+ if (SyncCacheViewAuthenticPixels(cmyk_view,exception) == MagickFalse)
+ break;
}
- if (SyncCacheViewAuthenticPixels(cmyk_view,exception) == MagickFalse)
+ cmyk_view=DestroyCacheView(cmyk_view);
+ image_view=DestroyCacheView(image_view);
+ images=GetNextImageInList(images);
+ if (images == (Image *) NULL)
break;
}
- cmyk_view=DestroyCacheView(cmyk_view);
- image_view=DestroyCacheView(image_view);
AppendImageToList(&cmyk_images,cmyk_image);
- images=GetNextImageInList(images);
- if (images == (Image *) NULL)
- break;
}
return(cmyk_images);
}
MagickOffsetType
progress;
+ OffsetInfo
+ offset;
+
RectangleInfo
bounding_box,
page;
Crop is not within virtual canvas, return 1 pixel transparent image.
*/
(void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
- "GeometryDoesNotContainImage","`%s'",image->filename);
+ "GeometryDoesNotContainImage","'%s'",image->filename);
crop_image=CloneImage(image,1,1,MagickTrue,exception);
if (crop_image == (Image *) NULL)
return((Image *) NULL);
crop_image->background_color.alpha=(Quantum) TransparentAlpha;
- (void) SetImageBackgroundColor(crop_image);
+ (void) SetImageBackgroundColor(crop_image,exception);
crop_image->page=bounding_box;
crop_image->page.x=(-1);
crop_image->page.y=(-1);
if ((page.width == 0) || (page.height == 0))
{
(void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
- "GeometryDoesNotContainImage","`%s'",image->filename);
+ "GeometryDoesNotContainImage","'%s'",image->filename);
return((Image *) NULL);
}
/*
return((Image *) NULL);
crop_image->page.width=image->page.width;
crop_image->page.height=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))
+ offset.x=(ssize_t) (bounding_box.x+bounding_box.width);
+ offset.y=(ssize_t) (bounding_box.y+bounding_box.height);
+ if ((offset.x > (ssize_t) image->page.width) ||
+ (offset.y > (ssize_t) image->page.height))
{
crop_image->page.width=bounding_box.width;
crop_image->page.height=bounding_box.height;
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- crop_view=AcquireCacheView(crop_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ crop_view=AcquireAuthenticCacheView(crop_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ dynamic_number_threads(image,image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) crop_image->rows; y++)
{
}
for (x=0; x < (ssize_t) crop_image->columns; x++)
{
- SetPixelRed(crop_image,GetPixelRed(image,p),q);
- SetPixelGreen(crop_image,GetPixelGreen(image,p),q);
- SetPixelBlue(crop_image,GetPixelBlue(image,p),q);
- if (image->colorspace == CMYKColorspace)
- SetPixelBlack(crop_image,GetPixelBlack(image,p),q);
- SetPixelAlpha(crop_image,GetPixelAlpha(image,p),q);
- if (image->storage_class == PseudoClass)
- SetPixelIndex(crop_image,GetPixelIndex(image,p),q);
+ register ssize_t
+ i;
+
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(crop_image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel
+ channel;
+
+ PixelTrait
+ crop_traits,
+ traits;
+
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ crop_traits=GetPixelChannelTraits(crop_image,channel);
+ if ((traits == UndefinedPixelTrait) ||
+ (crop_traits == UndefinedPixelTrait))
+ continue;
+ SetPixelChannel(crop_image,channel,p[i],q);
+ }
p+=GetPixelChannels(image);
q+=GetPixelChannels(crop_image);
}
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_CropImage)
+ #pragma omp critical (MagickCore_CropImage)
#endif
proceed=SetImageProgress(image,CropImageTag,progress++,image->rows);
if (proceed == MagickFalse)
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% CropImageToTiles() will crop a single image, into a possible list of tiles.
+% CropImageToTiles() crops a single image, into a possible list of tiles.
% This may include a single sub-region of the image. This basically applies
% all the normal geometry flags for Crop.
%
-% Image *CropImageToTiles(const Image *image,const RectangleInfo
-% *crop_geometry, ExceptionInfo *exception)
+% Image *CropImageToTiles(const Image *image,
+% const RectangleInfo *crop_geometry, ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
*/
-static inline ssize_t MagickRound(MagickRealType x)
+static inline ssize_t MagickRound(double x)
{
/*
Round the fraction to nearest integer.
}
MagickExport Image *CropImageToTiles(const Image *image,
- const char *crop_geometry, ExceptionInfo *exception)
+ const char *crop_geometry,ExceptionInfo *exception)
{
Image
*next,
}
delta.x=(double) width/geometry.width;
delta.y=(double) height/geometry.height;
+ if (delta.x < 1.0)
+ delta.x=1.0;
+ if (delta.y < 1.0)
+ delta.y=1.0;
for (offset.y=0; offset.y < (double) height; )
{
if ((flags & AspectValue) == 0)
{
- crop.y=(ssize_t) MagickRound((MagickRealType) (offset.y-
+ crop.y=(ssize_t) MagickRound((double) (offset.y-
(geometry.y > 0 ? 0 : geometry.y)));
offset.y+=delta.y; /* increment now to find width */
- crop.height=(size_t) MagickRound((MagickRealType) (offset.y+
+ crop.height=(size_t) MagickRound((double) (offset.y+
(geometry.y < 0 ? 0 : geometry.y)));
}
else
{
- crop.y=(ssize_t) MagickRound((MagickRealType) (offset.y-
+ crop.y=(ssize_t) MagickRound((double) (offset.y-
(geometry.y > 0 ? geometry.y : 0)));
offset.y+=delta.y; /* increment now to find width */
- crop.height=(size_t) MagickRound((MagickRealType)
+ crop.height=(size_t) MagickRound((double)
(offset.y+(geometry.y < -1 ? geometry.y : 0)));
}
crop.height-=crop.y;
{
if ((flags & AspectValue) == 0)
{
- crop.x=(ssize_t) MagickRound((MagickRealType) (offset.x-
+ crop.x=(ssize_t) MagickRound((double) (offset.x-
(geometry.x > 0 ? 0 : geometry.x)));
offset.x+=delta.x; /* increment now to find height */
- crop.width=(size_t) MagickRound((MagickRealType) (offset.x+
+ crop.width=(size_t) MagickRound((double) (offset.x+
(geometry.x < 0 ? 0 : geometry.x)));
}
else
{
- crop.x=(ssize_t) MagickRound((MagickRealType) (offset.x-
+ crop.x=(ssize_t) MagickRound((double) (offset.x-
(geometry.x > 0 ? geometry.x : 0)));
offset.x+=delta.x; /* increment now to find height */
- crop.width=(size_t) MagickRound((MagickRealType) (offset.x+
+ crop.width=(size_t) MagickRound((double) (offset.x+
(geometry.x < 0 ? geometry.x : 0)));
}
crop.width-=crop.x;
ClearMagickException(exception);
return(crop_image);
}
-
if (((geometry.width == 0) && (geometry.height == 0)) ||
((flags & XValue) != 0) || ((flags & YValue) != 0))
{
crop_image->page.y-=geometry.y;
}
return(crop_image);
- }
+ }
if ((image->columns > geometry.width) || (image->rows > geometry.height))
{
RectangleInfo
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- excerpt_view=AcquireCacheView(excerpt_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ excerpt_view=AcquireAuthenticCacheView(excerpt_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ dynamic_number_threads(image,image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) excerpt_image->rows; y++)
{
}
for (x=0; x < (ssize_t) excerpt_image->columns; x++)
{
- SetPixelRed(excerpt_image,GetPixelRed(image,p),q);
- SetPixelGreen(excerpt_image,GetPixelGreen(image,p),q);
- SetPixelBlue(excerpt_image,GetPixelBlue(image,p),q);
- if (image->colorspace == CMYKColorspace)
- SetPixelBlack(excerpt_image,GetPixelBlack(image,p),q);
- if (image->storage_class == PseudoClass)
- SetPixelIndex(excerpt_image,GetPixelIndex(image,p),q);
- SetPixelAlpha(excerpt_image,GetPixelAlpha(image,p),q);
+ register ssize_t
+ i;
+
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(excerpt_image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel
+ channel;
+
+ PixelTrait
+ excerpt_traits,
+ traits;
+
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ excerpt_traits=GetPixelChannelTraits(excerpt_image,channel);
+ if ((traits == UndefinedPixelTrait) ||
+ (excerpt_traits == UndefinedPixelTrait))
+ continue;
+ SetPixelChannel(excerpt_image,channel,p[i],q);
+ }
p+=GetPixelChannels(image);
q+=GetPixelChannels(excerpt_image);
}
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_ExcerptImage)
+ #pragma omp critical (MagickCore_ExcerptImage)
#endif
proceed=SetImageProgress(image,ExcerptImageTag,progress++,image->rows);
if (proceed == MagickFalse)
return((Image *) NULL);
}
if (extent_image->background_color.alpha != OpaqueAlpha)
- extent_image->matte=MagickTrue;
- (void) SetImageBackgroundColor(extent_image);
- (void) CompositeImage(extent_image,image->compose,image,-geometry->x,
- -geometry->y);
+ extent_image->alpha_trait=BlendPixelTrait;
+ (void) SetImageBackgroundColor(extent_image,exception);
+ (void) CompositeImage(extent_image,image,image->compose,MagickTrue,
+ -geometry->x,-geometry->y,exception);
return(extent_image);
}
\f
status=MagickTrue;
progress=0;
page=image->page;
- image_view=AcquireCacheView(image);
- flip_view=AcquireCacheView(flip_image);
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
+ image_view=AcquireVirtualCacheView(image,exception);
+ flip_view=AcquireAuthenticCacheView(flip_image,exception);
+#if defined(MAGICKCORE_OPENMP_SUPPORT) && defined(NoBenefitFromParallelism)
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ dynamic_number_threads(image,image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) flip_image->rows; y++)
{
}
for (x=0; x < (ssize_t) flip_image->columns; x++)
{
- SetPixelRed(flip_image,GetPixelRed(image,p),q);
- SetPixelGreen(flip_image,GetPixelGreen(image,p),q);
- SetPixelBlue(flip_image,GetPixelBlue(image,p),q);
- if (image->colorspace == CMYKColorspace)
- SetPixelBlack(flip_image,GetPixelBlack(image,p),q);
- if (image->storage_class == PseudoClass)
- SetPixelIndex(flip_image,GetPixelIndex(image,p),q);
- SetPixelAlpha(flip_image,GetPixelAlpha(image,p),q);
+ register ssize_t
+ i;
+
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(flip_image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel
+ channel;
+
+ PixelTrait
+ flip_traits,
+ traits;
+
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ flip_traits=GetPixelChannelTraits(flip_image,channel);
+ if ((traits == UndefinedPixelTrait) ||
+ (flip_traits == UndefinedPixelTrait))
+ continue;
+ SetPixelChannel(flip_image,channel,p[i],q);
+ }
p+=GetPixelChannels(image);
q+=GetPixelChannels(flip_image);
}
MagickBooleanType
proceed;
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_FlipImage)
+#if defined(MAGICKCORE_OPENMP_SUPPORT) && defined(NoBenefitFromParallelism)
+ #pragma omp critical (MagickCore_FlipImage)
#endif
proceed=SetImageProgress(image,FlipImageTag,progress++,image->rows);
if (proceed == MagickFalse)
status=MagickTrue;
progress=0;
page=image->page;
- image_view=AcquireCacheView(image);
- flop_view=AcquireCacheView(flop_image);
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
+ image_view=AcquireVirtualCacheView(image,exception);
+ flop_view=AcquireAuthenticCacheView(flop_image,exception);
+#if defined(MAGICKCORE_OPENMP_SUPPORT) && defined(NoBenefitFromParallelism)
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ dynamic_number_threads(image,image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) flop_image->rows; y++)
{
q+=GetPixelChannels(flop_image)*flop_image->columns;
for (x=0; x < (ssize_t) flop_image->columns; x++)
{
+ register ssize_t
+ i;
+
q-=GetPixelChannels(flop_image);
- SetPixelRed(flop_image,GetPixelRed(image,p),q);
- SetPixelGreen(flop_image,GetPixelGreen(image,p),q);
- SetPixelBlue(flop_image,GetPixelBlue(image,p),q);
- if (image->colorspace == CMYKColorspace)
- SetPixelBlack(flop_image,GetPixelBlack(image,p),q);
- SetPixelAlpha(flop_image,GetPixelAlpha(image,p),q);
- if (image->storage_class == PseudoClass)
- SetPixelIndex(flop_image,GetPixelIndex(image,p),q);
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel
+ channel;
+
+ PixelTrait
+ flop_traits,
+ traits;
+
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ flop_traits=GetPixelChannelTraits(flop_image,channel);
+ if ((traits == UndefinedPixelTrait) ||
+ (flop_traits == UndefinedPixelTrait))
+ continue;
+ SetPixelChannel(flop_image,channel,p[i],q);
+ }
p+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(flop_view,exception) == MagickFalse)
MagickBooleanType
proceed;
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_FlopImage)
+#if defined(MAGICKCORE_OPENMP_SUPPORT) && defined(NoBenefitFromParallelism)
+ #pragma omp critical (MagickCore_FlopImage)
#endif
proceed=SetImageProgress(image,FlopImageTag,progress++,image->rows);
if (proceed == MagickFalse)
y;
status=MagickTrue;
- source_view=AcquireCacheView(source);
- destination_view=AcquireCacheView(destination);
+ source_view=AcquireVirtualCacheView(source,exception);
+ destination_view=AcquireAuthenticCacheView(destination,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(status)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ dynamic_number_threads(source,columns,rows,1)
#endif
for (y=0; y < (ssize_t) rows; y++)
{
}
for (x=0; x < (ssize_t) columns; x++)
{
- SetPixelRed(destination,GetPixelRed(source,p),q);
- SetPixelGreen(destination,GetPixelGreen(source,p),q);
- SetPixelBlue(destination,GetPixelBlue(source,p),q);
- if (destination->colorspace == CMYKColorspace)
- SetPixelBlack(destination,GetPixelBlack(source,p),q);
- SetPixelAlpha(destination,GetPixelAlpha(source,p),q);
+ register ssize_t
+ i;
+
+ if (GetPixelMask(source,p) != 0)
+ {
+ p+=GetPixelChannels(source);
+ q+=GetPixelChannels(destination);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
+ {
+ PixelChannel
+ channel;
+
+ PixelTrait
+ destination_traits,
+ source_traits;
+
+ channel=GetPixelChannelChannel(source,i);
+ source_traits=GetPixelChannelTraits(source,channel);
+ destination_traits=GetPixelChannelTraits(destination,channel);
+ if ((source_traits == UndefinedPixelTrait) ||
+ (destination_traits == UndefinedPixelTrait))
+ continue;
+ SetPixelChannel(destination,channel,p[i],q);
+ }
p+=GetPixelChannels(source);
q+=GetPixelChannels(destination);
}
splice_image=DestroyImage(splice_image);
return((Image *) NULL);
}
- (void) SetImageBackgroundColor(splice_image);
+ (void) SetImageBackgroundColor(splice_image,exception);
/*
Respect image geometry.
*/
splice_geometry.y+=(ssize_t) splice_geometry.width/2;
break;
}
- case StaticGravity:
case CenterGravity:
{
splice_geometry.x+=(ssize_t) splice_geometry.width/2;
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- splice_view=AcquireCacheView(splice_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ splice_view=AcquireAuthenticCacheView(splice_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ dynamic_number_threads(image,image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) splice_geometry.y; y++)
{
}
for (x=0; x < splice_geometry.x; x++)
{
- SetPixelRed(splice_image,GetPixelRed(image,p),q);
- SetPixelGreen(splice_image,GetPixelGreen(image,p),q);
- SetPixelBlue(splice_image,GetPixelBlue(image,p),q);
- if (image->colorspace == CMYKColorspace)
- SetPixelBlack(splice_image,GetPixelBlack(image,p),q);
- SetPixelAlpha(splice_image,OpaqueAlpha,q);
- if (image->matte != MagickFalse)
- SetPixelAlpha(splice_image,GetPixelAlpha(image,p),q);
+ register ssize_t
+ i;
+
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(splice_image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel
+ channel;
+
+ PixelTrait
+ splice_traits,
+ traits;
+
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ splice_traits=GetPixelChannelTraits(splice_image,channel);
+ if ((traits == UndefinedPixelTrait) ||
+ (splice_traits == UndefinedPixelTrait))
+ continue;
+ SetPixelChannel(splice_image,channel,p[i],q);
+ }
p+=GetPixelChannels(image);
q+=GetPixelChannels(splice_image);
}
q+=GetPixelChannels(splice_image);
for ( ; x < (ssize_t) splice_image->columns; x++)
{
- SetPixelRed(splice_image,GetPixelRed(image,p),q);
- SetPixelGreen(splice_image,GetPixelGreen(image,p),q);
- SetPixelBlue(splice_image,GetPixelBlue(image,p),q);
- if (image->colorspace == CMYKColorspace)
- SetPixelBlack(splice_image,GetPixelBlack(image,p),q);
- SetPixelAlpha(splice_image,OpaqueAlpha,q);
- if (image->matte != MagickFalse)
- SetPixelAlpha(splice_image,GetPixelAlpha(image,p),q);
+ register ssize_t
+ i;
+
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(splice_image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel
+ channel;
+
+ PixelTrait
+ traits,
+ splice_traits;
+
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ splice_traits=GetPixelChannelTraits(splice_image,channel);
+ if ((traits == UndefinedPixelTrait) ||
+ (splice_traits == UndefinedPixelTrait))
+ continue;
+ SetPixelChannel(splice_image,channel,p[i],q);
+ }
p+=GetPixelChannels(image);
q+=GetPixelChannels(splice_image);
}
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_TransposeImage)
+ #pragma omp critical (MagickCore_TransposeImage)
#endif
proceed=SetImageProgress(image,SpliceImageTag,progress++,
splice_image->rows);
}
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ dynamic_number_threads(image,image->columns,image->rows,1)
#endif
for (y=(ssize_t) (splice_geometry.y+splice_geometry.height);
y < (ssize_t) splice_image->rows; y++)
}
for (x=0; x < splice_geometry.x; x++)
{
- SetPixelRed(splice_image,GetPixelRed(image,p),q);
- SetPixelGreen(splice_image,GetPixelGreen(image,p),q);
- SetPixelBlue(splice_image,GetPixelBlue(image,p),q);
- SetPixelAlpha(splice_image,OpaqueAlpha,q);
- if (image->colorspace == CMYKColorspace)
- SetPixelBlack(splice_image,GetPixelBlack(image,p),q);
- if (image->matte != MagickFalse)
- SetPixelAlpha(splice_image,GetPixelAlpha(image,p),q);
+ register ssize_t
+ i;
+
+ if (GetPixelMask(image,q) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(splice_image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel
+ channel;
+
+ PixelTrait
+ traits,
+ splice_traits;
+
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ splice_traits=GetPixelChannelTraits(splice_image,channel);
+ if ((traits == UndefinedPixelTrait) ||
+ (splice_traits == UndefinedPixelTrait))
+ continue;
+ SetPixelChannel(splice_image,channel,p[i],q);
+ }
p+=GetPixelChannels(image);
q+=GetPixelChannels(splice_image);
}
q+=GetPixelChannels(splice_image);
for ( ; x < (ssize_t) splice_image->columns; x++)
{
- SetPixelRed(splice_image,GetPixelRed(image,p),q);
- SetPixelGreen(splice_image,GetPixelGreen(image,p),q);
- SetPixelBlue(splice_image,GetPixelBlue(image,p),q);
- SetPixelAlpha(splice_image,OpaqueAlpha,q);
- if (image->colorspace == CMYKColorspace)
- SetPixelBlack(splice_image,GetPixelBlack(image,p),q);
- if (image->matte != MagickFalse)
- SetPixelAlpha(splice_image,GetPixelAlpha(image,p),q);
+ register ssize_t
+ i;
+
+ if (GetPixelMask(image,q) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(splice_image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel
+ channel;
+
+ PixelTrait
+ traits,
+ splice_traits;
+
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ splice_traits=GetPixelChannelTraits(splice_image,channel);
+ if ((traits == UndefinedPixelTrait) ||
+ (splice_traits == UndefinedPixelTrait))
+ continue;
+ SetPixelChannel(splice_image,channel,p[i],q);
+ }
p+=GetPixelChannels(image);
q+=GetPixelChannels(splice_image);
}
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_TransposeImage)
+ #pragma omp critical (MagickCore_TransposeImage)
#endif
proceed=SetImageProgress(image,SpliceImageTag,progress++,
splice_image->rows);
%
% This should only be used for single images.
%
+% This function destroys what it assumes to be a single image list.
+% If the input image is part of a larger list, all other images in that list
+% will be simply 'lost', not destroyed.
+%
+% Also if the crop generates a list of images only the first image is resized.
+% And finally if the crop succeeds and the resize failed, you will get a
+% cropped image, as well as a 'false' or 'failed' report.
+%
+% This function and should probably be depreciated in favor of direct calls
+% to CropImageToTiles() or ResizeImage(), as appropriate.
+%
% The format of the TransformImage method is:
%
% MagickBooleanType TransformImage(Image **image,const char *crop_geometry,
-% const char *image_geometry)
+% const char *image_geometry,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_geometry: An image geometry string. This geometry defines the
% final size of the image.
%
-*/
-/*
- DANGER: This function destroys what it assumes to be a single image list.
- If the input image is part of a larger list, all other images in that list
- will be simply 'lost', not destroyed.
-
- Also if the crop generates a list of images only the first image is resized.
- And finally if the crop succeeds and the resize failed, you will get a
- cropped image, as well as a 'false' or 'failed' report.
-
- This function and should probably be depreciated in favor of direct calls
- to CropImageToTiles() or ResizeImage(), as appropriate.
-
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType TransformImage(Image **image,
- const char *crop_geometry,const char *image_geometry)
+ const char *crop_geometry,const char *image_geometry,ExceptionInfo *exception)
{
Image
*resize_image,
/*
Crop image to a user specified size.
*/
- crop_image=CropImageToTiles(*image,crop_geometry,&(*image)->exception);
+ crop_image=CropImageToTiles(*image,crop_geometry,exception);
if (crop_image == (Image *) NULL)
- transform_image=CloneImage(*image,0,0,MagickTrue,&(*image)->exception);
+ transform_image=CloneImage(*image,0,0,MagickTrue,exception);
else
{
transform_image=DestroyImage(transform_image);
/*
Scale image to a user specified size.
*/
- flags=ParseRegionGeometry(transform_image,image_geometry,&geometry,
- &(*image)->exception);
+ flags=ParseRegionGeometry(transform_image,image_geometry,&geometry,exception);
(void) flags;
if ((transform_image->columns == geometry.width) &&
(transform_image->rows == geometry.height))
return(MagickTrue);
resize_image=ResizeImage(transform_image,geometry.width,geometry.height,
- transform_image->filter,transform_image->blur,&(*image)->exception);
+ transform_image->filter,exception);
if (resize_image == (Image *) NULL)
return(MagickFalse);
transform_image=DestroyImage(transform_image);
% The format of the TransformImage method is:
%
% MagickBooleanType TransformImages(Image **image,
-% const char *crop_geometry,const char *image_geometry)
+% const char *crop_geometry,const char *image_geometry,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_geometry: An image geometry string. This geometry defines the
% final size of the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType TransformImages(Image **images,
- const char *crop_geometry,const char *image_geometry)
+ const char *crop_geometry,const char *image_geometry,ExceptionInfo *exception)
{
Image
*image,
if ((*images)->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
(*images)->filename);
- image_list=ImageListToArray(*images,&(*images)->exception);
+ image_list=ImageListToArray(*images,exception);
if (image_list == (Image **) NULL)
return(MagickFalse);
status=MagickTrue;
for (i=0; image_list[i] != (Image *) NULL; i++)
{
image=image_list[i];
- status|=TransformImage(&image,crop_geometry,image_geometry);
+ status|=TransformImage(&image,crop_geometry,image_geometry,exception);
AppendImageToList(&transform_images,image);
}
*images=transform_images;
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- transpose_view=AcquireCacheView(transpose_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ transpose_view=AcquireAuthenticCacheView(transpose_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ dynamic_number_threads(image,image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
}
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelRed(transpose_image,GetPixelRed(image,p),q);
- SetPixelGreen(transpose_image,GetPixelGreen(image,p),q);
- SetPixelBlue(transpose_image,GetPixelBlue(image,p),q);
- if (image->colorspace == CMYKColorspace)
- SetPixelBlack(transpose_image,GetPixelBlack(image,p),q);
- SetPixelAlpha(transpose_image,GetPixelAlpha(image,p),q);
+ register ssize_t
+ i;
+
+ if (GetPixelMask(image,q) != 0)
+ {
+ p+=GetPixelChannels(image);
+ q+=GetPixelChannels(transpose_image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel
+ channel;
+
+ PixelTrait
+ traits,
+ transpose_traits;
+
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ transpose_traits=GetPixelChannelTraits(transpose_image,channel);
+ if ((traits == UndefinedPixelTrait) ||
+ (transpose_traits == UndefinedPixelTrait))
+ continue;
+ SetPixelChannel(transpose_image,channel,p[i],q);
+ }
p+=GetPixelChannels(image);
q+=GetPixelChannels(transpose_image);
}
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_TransposeImage)
+ #pragma omp critical (MagickCore_TransposeImage)
#endif
proceed=SetImageProgress(image,TransposeImageTag,progress++,
image->rows);
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- transverse_view=AcquireCacheView(transverse_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ transverse_view=AcquireAuthenticCacheView(transverse_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ dynamic_number_threads(image,image->columns,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
*restrict p;
- register ssize_t
- x;
-
register Quantum
*restrict q;
+ register ssize_t
+ x;
+
if (status == MagickFalse)
continue;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
- q=QueueCacheViewAuthenticPixels(transverse_view,(ssize_t) (image->rows-y-
- 1),0,1,transverse_image->rows,exception);
+ q=QueueCacheViewAuthenticPixels(transverse_view,(ssize_t) (image->rows-y-1),
+ 0,1,transverse_image->rows,exception);
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
{
status=MagickFalse;
q+=GetPixelChannels(transverse_image)*image->columns;
for (x=0; x < (ssize_t) image->columns; x++)
{
+ register ssize_t
+ i;
+
q-=GetPixelChannels(transverse_image);
- SetPixelRed(transverse_image,GetPixelRed(image,p),q);
- SetPixelGreen(transverse_image,GetPixelGreen(image,p),q);
- SetPixelBlue(transverse_image,GetPixelBlue(image,p),q);
- SetPixelAlpha(transverse_image,GetPixelAlpha(image,p),q);
- if (image->colorspace == CMYKColorspace)
- SetPixelBlack(transverse_image,GetPixelBlack(image,p),q);
+ if (GetPixelMask(image,p) != 0)
+ {
+ p+=GetPixelChannels(image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel
+ channel;
+
+ PixelTrait
+ traits,
+ transverse_traits;
+
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ transverse_traits=GetPixelChannelTraits(transverse_image,channel);
+ if ((traits == UndefinedPixelTrait) ||
+ (transverse_traits == UndefinedPixelTrait))
+ continue;
+ SetPixelChannel(transverse_image,channel,p[i],q);
+ }
p+=GetPixelChannels(image);
}
sync=SyncCacheViewAuthenticPixels(transverse_view,exception);
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_TransverseImage)
+ #pragma omp critical (MagickCore_TransverseImage)
#endif
proceed=SetImageProgress(image,TransverseImageTag,progress++,
image->rows);
if (crop_image == (Image *) NULL)
return((Image *) NULL);
crop_image->background_color.alpha=(Quantum) TransparentAlpha;
- (void) SetImageBackgroundColor(crop_image);
+ (void) SetImageBackgroundColor(crop_image,exception);
crop_image->page=image->page;
crop_image->page.x=(-1);
crop_image->page.y=(-1);