42 #include "magick/studio.h"
43 #include "magick/attribute.h"
44 #include "magick/cache.h"
45 #include "magick/cache-view.h"
46 #include "magick/color.h"
47 #include "magick/color-private.h"
48 #include "magick/colorspace-private.h"
49 #include "magick/composite.h"
50 #include "magick/distort.h"
51 #include "magick/draw.h"
52 #include "magick/effect.h"
53 #include "magick/exception.h"
54 #include "magick/exception-private.h"
55 #include "magick/geometry.h"
56 #include "magick/image.h"
57 #include "magick/memory_.h"
58 #include "magick/layer.h"
59 #include "magick/list.h"
60 #include "magick/monitor.h"
61 #include "magick/monitor-private.h"
62 #include "magick/pixel-private.h"
63 #include "magick/property.h"
64 #include "magick/resource_.h"
65 #include "magick/resize.h"
66 #include "magick/statistic.h"
67 #include "magick/string_.h"
68 #include "magick/thread-private.h"
69 #include "magick/transform.h"
99 MagickExport
Image *AutoOrientImage(
const Image *image,
105 assert(image != (
const Image *) NULL);
106 assert(image->signature == MagickCoreSignature);
108 assert(exception->signature == MagickCoreSignature);
109 orient_image=(
Image *) NULL;
112 case UndefinedOrientation:
113 case TopLeftOrientation:
116 orient_image=CloneImage(image,0,0,MagickTrue,exception);
119 case TopRightOrientation:
121 orient_image=FlopImage(image,exception);
124 case BottomRightOrientation:
126 orient_image=RotateImage(image,180.0,exception);
129 case BottomLeftOrientation:
131 orient_image=FlipImage(image,exception);
134 case LeftTopOrientation:
136 orient_image=TransposeImage(image,exception);
139 case RightTopOrientation:
141 orient_image=RotateImage(image,90.0,exception);
144 case RightBottomOrientation:
146 orient_image=TransverseImage(image,exception);
149 case LeftBottomOrientation:
151 orient_image=RotateImage(image,270.0,exception);
155 if (orient_image != (
Image *) NULL)
156 orient_image->orientation=TopLeftOrientation;
157 return(orient_image);
191 #define ChopImageTag "Chop/Image"
215 assert(image != (
const Image *) NULL);
216 assert(image->signature == MagickCoreSignature);
218 assert(exception->signature == MagickCoreSignature);
220 if (IsEventLogging() != MagickFalse)
221 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
222 if (((chop_info->x+(ssize_t) chop_info->width) < 0) ||
223 ((chop_info->y+(ssize_t) chop_info->height) < 0) ||
224 (chop_info->x > (ssize_t) image->columns) ||
225 (chop_info->y > (ssize_t) image->rows))
226 ThrowImageException(OptionWarning,
"GeometryDoesNotContainImage");
228 if ((extent.x+(ssize_t) extent.width) > (ssize_t) image->columns)
229 extent.width=(size_t) ((ssize_t) image->columns-extent.x);
230 if ((extent.y+(ssize_t) extent.height) > (ssize_t) image->rows)
231 extent.height=(size_t) ((ssize_t) image->rows-extent.y);
234 extent.width-=(size_t) (-extent.x);
239 extent.height-=(size_t) (-extent.y);
242 chop_image=CloneImage(image,image->columns-extent.width,image->rows-
243 extent.height,MagickTrue,exception);
244 if (chop_image == (
Image *) NULL)
245 return((
Image *) NULL);
251 image_view=AcquireVirtualCacheView(image,exception);
252 chop_view=AcquireAuthenticCacheView(chop_image,exception);
253 #if defined(MAGICKCORE_OPENMP_SUPPORT)
254 #pragma omp parallel for schedule(static) shared(status) \
255 magick_number_threads(image,chop_image,extent.y,1)
257 for (y=0; y < (ssize_t) extent.y; y++)
263 *magick_restrict chop_indexes,
264 *magick_restrict indexes;
272 if (status == MagickFalse)
274 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
275 q=QueueCacheViewAuthenticPixels(chop_view,0,y,chop_image->columns,1,
282 indexes=GetCacheViewAuthenticIndexQueue(image_view);
283 chop_indexes=GetCacheViewAuthenticIndexQueue(chop_view);
284 for (x=0; x < (ssize_t) image->columns; x++)
286 if ((x < extent.x) || (x >= (ssize_t) (extent.x+extent.width)))
289 if (indexes != (IndexPacket *) NULL)
291 if (chop_indexes != (IndexPacket *) NULL)
292 *chop_indexes++=GetPixelIndex(indexes+x);
298 if (SyncCacheViewAuthenticPixels(chop_view,exception) == MagickFalse)
300 if (image->progress_monitor != (MagickProgressMonitor) NULL)
305 #if defined(MAGICKCORE_OPENMP_SUPPORT)
309 proceed=SetImageProgress(image,ChopImageTag,progress,image->rows);
310 if (proceed == MagickFalse)
317 #if defined(MAGICKCORE_OPENMP_SUPPORT)
318 #pragma omp parallel for schedule(static) shared(status) \
319 magick_number_threads(image,image,image->rows,1)
321 for (y=0; y < (ssize_t) (image->rows-(extent.y+extent.height)); y++)
327 *magick_restrict chop_indexes,
328 *magick_restrict indexes;
336 if (status == MagickFalse)
338 p=GetCacheViewVirtualPixels(image_view,0,extent.y+extent.height+y,
339 image->columns,1,exception);
340 q=QueueCacheViewAuthenticPixels(chop_view,0,extent.y+y,chop_image->columns,
347 indexes=GetCacheViewAuthenticIndexQueue(image_view);
348 chop_indexes=GetCacheViewAuthenticIndexQueue(chop_view);
349 for (x=0; x < (ssize_t) image->columns; x++)
351 if ((x < extent.x) || (x >= (ssize_t) (extent.x+extent.width)))
354 if (indexes != (IndexPacket *) NULL)
356 if (chop_indexes != (IndexPacket *) NULL)
357 *chop_indexes++=GetPixelIndex(indexes+x);
363 if (SyncCacheViewAuthenticPixels(chop_view,exception) == MagickFalse)
365 if (image->progress_monitor != (MagickProgressMonitor) NULL)
370 #if defined(MAGICKCORE_OPENMP_SUPPORT)
374 proceed=SetImageProgress(image,ChopImageTag,progress,image->rows);
375 if (proceed == MagickFalse)
379 chop_view=DestroyCacheView(chop_view);
380 image_view=DestroyCacheView(image_view);
381 chop_image->type=image->type;
382 if (status == MagickFalse)
383 chop_image=DestroyImage(chop_image);
412 MagickExport
Image *ConsolidateCMYKImages(
const Image *images,
432 assert(images != (
Image *) NULL);
433 assert(images->signature == MagickCoreSignature);
435 assert(exception->signature == MagickCoreSignature);
436 if (IsEventLogging() != MagickFalse)
437 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",images->filename);
438 cmyk_images=NewImageList();
439 for (i=0; i < (ssize_t) GetImageListLength(images); i+=4)
441 cmyk_image=CloneImage(images,0,0,MagickTrue,exception);
442 if (cmyk_image == (
Image *) NULL)
444 if (SetImageStorageClass(cmyk_image,DirectClass) == MagickFalse)
446 (void) SetImageColorspace(cmyk_image,CMYKColorspace);
447 image_view=AcquireVirtualCacheView(images,exception);
448 cmyk_view=AcquireAuthenticCacheView(cmyk_image,exception);
449 for (y=0; y < (ssize_t) images->rows; y++)
460 p=GetCacheViewVirtualPixels(image_view,0,y,images->columns,1,exception);
461 q=QueueCacheViewAuthenticPixels(cmyk_view,0,y,cmyk_image->columns,1,
465 for (x=0; x < (ssize_t) images->columns; x++)
467 SetPixelRed(q,ClampToQuantum(QuantumRange-GetPixelIntensity(images,p)));
471 if (SyncCacheViewAuthenticPixels(cmyk_view,exception) == MagickFalse)
474 cmyk_view=DestroyCacheView(cmyk_view);
475 image_view=DestroyCacheView(image_view);
476 images=GetNextImageInList(images);
477 if (images == (
Image *) NULL)
479 image_view=AcquireVirtualCacheView(images,exception);
480 cmyk_view=AcquireAuthenticCacheView(cmyk_image,exception);
481 for (y=0; y < (ssize_t) images->rows; y++)
492 p=GetCacheViewVirtualPixels(image_view,0,y,images->columns,1,exception);
493 q=GetCacheViewAuthenticPixels(cmyk_view,0,y,cmyk_image->columns,1,
497 for (x=0; x < (ssize_t) images->columns; x++)
499 q->green=ClampToQuantum(QuantumRange-GetPixelIntensity(images,p));
503 if (SyncCacheViewAuthenticPixels(cmyk_view,exception) == MagickFalse)
506 cmyk_view=DestroyCacheView(cmyk_view);
507 image_view=DestroyCacheView(image_view);
508 images=GetNextImageInList(images);
509 if (images == (
Image *) NULL)
511 image_view=AcquireVirtualCacheView(images,exception);
512 cmyk_view=AcquireAuthenticCacheView(cmyk_image,exception);
513 for (y=0; y < (ssize_t) images->rows; y++)
524 p=GetCacheViewVirtualPixels(image_view,0,y,images->columns,1,exception);
525 q=GetCacheViewAuthenticPixels(cmyk_view,0,y,cmyk_image->columns,1,
529 for (x=0; x < (ssize_t) images->columns; x++)
531 q->blue=ClampToQuantum(QuantumRange-GetPixelIntensity(images,p));
535 if (SyncCacheViewAuthenticPixels(cmyk_view,exception) == MagickFalse)
538 cmyk_view=DestroyCacheView(cmyk_view);
539 image_view=DestroyCacheView(image_view);
540 images=GetNextImageInList(images);
541 if (images == (
Image *) NULL)
543 image_view=AcquireVirtualCacheView(images,exception);
544 cmyk_view=AcquireAuthenticCacheView(cmyk_image,exception);
545 for (y=0; y < (ssize_t) images->rows; y++)
551 *magick_restrict indexes;
559 p=GetCacheViewVirtualPixels(image_view,0,y,images->columns,1,exception);
560 q=GetCacheViewAuthenticPixels(cmyk_view,0,y,cmyk_image->columns,1,
564 indexes=GetCacheViewAuthenticIndexQueue(cmyk_view);
565 for (x=0; x < (ssize_t) images->columns; x++)
567 SetPixelIndex(indexes+x,ClampToQuantum(QuantumRange-
568 GetPixelIntensity(images,p)));
571 if (SyncCacheViewAuthenticPixels(cmyk_view,exception) == MagickFalse)
574 cmyk_view=DestroyCacheView(cmyk_view);
575 image_view=DestroyCacheView(image_view);
576 AppendImageToList(&cmyk_images,cmyk_image);
577 images=GetNextImageInList(images);
578 if (images == (
Image *) NULL)
617 #define CropImageTag "Crop/Image"
642 assert(image != (
const Image *) NULL);
643 assert(image->signature == MagickCoreSignature);
646 assert(exception->signature == MagickCoreSignature);
647 if (IsEventLogging() != MagickFalse)
648 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
649 bounding_box=image->page;
650 if ((bounding_box.width == 0) || (bounding_box.height == 0))
652 bounding_box.width=image->columns;
653 bounding_box.height=image->rows;
657 page.width=bounding_box.width;
658 if (page.height == 0)
659 page.height=bounding_box.height;
660 if (((bounding_box.x-page.x) >= (ssize_t) page.width) ||
661 ((bounding_box.y-page.y) >= (ssize_t) page.height) ||
662 ((page.x-bounding_box.x) > (ssize_t) image->columns) ||
663 ((page.y-bounding_box.y) > (ssize_t) image->rows))
668 (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
669 "GeometryDoesNotContainImage",
"`%s'",image->filename);
670 crop_image=CloneImage(image,1,1,MagickTrue,exception);
671 if (crop_image == (
Image *) NULL)
672 return((
Image *) NULL);
673 crop_image->background_color.opacity=(Quantum) TransparentOpacity;
674 (void) SetImageBackgroundColor(crop_image);
675 crop_image->page=bounding_box;
676 crop_image->page.x=(-1);
677 crop_image->page.y=(-1);
678 if (crop_image->dispose == BackgroundDispose)
679 crop_image->dispose=NoneDispose;
682 if ((page.x < 0) && (bounding_box.x >= 0))
684 page.width+=page.x-bounding_box.x;
689 page.width-=bounding_box.x-page.x;
690 page.x-=bounding_box.x;
694 if ((page.y < 0) && (bounding_box.y >= 0))
696 page.height+=page.y-bounding_box.y;
701 page.height-=bounding_box.y-page.y;
702 page.y-=bounding_box.y;
706 if ((page.x+(ssize_t) page.width) > (ssize_t) image->columns)
707 page.width=image->columns-page.x;
708 if ((geometry->width != 0) && (page.width > geometry->width))
709 page.width=geometry->width;
710 if ((page.y+(ssize_t) page.height) > (ssize_t) image->rows)
711 page.height=image->rows-page.y;
712 if ((geometry->height != 0) && (page.height > geometry->height))
713 page.height=geometry->height;
714 bounding_box.x+=page.x;
715 bounding_box.y+=page.y;
716 if ((page.width == 0) || (page.height == 0))
718 (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
719 "GeometryDoesNotContainImage",
"`%s'",image->filename);
720 return((
Image *) NULL);
725 crop_image=CloneImage(image,page.width,page.height,MagickTrue,exception);
726 if (crop_image == (
Image *) NULL)
727 return((
Image *) NULL);
728 crop_image->page.width=image->page.width;
729 crop_image->page.height=image->page.height;
730 if (((ssize_t) (bounding_box.x+bounding_box.width) > (ssize_t) image->page.width) ||
731 ((ssize_t) (bounding_box.y+bounding_box.height) > (ssize_t) image->page.height))
733 crop_image->page.width=bounding_box.width;
734 crop_image->page.height=bounding_box.height;
736 crop_image->page.x=bounding_box.x;
737 crop_image->page.y=bounding_box.y;
743 image_view=AcquireVirtualCacheView(image,exception);
744 crop_view=AcquireAuthenticCacheView(crop_image,exception);
745 #if defined(MAGICKCORE_OPENMP_SUPPORT)
746 #pragma omp parallel for schedule(static) shared(status) \
747 magick_number_threads(image,crop_image,crop_image->rows,1)
749 for (y=0; y < (ssize_t) crop_image->rows; y++)
752 *magick_restrict indexes;
758 *magick_restrict crop_indexes;
763 if (status == MagickFalse)
765 p=GetCacheViewVirtualPixels(image_view,page.x,page.y+y,crop_image->columns,
767 q=QueueCacheViewAuthenticPixels(crop_view,0,y,crop_image->columns,1,
774 indexes=GetCacheViewVirtualIndexQueue(image_view);
775 crop_indexes=GetCacheViewAuthenticIndexQueue(crop_view);
776 (void) memcpy(q,p,(
size_t) crop_image->columns*
sizeof(*p));
777 if ((indexes != (IndexPacket *) NULL) &&
778 (crop_indexes != (IndexPacket *) NULL))
779 (
void) memcpy(crop_indexes,indexes,(
size_t) crop_image->columns*
780 sizeof(*crop_indexes));
781 if (SyncCacheViewAuthenticPixels(crop_view,exception) == MagickFalse)
783 if (image->progress_monitor != (MagickProgressMonitor) NULL)
788 #if defined(MAGICKCORE_OPENMP_SUPPORT)
792 proceed=SetImageProgress(image,CropImageTag,progress,image->rows);
793 if (proceed == MagickFalse)
797 crop_view=DestroyCacheView(crop_view);
798 image_view=DestroyCacheView(image_view);
799 crop_image->type=image->type;
800 if (status == MagickFalse)
801 crop_image=DestroyImage(crop_image);
833 static inline ssize_t PixelRoundOffset(
double x)
838 if ((x-floor(x)) < (ceil(x)-x))
839 return(CastDoubleToLong(floor(x)));
840 return(CastDoubleToLong(ceil(x)));
843 MagickExport
Image *CropImageToTiles(
const Image *image,
856 assert(image != (
Image *) NULL);
857 assert(image->signature == MagickCoreSignature);
858 if (IsEventLogging() != MagickFalse)
859 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
860 flags=ParseGravityGeometry(image,crop_geometry,&geometry,exception);
861 if ((flags & AreaValue) != 0)
877 crop_image=NewImageList();
878 width=image->columns;
880 if (geometry.width == 0)
882 if (geometry.height == 0)
884 if ((flags & AspectValue) == 0)
886 width-=(geometry.x < 0 ? -1 : 1)*geometry.x;
887 height-=(geometry.y < 0 ? -1 : 1)*geometry.y;
891 width+=(geometry.x < 0 ? -1 : 1)*geometry.x;
892 height+=(geometry.y < 0 ? -1 : 1)*geometry.y;
894 delta.x=(double) width/geometry.width;
895 delta.y=(
double) height/geometry.height;
900 for (offset.y=0; offset.y < (
double) height; )
902 if ((flags & AspectValue) == 0)
904 crop.y=PixelRoundOffset((MagickRealType) (offset.y-
905 (geometry.y > 0 ? 0 : geometry.y)));
907 crop.height=(size_t) PixelRoundOffset((MagickRealType) (offset.y+
908 (geometry.y < 0 ? 0 : geometry.y)));
912 crop.y=PixelRoundOffset((MagickRealType) (offset.y-
913 (geometry.y > 0 ? geometry.y : 0)));
915 crop.height=(size_t) PixelRoundOffset((MagickRealType) (offset.y+
916 (geometry.y < 0 ? geometry.y : 0)));
919 crop.y+=image->page.y;
920 for (offset.x=0; offset.x < (
double) width; )
922 if ((flags & AspectValue) == 0)
924 crop.x=PixelRoundOffset((MagickRealType) (offset.x-
925 (geometry.x > 0 ? 0 : geometry.x)));
927 crop.width=(size_t) PixelRoundOffset((MagickRealType) (offset.x+
928 (geometry.x < 0 ? 0 : geometry.x)));
932 crop.x=PixelRoundOffset((MagickRealType) (offset.x-
933 (geometry.x > 0 ? geometry.x : 0)));
935 crop.width=(size_t) PixelRoundOffset((MagickRealType) (offset.x+
936 (geometry.x < 0 ? geometry.x : 0)));
939 crop.x+=image->page.x;
940 next=CropImage(image,&crop,exception);
941 if (next != (
Image *) NULL)
942 AppendImageToList(&crop_image,next);
945 ClearMagickException(exception);
948 if (((geometry.width == 0) && (geometry.height == 0)) ||
949 ((flags & XValue) != 0) || ((flags & YValue) != 0))
954 crop_image=CropImage(image,&geometry,exception);
955 if ((crop_image != (
Image *) NULL) && ((flags & AspectValue) != 0))
957 crop_image->page.width=geometry.width;
958 crop_image->page.height=geometry.height;
959 crop_image->page.x-=geometry.x;
960 crop_image->page.y-=geometry.y;
964 if ((image->columns > geometry.width) || (image->rows > geometry.height))
982 page.width=image->columns;
983 if (page.height == 0)
984 page.height=image->rows;
985 width=geometry.width;
988 height=geometry.height;
991 crop_image=NewImageList();
993 for (y=0; y < (ssize_t) page.height; y+=(ssize_t) height)
995 for (x=0; x < (ssize_t) page.width; x+=(ssize_t) width)
997 geometry.width=width;
998 geometry.height=height;
1001 next=CropImage(image,&geometry,exception);
1002 if (next == (
Image *) NULL)
1004 AppendImageToList(&crop_image,next);
1006 if (next == (
Image *) NULL)
1011 return(CloneImage(image,0,0,MagickTrue,exception));
1042 MagickExport
Image *ExcerptImage(
const Image *image,
1045 #define ExcerptImageTag "Excerpt/Image"
1066 assert(image != (
const Image *) NULL);
1067 assert(image->signature == MagickCoreSignature);
1070 assert(exception->signature == MagickCoreSignature);
1071 if (IsEventLogging() != MagickFalse)
1072 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1073 excerpt_image=CloneImage(image,geometry->width,geometry->height,MagickTrue,
1075 if (excerpt_image == (
Image *) NULL)
1076 return((
Image *) NULL);
1082 image_view=AcquireVirtualCacheView(image,exception);
1083 excerpt_view=AcquireAuthenticCacheView(excerpt_image,exception);
1084 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1085 #pragma omp parallel for schedule(static) shared(progress,status) \
1086 magick_number_threads(image,excerpt_image,excerpt_image->rows,1)
1088 for (y=0; y < (ssize_t) excerpt_image->rows; y++)
1094 *magick_restrict excerpt_indexes,
1095 *magick_restrict indexes;
1100 if (status == MagickFalse)
1102 p=GetCacheViewVirtualPixels(image_view,geometry->x,geometry->y+y,
1103 geometry->width,1,exception);
1104 q=GetCacheViewAuthenticPixels(excerpt_view,0,y,excerpt_image->columns,1,
1111 (void) memcpy(q,p,(
size_t) excerpt_image->columns*
sizeof(*q));
1112 indexes=GetCacheViewAuthenticIndexQueue(image_view);
1113 if (indexes != (IndexPacket *) NULL)
1115 excerpt_indexes=GetCacheViewAuthenticIndexQueue(excerpt_view);
1116 if (excerpt_indexes != (IndexPacket *) NULL)
1117 (void) memcpy(excerpt_indexes,indexes,(
size_t)
1118 excerpt_image->columns*
sizeof(*excerpt_indexes));
1120 if (SyncCacheViewAuthenticPixels(excerpt_view,exception) == MagickFalse)
1122 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1127 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1131 proceed=SetImageProgress(image,ExcerptImageTag,progress,image->rows);
1132 if (proceed == MagickFalse)
1136 excerpt_view=DestroyCacheView(excerpt_view);
1137 image_view=DestroyCacheView(image_view);
1138 excerpt_image->type=image->type;
1139 if (status == MagickFalse)
1140 excerpt_image=DestroyImage(excerpt_image);
1141 return(excerpt_image);
1174 MagickExport
Image *ExtentImage(
const Image *image,
1186 assert(image != (
const Image *) NULL);
1187 assert(image->signature == MagickCoreSignature);
1190 assert(exception->signature == MagickCoreSignature);
1191 if (IsEventLogging() != MagickFalse)
1192 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1193 extent_image=CloneImage(image,geometry->width,geometry->height,MagickTrue,
1195 if (extent_image == (
Image *) NULL)
1196 return((
Image *) NULL);
1197 (void) DeleteImageProfile(extent_image,
"8bim");
1198 status=SetImageBackgroundColor(extent_image);
1199 if (status == MagickFalse)
1201 InheritException(exception,&extent_image->exception);
1202 extent_image=DestroyImage(extent_image);
1203 return((
Image *) NULL);
1205 status=CompositeImage(extent_image,image->compose,image,-geometry->x,
1207 if (status == MagickFalse)
1209 InheritException(exception,&extent_image->exception);
1210 extent_image=DestroyImage(extent_image);
1211 return((
Image *) NULL);
1213 return(extent_image);
1243 #define FlipImageTag "Flip/Image"
1264 assert(image != (
const Image *) NULL);
1265 assert(image->signature == MagickCoreSignature);
1267 assert(exception->signature == MagickCoreSignature);
1268 if (IsEventLogging() != MagickFalse)
1269 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1270 flip_image=CloneImage(image,0,0,MagickTrue,exception);
1271 if (flip_image == (
Image *) NULL)
1272 return((
Image *) NULL);
1279 image_view=AcquireVirtualCacheView(image,exception);
1280 flip_view=AcquireAuthenticCacheView(flip_image,exception);
1281 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1282 #pragma omp parallel for schedule(static) shared(status) \
1283 magick_number_threads(image,flip_image,flip_image->rows,1)
1285 for (y=0; y < (ssize_t) flip_image->rows; y++)
1288 *magick_restrict indexes;
1294 *magick_restrict flip_indexes;
1299 if (status == MagickFalse)
1301 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
1302 q=QueueCacheViewAuthenticPixels(flip_view,0,(ssize_t) (flip_image->rows-y-
1303 1),flip_image->columns,1,exception);
1309 (void) memcpy(q,p,(
size_t) image->columns*
sizeof(*q));
1310 indexes=GetCacheViewVirtualIndexQueue(image_view);
1311 if (indexes != (
const IndexPacket *) NULL)
1313 flip_indexes=GetCacheViewAuthenticIndexQueue(flip_view);
1314 if (flip_indexes != (IndexPacket *) NULL)
1315 (void) memcpy(flip_indexes,indexes,(
size_t) image->columns*
1316 sizeof(*flip_indexes));
1318 if (SyncCacheViewAuthenticPixels(flip_view,exception) == MagickFalse)
1320 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1325 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1329 proceed=SetImageProgress(image,FlipImageTag,progress,image->rows);
1330 if (proceed == MagickFalse)
1334 flip_view=DestroyCacheView(flip_view);
1335 image_view=DestroyCacheView(image_view);
1336 flip_image->type=image->type;
1337 if (page.height != 0)
1338 page.y=(ssize_t) (page.height-flip_image->rows-page.y);
1339 flip_image->page=page;
1340 if (status == MagickFalse)
1341 flip_image=DestroyImage(flip_image);
1372 #define FlopImageTag "Flop/Image"
1393 assert(image != (
const Image *) NULL);
1394 assert(image->signature == MagickCoreSignature);
1396 assert(exception->signature == MagickCoreSignature);
1397 if (IsEventLogging() != MagickFalse)
1398 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1399 flop_image=CloneImage(image,0,0,MagickTrue,exception);
1400 if (flop_image == (
Image *) NULL)
1401 return((
Image *) NULL);
1408 image_view=AcquireVirtualCacheView(image,exception);
1409 flop_view=AcquireAuthenticCacheView(flop_image,exception);
1410 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1411 #pragma omp parallel for schedule(static) shared(status) \
1412 magick_number_threads(image,flop_image,flop_image->rows,1)
1414 for (y=0; y < (ssize_t) flop_image->rows; y++)
1417 *magick_restrict indexes;
1423 *magick_restrict flop_indexes;
1431 if (status == MagickFalse)
1433 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
1434 q=QueueCacheViewAuthenticPixels(flop_view,0,y,flop_image->columns,1,
1441 q+=flop_image->columns;
1442 indexes=GetCacheViewVirtualIndexQueue(image_view);
1443 flop_indexes=GetCacheViewAuthenticIndexQueue(flop_view);
1444 for (x=0; x < (ssize_t) flop_image->columns; x++)
1447 if ((indexes != (
const IndexPacket *) NULL) &&
1448 (flop_indexes != (IndexPacket *) NULL))
1449 SetPixelIndex(flop_indexes+flop_image->columns-x-1,
1450 GetPixelIndex(indexes+x));
1452 if (SyncCacheViewAuthenticPixels(flop_view,exception) == MagickFalse)
1454 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1459 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1463 proceed=SetImageProgress(image,FlopImageTag,progress,image->rows);
1464 if (proceed == MagickFalse)
1468 flop_view=DestroyCacheView(flop_view);
1469 image_view=DestroyCacheView(image_view);
1470 flop_image->type=image->type;
1471 if (page.width != 0)
1472 page.x=(ssize_t) (page.width-flop_image->columns-page.x);
1473 flop_image->page=page;
1474 if (status == MagickFalse)
1475 flop_image=DestroyImage(flop_image);
1509 static MagickBooleanType CopyImageRegion(
Image *destination,
const Image *source,
const size_t columns,
const size_t rows,
const ssize_t sx,
const ssize_t sy,
1525 source_view=AcquireVirtualCacheView(source,exception);
1526 destination_view=AcquireAuthenticCacheView(destination,exception);
1527 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1528 #pragma omp parallel for schedule(static) shared(status) \
1529 magick_number_threads(source,destination,rows,1)
1531 for (y=0; y < (ssize_t) rows; y++)
1537 *magick_restrict indexes;
1543 *magick_restrict destination_indexes;
1551 if (status == MagickFalse)
1553 p=GetCacheViewVirtualPixels(source_view,sx,sy+y,columns,1,exception);
1554 q=GetCacheViewAuthenticPixels(destination_view,dx,dy+y,columns,1,exception);
1560 indexes=GetCacheViewVirtualIndexQueue(source_view);
1561 (void) memcpy(q,p,(
size_t) columns*
sizeof(*p));
1562 if (indexes != (IndexPacket *) NULL)
1564 destination_indexes=GetCacheViewAuthenticIndexQueue(destination_view);
1565 if (destination_indexes != (IndexPacket *) NULL)
1566 (void) memcpy(destination_indexes,indexes,(
size_t)
1567 columns*
sizeof(*indexes));
1569 sync=SyncCacheViewAuthenticPixels(destination_view,exception);
1570 if (sync == MagickFalse)
1573 destination_view=DestroyCacheView(destination_view);
1574 source_view=DestroyCacheView(source_view);
1578 MagickExport
Image *RollImage(
const Image *image,
const ssize_t x_offset,
1581 #define RollImageTag "Roll/Image"
1595 assert(image != (
const Image *) NULL);
1596 assert(image->signature == MagickCoreSignature);
1598 assert(exception->signature == MagickCoreSignature);
1599 if (IsEventLogging() != MagickFalse)
1600 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1601 roll_image=CloneImage(image,0,0,MagickTrue,exception);
1602 if (roll_image == (
Image *) NULL)
1603 return((
Image *) NULL);
1606 while (offset.x < 0)
1607 offset.x+=(ssize_t) image->columns;
1608 while (offset.x >= (ssize_t) image->columns)
1609 offset.x-=(ssize_t) image->columns;
1610 while (offset.y < 0)
1611 offset.y+=(ssize_t) image->rows;
1612 while (offset.y >= (ssize_t) image->rows)
1613 offset.y-=(ssize_t) image->rows;
1617 status=CopyImageRegion(roll_image,image,(
size_t) offset.x,
1618 (
size_t) offset.y,(ssize_t) image->columns-offset.x,(ssize_t) image->rows-
1619 offset.y,0,0,exception);
1620 (void) SetImageProgress(image,RollImageTag,0,3);
1621 status&=CopyImageRegion(roll_image,image,image->columns-offset.x,
1622 (
size_t) offset.y,0,(ssize_t) image->rows-offset.y,offset.x,0,
1624 (void) SetImageProgress(image,RollImageTag,1,3);
1625 status&=CopyImageRegion(roll_image,image,(
size_t) offset.x,image->rows-
1626 offset.y,(ssize_t) image->columns-offset.x,0,0,offset.y,exception);
1627 (void) SetImageProgress(image,RollImageTag,2,3);
1628 status&=CopyImageRegion(roll_image,image,image->columns-offset.x,image->rows-
1629 offset.y,0,0,offset.x,offset.y,exception);
1630 (void) SetImageProgress(image,RollImageTag,3,3);
1631 roll_image->type=image->type;
1632 if (status == MagickFalse)
1633 roll_image=DestroyImage(roll_image);
1671 MagickExport
Image *ShaveImage(
const Image *image,
1680 assert(image != (
const Image *) NULL);
1681 assert(image->signature == MagickCoreSignature);
1682 if (IsEventLogging() != MagickFalse)
1683 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1684 if (((2*shave_info->width) >= image->columns) ||
1685 ((2*shave_info->height) >= image->rows))
1686 ThrowImageException(OptionWarning,
"GeometryDoesNotContainImage");
1687 SetGeometry(image,&geometry);
1688 geometry.width-=2*shave_info->width;
1689 geometry.height-=2*shave_info->height;
1690 geometry.x=(ssize_t) shave_info->width+image->page.x;
1691 geometry.y=(ssize_t) shave_info->height+image->page.y;
1692 shave_image=CropImage(image,&geometry,exception);
1693 if (shave_image == (
Image *) NULL)
1694 return((
Image *) NULL);
1695 shave_image->page.width-=2*shave_info->width;
1696 shave_image->page.height-=2*shave_info->height;
1697 shave_image->page.x-=(ssize_t) shave_info->width;
1698 shave_image->page.y-=(ssize_t) shave_info->height;
1699 return(shave_image);
1731 MagickExport
Image *SpliceImage(
const Image *image,
1734 #define SpliceImageTag "Splice/Image"
1759 assert(image != (
const Image *) NULL);
1760 assert(image->signature == MagickCoreSignature);
1763 assert(exception->signature == MagickCoreSignature);
1764 if (IsEventLogging() != MagickFalse)
1765 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1766 splice_geometry=(*geometry);
1767 splice_image=CloneImage(image,image->columns+splice_geometry.width,
1768 image->rows+splice_geometry.height,MagickTrue,exception);
1769 if (splice_image == (
Image *) NULL)
1770 return((
Image *) NULL);
1771 if (SetImageStorageClass(splice_image,DirectClass) == MagickFalse)
1773 InheritException(exception,&splice_image->exception);
1774 splice_image=DestroyImage(splice_image);
1775 return((
Image *) NULL);
1777 (void) SetImageBackgroundColor(splice_image);
1781 switch (image->gravity)
1784 case UndefinedGravity:
1785 case NorthWestGravity:
1789 splice_geometry.x+=(ssize_t) splice_geometry.width/2;
1792 case NorthEastGravity:
1794 splice_geometry.x+=(ssize_t) splice_geometry.width;
1799 splice_geometry.y+=(ssize_t) splice_geometry.width/2;
1805 splice_geometry.x+=(ssize_t) splice_geometry.width/2;
1806 splice_geometry.y+=(ssize_t) splice_geometry.height/2;
1811 splice_geometry.x+=(ssize_t) splice_geometry.width;
1812 splice_geometry.y+=(ssize_t) splice_geometry.height/2;
1815 case SouthWestGravity:
1817 splice_geometry.y+=(ssize_t) splice_geometry.height;
1822 splice_geometry.x+=(ssize_t) splice_geometry.width/2;
1823 splice_geometry.y+=(ssize_t) splice_geometry.height;
1826 case SouthEastGravity:
1828 splice_geometry.x+=(ssize_t) splice_geometry.width;
1829 splice_geometry.y+=(ssize_t) splice_geometry.height;
1838 columns=MagickMin(splice_geometry.x,(ssize_t) splice_image->columns);
1839 image_view=AcquireVirtualCacheView(image,exception);
1840 splice_view=AcquireAuthenticCacheView(splice_image,exception);
1841 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1842 #pragma omp parallel for schedule(static) shared(progress,status) \
1843 magick_number_threads(image,splice_image,splice_geometry.y,1)
1845 for (y=0; y < (ssize_t) splice_geometry.y; y++)
1851 *magick_restrict indexes,
1852 *magick_restrict splice_indexes;
1860 if (status == MagickFalse)
1862 p=GetCacheViewVirtualPixels(image_view,0,y,splice_image->columns,1,
1864 q=QueueCacheViewAuthenticPixels(splice_view,0,y,splice_image->columns,1,
1871 indexes=GetCacheViewAuthenticIndexQueue(image_view);
1872 splice_indexes=GetCacheViewAuthenticIndexQueue(splice_view);
1873 for (x=0; x < columns; x++)
1875 SetPixelRed(q,GetPixelRed(p));
1876 SetPixelGreen(q,GetPixelGreen(p));
1877 SetPixelBlue(q,GetPixelBlue(p));
1878 SetPixelOpacity(q,OpaqueOpacity);
1879 if (image->matte != MagickFalse)
1880 SetPixelOpacity(q,GetPixelOpacity(p));
1881 if (image->colorspace == CMYKColorspace)
1882 SetPixelIndex(splice_indexes+x,GetPixelIndex(indexes));
1887 for ( ; x < (ssize_t) (splice_geometry.x+splice_geometry.width); x++)
1889 for ( ; x < (ssize_t) splice_image->columns; x++)
1891 SetPixelRed(q,GetPixelRed(p));
1892 SetPixelGreen(q,GetPixelGreen(p));
1893 SetPixelBlue(q,GetPixelBlue(p));
1894 SetPixelOpacity(q,OpaqueOpacity);
1895 if (image->matte != MagickFalse)
1896 SetPixelOpacity(q,GetPixelOpacity(p));
1897 if (image->colorspace == CMYKColorspace)
1898 SetPixelIndex(splice_indexes+x,GetPixelIndex(indexes));
1903 if (SyncCacheViewAuthenticPixels(splice_view,exception) == MagickFalse)
1905 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1910 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1914 proceed=SetImageProgress(image,SpliceImageTag,progress,
1915 splice_image->rows);
1916 if (proceed == MagickFalse)
1920 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1921 #pragma omp parallel for schedule(static) shared(progress,status) \
1922 magick_number_threads(image,splice_image,splice_image->rows,1)
1924 for (y=(ssize_t) (splice_geometry.y+splice_geometry.height);
1925 y < (ssize_t) splice_image->rows; y++)
1931 *magick_restrict indexes,
1932 *magick_restrict splice_indexes;
1940 if (status == MagickFalse)
1942 if ((y < 0) || (y >= (ssize_t)splice_image->rows))
1944 p=GetCacheViewVirtualPixels(image_view,0,y-(ssize_t) splice_geometry.height,
1945 splice_image->columns,1,exception);
1946 q=QueueCacheViewAuthenticPixels(splice_view,0,y,splice_image->columns,1,
1953 indexes=GetCacheViewAuthenticIndexQueue(image_view);
1954 splice_indexes=GetCacheViewAuthenticIndexQueue(splice_view);
1955 for (x=0; x < columns; x++)
1957 SetPixelRed(q,GetPixelRed(p));
1958 SetPixelGreen(q,GetPixelGreen(p));
1959 SetPixelBlue(q,GetPixelBlue(p));
1960 SetPixelOpacity(q,OpaqueOpacity);
1961 if (image->matte != MagickFalse)
1962 SetPixelOpacity(q,GetPixelOpacity(p));
1963 if (image->colorspace == CMYKColorspace)
1964 SetPixelIndex(splice_indexes+x,GetPixelIndex(indexes));
1969 for ( ; x < (ssize_t) (splice_geometry.x+splice_geometry.width); x++)
1971 for ( ; x < (ssize_t) splice_image->columns; x++)
1973 SetPixelRed(q,GetPixelRed(p));
1974 SetPixelGreen(q,GetPixelGreen(p));
1975 SetPixelBlue(q,GetPixelBlue(p));
1976 SetPixelOpacity(q,OpaqueOpacity);
1977 if (image->matte != MagickFalse)
1978 SetPixelOpacity(q,GetPixelOpacity(p));
1979 if (image->colorspace == CMYKColorspace)
1980 SetPixelIndex(splice_indexes+x,GetPixelIndex(indexes));
1985 if (SyncCacheViewAuthenticPixels(splice_view,exception) == MagickFalse)
1987 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1992 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1996 proceed=SetImageProgress(image,SpliceImageTag,progress,
1997 splice_image->rows);
1998 if (proceed == MagickFalse)
2002 splice_view=DestroyCacheView(splice_view);
2003 image_view=DestroyCacheView(image_view);
2004 if (status == MagickFalse)
2005 splice_image=DestroyImage(splice_image);
2006 return(splice_image);
2056 MagickExport MagickBooleanType TransformImage(
Image **image,
2057 const char *crop_geometry,
const char *image_geometry)
2069 assert(image != (
Image **) NULL);
2070 assert((*image)->signature == MagickCoreSignature);
2071 if (IsEventLogging() != MagickFalse)
2072 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",(*image)->filename);
2073 transform_image=(*image);
2074 if (crop_geometry != (
const char *) NULL)
2082 crop_image=CropImageToTiles(*image,crop_geometry,&(*image)->exception);
2083 if (crop_image == (
Image *) NULL)
2084 transform_image=CloneImage(*image,0,0,MagickTrue,&(*image)->exception);
2087 transform_image=DestroyImage(transform_image);
2088 transform_image=GetFirstImageInList(crop_image);
2090 *image=transform_image;
2092 if (image_geometry == (
const char *) NULL)
2098 flags=ParseRegionGeometry(transform_image,image_geometry,&geometry,
2099 &(*image)->exception);
2101 if ((transform_image->columns == geometry.width) &&
2102 (transform_image->rows == geometry.height))
2104 resize_image=ResizeImage(transform_image,geometry.width,geometry.height,
2105 transform_image->filter,transform_image->blur,&(*image)->exception);
2106 if (resize_image == (
Image *) NULL)
2107 return(MagickFalse);
2108 transform_image=DestroyImage(transform_image);
2109 transform_image=resize_image;
2110 *image=transform_image;
2143 MagickExport MagickBooleanType TransformImages(
Image **images,
2144 const char *crop_geometry,
const char *image_geometry)
2157 assert(images != (
Image **) NULL);
2158 assert((*images)->signature == MagickCoreSignature);
2159 if (IsEventLogging() != MagickFalse)
2160 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
2161 (*images)->filename);
2162 image_list=ImageListToArray(*images,&(*images)->exception);
2163 if (image_list == (
Image **) NULL)
2164 return(MagickFalse);
2166 transform_images=NewImageList();
2167 for (i=0; image_list[i] != (
Image *) NULL; i++)
2169 image=image_list[i];
2170 status&=TransformImage(&image,crop_geometry,image_geometry);
2171 AppendImageToList(&transform_images,image);
2173 *images=transform_images;
2174 image_list=(
Image **) RelinquishMagickMemory(image_list);
2175 return(status != 0 ? MagickTrue : MagickFalse);
2205 #define TransposeImageTag "Transpose/Image"
2226 assert(image != (
const Image *) NULL);
2227 assert(image->signature == MagickCoreSignature);
2228 if (IsEventLogging() != MagickFalse)
2229 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2231 assert(exception->signature == MagickCoreSignature);
2232 transpose_image=CloneImage(image,image->rows,image->columns,MagickTrue,
2234 if (transpose_image == (
Image *) NULL)
2235 return((
Image *) NULL);
2241 image_view=AcquireVirtualCacheView(image,exception);
2242 transpose_view=AcquireAuthenticCacheView(transpose_image,exception);
2243 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2244 #pragma omp parallel for schedule(static) shared(progress,status) \
2245 magick_number_threads(image,transpose_image,image->rows,1)
2247 for (y=0; y < (ssize_t) image->rows; y++)
2253 *magick_restrict transpose_indexes,
2254 *magick_restrict indexes;
2259 if (status == MagickFalse)
2261 p=GetCacheViewVirtualPixels(image_view,0,(ssize_t) image->rows-y-1,
2262 image->columns,1,exception);
2263 q=QueueCacheViewAuthenticPixels(transpose_view,(ssize_t) (image->rows-y-1),
2264 0,1,transpose_image->rows,exception);
2270 (void) memcpy(q,p,(
size_t) image->columns*
sizeof(*q));
2271 indexes=GetCacheViewAuthenticIndexQueue(image_view);
2272 if (indexes != (IndexPacket *) NULL)
2274 transpose_indexes=GetCacheViewAuthenticIndexQueue(transpose_view);
2275 if (transpose_indexes != (IndexPacket *) NULL)
2276 (void) memcpy(transpose_indexes,indexes,(
size_t)
2277 image->columns*
sizeof(*transpose_indexes));
2279 if (SyncCacheViewAuthenticPixels(transpose_view,exception) == MagickFalse)
2281 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2286 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2290 proceed=SetImageProgress(image,TransposeImageTag,progress,
2292 if (proceed == MagickFalse)
2296 transpose_view=DestroyCacheView(transpose_view);
2297 image_view=DestroyCacheView(image_view);
2298 transpose_image->type=image->type;
2299 page=transpose_image->page;
2300 Swap(page.width,page.height);
2301 Swap(page.x,page.y);
2302 transpose_image->page=page;
2303 if (status == MagickFalse)
2304 transpose_image=DestroyImage(transpose_image);
2305 return(transpose_image);
2335 #define TransverseImageTag "Transverse/Image"
2356 assert(image != (
const Image *) NULL);
2357 assert(image->signature == MagickCoreSignature);
2358 if (IsEventLogging() != MagickFalse)
2359 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2361 assert(exception->signature == MagickCoreSignature);
2362 transverse_image=CloneImage(image,image->rows,image->columns,MagickTrue,
2364 if (transverse_image == (
Image *) NULL)
2365 return((
Image *) NULL);
2371 image_view=AcquireVirtualCacheView(image,exception);
2372 transverse_view=AcquireAuthenticCacheView(transverse_image,exception);
2373 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2374 #pragma omp parallel for schedule(static) shared(progress,status) \
2375 magick_number_threads(image,transverse_image,image->rows,1)
2377 for (y=0; y < (ssize_t) image->rows; y++)
2386 *magick_restrict transverse_indexes,
2387 *magick_restrict indexes;
2395 if (status == MagickFalse)
2397 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
2398 q=QueueCacheViewAuthenticPixels(transverse_view,(ssize_t) (image->rows-y-
2399 1),0,1,transverse_image->rows,exception);
2406 for (x=0; x < (ssize_t) image->columns; x++)
2408 indexes=GetCacheViewAuthenticIndexQueue(image_view);
2409 if (indexes != (IndexPacket *) NULL)
2411 transverse_indexes=GetCacheViewAuthenticIndexQueue(transverse_view);
2412 if (transverse_indexes != (IndexPacket *) NULL)
2413 for (x=0; x < (ssize_t) image->columns; x++)
2414 SetPixelIndex(transverse_indexes+image->columns-x-1,
2415 GetPixelIndex(indexes+x));
2417 sync=SyncCacheViewAuthenticPixels(transverse_view,exception);
2418 if (sync == MagickFalse)
2420 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2425 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2429 proceed=SetImageProgress(image,TransverseImageTag,progress,image->rows);
2430 if (proceed == MagickFalse)
2434 transverse_view=DestroyCacheView(transverse_view);
2435 image_view=DestroyCacheView(image_view);
2436 transverse_image->type=image->type;
2437 page=transverse_image->page;
2438 Swap(page.width,page.height);
2439 Swap(page.x,page.y);
2440 if (page.width != 0)
2441 page.x=(ssize_t) (page.width-transverse_image->columns-page.x);
2442 if (page.height != 0)
2443 page.y=(ssize_t) (page.height-transverse_image->rows-page.y);
2444 transverse_image->page=page;
2445 if (status == MagickFalse)
2446 transverse_image=DestroyImage(transverse_image);
2447 return(transverse_image);
2481 assert(image != (
const Image *) NULL);
2482 assert(image->signature == MagickCoreSignature);
2483 if (IsEventLogging() != MagickFalse)
2484 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2485 geometry=GetImageBoundingBox(image,exception);
2486 if ((geometry.width == 0) || (geometry.height == 0))
2491 crop_image=CloneImage(image,1,1,MagickTrue,exception);
2492 if (crop_image == (
Image *) NULL)
2493 return((
Image *) NULL);
2494 crop_image->background_color.opacity=(Quantum) TransparentOpacity;
2495 (void) SetImageBackgroundColor(crop_image);
2496 crop_image->page=image->page;
2497 crop_image->page.x=(-1);
2498 crop_image->page.y=(-1);
2501 geometry.x+=image->page.x;
2502 geometry.y+=image->page.y;
2503 return(CropImage(image,&geometry,exception));