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 if ((extent.width >= image->columns) || (extent.height >= image->rows))
243 ThrowImageException(OptionWarning,
"GeometryDoesNotContainImage");
244 chop_image=CloneImage(image,image->columns-extent.width,image->rows-
245 extent.height,MagickTrue,exception);
246 if (chop_image == (
Image *) NULL)
247 return((
Image *) NULL);
253 image_view=AcquireVirtualCacheView(image,exception);
254 chop_view=AcquireAuthenticCacheView(chop_image,exception);
255 #if defined(MAGICKCORE_OPENMP_SUPPORT)
256 #pragma omp parallel for schedule(static) shared(status) \
257 magick_number_threads(image,chop_image,extent.y,1)
259 for (y=0; y < (ssize_t) extent.y; y++)
265 *magick_restrict chop_indexes,
266 *magick_restrict indexes;
274 if (status == MagickFalse)
276 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
277 q=QueueCacheViewAuthenticPixels(chop_view,0,y,chop_image->columns,1,
284 indexes=GetCacheViewAuthenticIndexQueue(image_view);
285 chop_indexes=GetCacheViewAuthenticIndexQueue(chop_view);
286 for (x=0; x < (ssize_t) image->columns; x++)
288 if ((x < extent.x) || (x >= (ssize_t) (extent.x+extent.width)))
291 if (indexes != (IndexPacket *) NULL)
293 if (chop_indexes != (IndexPacket *) NULL)
294 *chop_indexes++=GetPixelIndex(indexes+x);
300 if (SyncCacheViewAuthenticPixels(chop_view,exception) == MagickFalse)
302 if (image->progress_monitor != (MagickProgressMonitor) NULL)
307 #if defined(MAGICKCORE_OPENMP_SUPPORT)
311 proceed=SetImageProgress(image,ChopImageTag,progress,image->rows);
312 if (proceed == MagickFalse)
319 #if defined(MAGICKCORE_OPENMP_SUPPORT)
320 #pragma omp parallel for schedule(static) shared(status) \
321 magick_number_threads(image,image,image->rows,1)
323 for (y=0; y < (ssize_t) (image->rows-(extent.y+extent.height)); y++)
329 *magick_restrict chop_indexes,
330 *magick_restrict indexes;
338 if (status == MagickFalse)
340 p=GetCacheViewVirtualPixels(image_view,0,extent.y+extent.height+y,
341 image->columns,1,exception);
342 q=QueueCacheViewAuthenticPixels(chop_view,0,extent.y+y,chop_image->columns,
349 indexes=GetCacheViewAuthenticIndexQueue(image_view);
350 chop_indexes=GetCacheViewAuthenticIndexQueue(chop_view);
351 for (x=0; x < (ssize_t) image->columns; x++)
353 if ((x < extent.x) || (x >= (ssize_t) (extent.x+extent.width)))
356 if (indexes != (IndexPacket *) NULL)
358 if (chop_indexes != (IndexPacket *) NULL)
359 *chop_indexes++=GetPixelIndex(indexes+x);
365 if (SyncCacheViewAuthenticPixels(chop_view,exception) == MagickFalse)
367 if (image->progress_monitor != (MagickProgressMonitor) NULL)
372 #if defined(MAGICKCORE_OPENMP_SUPPORT)
376 proceed=SetImageProgress(image,ChopImageTag,progress,image->rows);
377 if (proceed == MagickFalse)
381 chop_view=DestroyCacheView(chop_view);
382 image_view=DestroyCacheView(image_view);
383 chop_image->type=image->type;
384 if (status == MagickFalse)
385 chop_image=DestroyImage(chop_image);
414 MagickExport
Image *ConsolidateCMYKImages(
const Image *images,
434 assert(images != (
Image *) NULL);
435 assert(images->signature == MagickCoreSignature);
437 assert(exception->signature == MagickCoreSignature);
438 if (IsEventLogging() != MagickFalse)
439 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",images->filename);
440 cmyk_images=NewImageList();
441 for (i=0; i < (ssize_t) GetImageListLength(images); i+=4)
443 cmyk_image=CloneImage(images,0,0,MagickTrue,exception);
444 if (cmyk_image == (
Image *) NULL)
446 if (SetImageStorageClass(cmyk_image,DirectClass) == MagickFalse)
448 (void) SetImageColorspace(cmyk_image,CMYKColorspace);
449 image_view=AcquireVirtualCacheView(images,exception);
450 cmyk_view=AcquireAuthenticCacheView(cmyk_image,exception);
451 for (y=0; y < (ssize_t) images->rows; y++)
462 p=GetCacheViewVirtualPixels(image_view,0,y,images->columns,1,exception);
463 q=QueueCacheViewAuthenticPixels(cmyk_view,0,y,cmyk_image->columns,1,
467 for (x=0; x < (ssize_t) images->columns; x++)
469 SetPixelRed(q,ClampToQuantum(QuantumRange-GetPixelIntensity(images,p)));
473 if (SyncCacheViewAuthenticPixels(cmyk_view,exception) == MagickFalse)
476 cmyk_view=DestroyCacheView(cmyk_view);
477 image_view=DestroyCacheView(image_view);
478 images=GetNextImageInList(images);
479 if (images == (
Image *) NULL)
481 image_view=AcquireVirtualCacheView(images,exception);
482 cmyk_view=AcquireAuthenticCacheView(cmyk_image,exception);
483 for (y=0; y < (ssize_t) images->rows; y++)
494 p=GetCacheViewVirtualPixels(image_view,0,y,images->columns,1,exception);
495 q=GetCacheViewAuthenticPixels(cmyk_view,0,y,cmyk_image->columns,1,
499 for (x=0; x < (ssize_t) images->columns; x++)
501 q->green=ClampToQuantum(QuantumRange-GetPixelIntensity(images,p));
505 if (SyncCacheViewAuthenticPixels(cmyk_view,exception) == MagickFalse)
508 cmyk_view=DestroyCacheView(cmyk_view);
509 image_view=DestroyCacheView(image_view);
510 images=GetNextImageInList(images);
511 if (images == (
Image *) NULL)
513 image_view=AcquireVirtualCacheView(images,exception);
514 cmyk_view=AcquireAuthenticCacheView(cmyk_image,exception);
515 for (y=0; y < (ssize_t) images->rows; y++)
526 p=GetCacheViewVirtualPixels(image_view,0,y,images->columns,1,exception);
527 q=GetCacheViewAuthenticPixels(cmyk_view,0,y,cmyk_image->columns,1,
531 for (x=0; x < (ssize_t) images->columns; x++)
533 q->blue=ClampToQuantum(QuantumRange-GetPixelIntensity(images,p));
537 if (SyncCacheViewAuthenticPixels(cmyk_view,exception) == MagickFalse)
540 cmyk_view=DestroyCacheView(cmyk_view);
541 image_view=DestroyCacheView(image_view);
542 images=GetNextImageInList(images);
543 if (images == (
Image *) NULL)
545 image_view=AcquireVirtualCacheView(images,exception);
546 cmyk_view=AcquireAuthenticCacheView(cmyk_image,exception);
547 for (y=0; y < (ssize_t) images->rows; y++)
553 *magick_restrict indexes;
561 p=GetCacheViewVirtualPixels(image_view,0,y,images->columns,1,exception);
562 q=GetCacheViewAuthenticPixels(cmyk_view,0,y,cmyk_image->columns,1,
566 indexes=GetCacheViewAuthenticIndexQueue(cmyk_view);
567 for (x=0; x < (ssize_t) images->columns; x++)
569 SetPixelIndex(indexes+x,ClampToQuantum(QuantumRange-
570 GetPixelIntensity(images,p)));
573 if (SyncCacheViewAuthenticPixels(cmyk_view,exception) == MagickFalse)
576 cmyk_view=DestroyCacheView(cmyk_view);
577 image_view=DestroyCacheView(image_view);
578 AppendImageToList(&cmyk_images,cmyk_image);
579 images=GetNextImageInList(images);
580 if (images == (
Image *) NULL)
619 #define CropImageTag "Crop/Image"
644 assert(image != (
const Image *) NULL);
645 assert(image->signature == MagickCoreSignature);
648 assert(exception->signature == MagickCoreSignature);
649 if (IsEventLogging() != MagickFalse)
650 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
651 bounding_box=image->page;
652 if ((bounding_box.width == 0) || (bounding_box.height == 0))
654 bounding_box.width=image->columns;
655 bounding_box.height=image->rows;
659 page.width=bounding_box.width;
660 if (page.height == 0)
661 page.height=bounding_box.height;
662 if (((bounding_box.x-page.x) >= (ssize_t) page.width) ||
663 ((bounding_box.y-page.y) >= (ssize_t) page.height) ||
664 ((page.x-bounding_box.x) > (ssize_t) image->columns) ||
665 ((page.y-bounding_box.y) > (ssize_t) image->rows))
670 (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
671 "GeometryDoesNotContainImage",
"`%s'",image->filename);
672 crop_image=CloneImage(image,1,1,MagickTrue,exception);
673 if (crop_image == (
Image *) NULL)
674 return((
Image *) NULL);
675 crop_image->background_color.opacity=(Quantum) TransparentOpacity;
676 (void) SetImageBackgroundColor(crop_image);
677 crop_image->page=bounding_box;
678 crop_image->page.x=(-1);
679 crop_image->page.y=(-1);
680 if (crop_image->dispose == BackgroundDispose)
681 crop_image->dispose=NoneDispose;
684 if ((page.x < 0) && (bounding_box.x >= 0))
686 page.width+=page.x-bounding_box.x;
691 page.width-=bounding_box.x-page.x;
692 page.x-=bounding_box.x;
696 if ((page.y < 0) && (bounding_box.y >= 0))
698 page.height+=page.y-bounding_box.y;
703 page.height-=bounding_box.y-page.y;
704 page.y-=bounding_box.y;
708 if ((page.x+(ssize_t) page.width) > (ssize_t) image->columns)
709 page.width=image->columns-page.x;
710 if ((geometry->width != 0) && (page.width > geometry->width))
711 page.width=geometry->width;
712 if ((page.y+(ssize_t) page.height) > (ssize_t) image->rows)
713 page.height=image->rows-page.y;
714 if ((geometry->height != 0) && (page.height > geometry->height))
715 page.height=geometry->height;
716 bounding_box.x+=page.x;
717 bounding_box.y+=page.y;
718 if ((page.width == 0) || (page.height == 0))
720 (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
721 "GeometryDoesNotContainImage",
"`%s'",image->filename);
722 return((
Image *) NULL);
727 crop_image=CloneImage(image,page.width,page.height,MagickTrue,exception);
728 if (crop_image == (
Image *) NULL)
729 return((
Image *) NULL);
730 crop_image->page.width=image->page.width;
731 crop_image->page.height=image->page.height;
732 if (((ssize_t) (bounding_box.x+bounding_box.width) > (ssize_t) image->page.width) ||
733 ((ssize_t) (bounding_box.y+bounding_box.height) > (ssize_t) image->page.height))
735 crop_image->page.width=bounding_box.width;
736 crop_image->page.height=bounding_box.height;
738 crop_image->page.x=bounding_box.x;
739 crop_image->page.y=bounding_box.y;
745 image_view=AcquireVirtualCacheView(image,exception);
746 crop_view=AcquireAuthenticCacheView(crop_image,exception);
747 #if defined(MAGICKCORE_OPENMP_SUPPORT)
748 #pragma omp parallel for schedule(static) shared(status) \
749 magick_number_threads(image,crop_image,crop_image->rows,1)
751 for (y=0; y < (ssize_t) crop_image->rows; y++)
754 *magick_restrict indexes;
760 *magick_restrict crop_indexes;
765 if (status == MagickFalse)
767 p=GetCacheViewVirtualPixels(image_view,page.x,page.y+y,crop_image->columns,
769 q=QueueCacheViewAuthenticPixels(crop_view,0,y,crop_image->columns,1,
776 indexes=GetCacheViewVirtualIndexQueue(image_view);
777 crop_indexes=GetCacheViewAuthenticIndexQueue(crop_view);
778 (void) memcpy(q,p,(
size_t) crop_image->columns*
sizeof(*p));
779 if ((indexes != (IndexPacket *) NULL) &&
780 (crop_indexes != (IndexPacket *) NULL))
781 (
void) memcpy(crop_indexes,indexes,(
size_t) crop_image->columns*
782 sizeof(*crop_indexes));
783 if (SyncCacheViewAuthenticPixels(crop_view,exception) == MagickFalse)
785 if (image->progress_monitor != (MagickProgressMonitor) NULL)
790 #if defined(MAGICKCORE_OPENMP_SUPPORT)
794 proceed=SetImageProgress(image,CropImageTag,progress,image->rows);
795 if (proceed == MagickFalse)
799 crop_view=DestroyCacheView(crop_view);
800 image_view=DestroyCacheView(image_view);
801 crop_image->type=image->type;
802 if (status == MagickFalse)
803 crop_image=DestroyImage(crop_image);
835 static inline ssize_t PixelRoundOffset(
double x)
840 if ((x-floor(x)) < (ceil(x)-x))
841 return(CastDoubleToLong(floor(x)));
842 return(CastDoubleToLong(ceil(x)));
845 MagickExport
Image *CropImageToTiles(
const Image *image,
858 assert(image != (
Image *) NULL);
859 assert(image->signature == MagickCoreSignature);
860 if (IsEventLogging() != MagickFalse)
861 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
862 flags=ParseGravityGeometry(image,crop_geometry,&geometry,exception);
863 if ((flags & AreaValue) != 0)
879 crop_image=NewImageList();
880 width=image->columns;
882 if (geometry.width == 0)
884 if (geometry.height == 0)
886 if ((flags & AspectValue) == 0)
888 width-=(geometry.x < 0 ? -1 : 1)*geometry.x;
889 height-=(geometry.y < 0 ? -1 : 1)*geometry.y;
893 width+=(geometry.x < 0 ? -1 : 1)*geometry.x;
894 height+=(geometry.y < 0 ? -1 : 1)*geometry.y;
896 delta.x=(double) width/geometry.width;
897 delta.y=(
double) height/geometry.height;
902 for (offset.y=0; offset.y < (
double) height; )
904 if ((flags & AspectValue) == 0)
906 crop.y=PixelRoundOffset((MagickRealType) (offset.y-
907 (geometry.y > 0 ? 0 : geometry.y)));
909 crop.height=(size_t) PixelRoundOffset((MagickRealType) (offset.y+
910 (geometry.y < 0 ? 0 : geometry.y)));
914 crop.y=PixelRoundOffset((MagickRealType) (offset.y-
915 (geometry.y > 0 ? geometry.y : 0)));
917 crop.height=(size_t) PixelRoundOffset((MagickRealType) (offset.y+
918 (geometry.y < 0 ? geometry.y : 0)));
921 crop.y+=image->page.y;
922 for (offset.x=0; offset.x < (
double) width; )
924 if ((flags & AspectValue) == 0)
926 crop.x=PixelRoundOffset((MagickRealType) (offset.x-
927 (geometry.x > 0 ? 0 : geometry.x)));
929 crop.width=(size_t) PixelRoundOffset((MagickRealType) (offset.x+
930 (geometry.x < 0 ? 0 : geometry.x)));
934 crop.x=PixelRoundOffset((MagickRealType) (offset.x-
935 (geometry.x > 0 ? geometry.x : 0)));
937 crop.width=(size_t) PixelRoundOffset((MagickRealType) (offset.x+
938 (geometry.x < 0 ? geometry.x : 0)));
941 crop.x+=image->page.x;
942 next=CropImage(image,&crop,exception);
943 if (next != (
Image *) NULL)
944 AppendImageToList(&crop_image,next);
947 ClearMagickException(exception);
950 if (((geometry.width == 0) && (geometry.height == 0)) ||
951 ((flags & XValue) != 0) || ((flags & YValue) != 0))
956 crop_image=CropImage(image,&geometry,exception);
957 if ((crop_image != (
Image *) NULL) && ((flags & AspectValue) != 0))
959 crop_image->page.width=geometry.width;
960 crop_image->page.height=geometry.height;
961 crop_image->page.x-=geometry.x;
962 crop_image->page.y-=geometry.y;
966 if ((image->columns > geometry.width) || (image->rows > geometry.height))
984 page.width=image->columns;
985 if (page.height == 0)
986 page.height=image->rows;
987 width=geometry.width;
990 height=geometry.height;
993 crop_image=NewImageList();
995 for (y=0; y < (ssize_t) page.height; y+=(ssize_t) height)
997 for (x=0; x < (ssize_t) page.width; x+=(ssize_t) width)
999 geometry.width=width;
1000 geometry.height=height;
1003 next=CropImage(image,&geometry,exception);
1004 if (next == (
Image *) NULL)
1006 AppendImageToList(&crop_image,next);
1008 if (next == (
Image *) NULL)
1013 return(CloneImage(image,0,0,MagickTrue,exception));
1044 MagickExport
Image *ExcerptImage(
const Image *image,
1047 #define ExcerptImageTag "Excerpt/Image"
1068 assert(image != (
const Image *) NULL);
1069 assert(image->signature == MagickCoreSignature);
1072 assert(exception->signature == MagickCoreSignature);
1073 if (IsEventLogging() != MagickFalse)
1074 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1075 excerpt_image=CloneImage(image,geometry->width,geometry->height,MagickTrue,
1077 if (excerpt_image == (
Image *) NULL)
1078 return((
Image *) NULL);
1084 image_view=AcquireVirtualCacheView(image,exception);
1085 excerpt_view=AcquireAuthenticCacheView(excerpt_image,exception);
1086 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1087 #pragma omp parallel for schedule(static) shared(progress,status) \
1088 magick_number_threads(image,excerpt_image,excerpt_image->rows,1)
1090 for (y=0; y < (ssize_t) excerpt_image->rows; y++)
1096 *magick_restrict excerpt_indexes,
1097 *magick_restrict indexes;
1102 if (status == MagickFalse)
1104 p=GetCacheViewVirtualPixels(image_view,geometry->x,geometry->y+y,
1105 geometry->width,1,exception);
1106 q=GetCacheViewAuthenticPixels(excerpt_view,0,y,excerpt_image->columns,1,
1113 (void) memcpy(q,p,(
size_t) excerpt_image->columns*
sizeof(*q));
1114 indexes=GetCacheViewAuthenticIndexQueue(image_view);
1115 if (indexes != (IndexPacket *) NULL)
1117 excerpt_indexes=GetCacheViewAuthenticIndexQueue(excerpt_view);
1118 if (excerpt_indexes != (IndexPacket *) NULL)
1119 (void) memcpy(excerpt_indexes,indexes,(
size_t)
1120 excerpt_image->columns*
sizeof(*excerpt_indexes));
1122 if (SyncCacheViewAuthenticPixels(excerpt_view,exception) == MagickFalse)
1124 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1129 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1133 proceed=SetImageProgress(image,ExcerptImageTag,progress,image->rows);
1134 if (proceed == MagickFalse)
1138 excerpt_view=DestroyCacheView(excerpt_view);
1139 image_view=DestroyCacheView(image_view);
1140 excerpt_image->type=image->type;
1141 if (status == MagickFalse)
1142 excerpt_image=DestroyImage(excerpt_image);
1143 return(excerpt_image);
1176 MagickExport
Image *ExtentImage(
const Image *image,
1188 assert(image != (
const Image *) NULL);
1189 assert(image->signature == MagickCoreSignature);
1192 assert(exception->signature == MagickCoreSignature);
1193 if (IsEventLogging() != MagickFalse)
1194 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1195 extent_image=CloneImage(image,geometry->width,geometry->height,MagickTrue,
1197 if (extent_image == (
Image *) NULL)
1198 return((
Image *) NULL);
1199 (void) DeleteImageProfile(extent_image,
"8bim");
1200 status=SetImageBackgroundColor(extent_image);
1201 if (status == MagickFalse)
1203 InheritException(exception,&extent_image->exception);
1204 extent_image=DestroyImage(extent_image);
1205 return((
Image *) NULL);
1207 status=CompositeImage(extent_image,image->compose,image,-geometry->x,
1209 if (status == MagickFalse)
1211 InheritException(exception,&extent_image->exception);
1212 extent_image=DestroyImage(extent_image);
1213 return((
Image *) NULL);
1215 return(extent_image);
1245 #define FlipImageTag "Flip/Image"
1266 assert(image != (
const Image *) NULL);
1267 assert(image->signature == MagickCoreSignature);
1269 assert(exception->signature == MagickCoreSignature);
1270 if (IsEventLogging() != MagickFalse)
1271 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1272 flip_image=CloneImage(image,0,0,MagickTrue,exception);
1273 if (flip_image == (
Image *) NULL)
1274 return((
Image *) NULL);
1281 image_view=AcquireVirtualCacheView(image,exception);
1282 flip_view=AcquireAuthenticCacheView(flip_image,exception);
1283 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1284 #pragma omp parallel for schedule(static) shared(status) \
1285 magick_number_threads(image,flip_image,flip_image->rows,1)
1287 for (y=0; y < (ssize_t) flip_image->rows; y++)
1290 *magick_restrict indexes;
1296 *magick_restrict flip_indexes;
1301 if (status == MagickFalse)
1303 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
1304 q=QueueCacheViewAuthenticPixels(flip_view,0,(ssize_t) (flip_image->rows-y-
1305 1),flip_image->columns,1,exception);
1311 (void) memcpy(q,p,(
size_t) image->columns*
sizeof(*q));
1312 indexes=GetCacheViewVirtualIndexQueue(image_view);
1313 if (indexes != (
const IndexPacket *) NULL)
1315 flip_indexes=GetCacheViewAuthenticIndexQueue(flip_view);
1316 if (flip_indexes != (IndexPacket *) NULL)
1317 (void) memcpy(flip_indexes,indexes,(
size_t) image->columns*
1318 sizeof(*flip_indexes));
1320 if (SyncCacheViewAuthenticPixels(flip_view,exception) == MagickFalse)
1322 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1327 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1331 proceed=SetImageProgress(image,FlipImageTag,progress,image->rows);
1332 if (proceed == MagickFalse)
1336 flip_view=DestroyCacheView(flip_view);
1337 image_view=DestroyCacheView(image_view);
1338 flip_image->type=image->type;
1339 if (page.height != 0)
1340 page.y=(ssize_t) (page.height-flip_image->rows-page.y);
1341 flip_image->page=page;
1342 if (status == MagickFalse)
1343 flip_image=DestroyImage(flip_image);
1374 #define FlopImageTag "Flop/Image"
1395 assert(image != (
const Image *) NULL);
1396 assert(image->signature == MagickCoreSignature);
1398 assert(exception->signature == MagickCoreSignature);
1399 if (IsEventLogging() != MagickFalse)
1400 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1401 flop_image=CloneImage(image,0,0,MagickTrue,exception);
1402 if (flop_image == (
Image *) NULL)
1403 return((
Image *) NULL);
1410 image_view=AcquireVirtualCacheView(image,exception);
1411 flop_view=AcquireAuthenticCacheView(flop_image,exception);
1412 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1413 #pragma omp parallel for schedule(static) shared(status) \
1414 magick_number_threads(image,flop_image,flop_image->rows,1)
1416 for (y=0; y < (ssize_t) flop_image->rows; y++)
1419 *magick_restrict indexes;
1425 *magick_restrict flop_indexes;
1433 if (status == MagickFalse)
1435 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
1436 q=QueueCacheViewAuthenticPixels(flop_view,0,y,flop_image->columns,1,
1443 q+=flop_image->columns;
1444 indexes=GetCacheViewVirtualIndexQueue(image_view);
1445 flop_indexes=GetCacheViewAuthenticIndexQueue(flop_view);
1446 for (x=0; x < (ssize_t) flop_image->columns; x++)
1449 if ((indexes != (
const IndexPacket *) NULL) &&
1450 (flop_indexes != (IndexPacket *) NULL))
1451 SetPixelIndex(flop_indexes+flop_image->columns-x-1,
1452 GetPixelIndex(indexes+x));
1454 if (SyncCacheViewAuthenticPixels(flop_view,exception) == MagickFalse)
1456 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1461 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1465 proceed=SetImageProgress(image,FlopImageTag,progress,image->rows);
1466 if (proceed == MagickFalse)
1470 flop_view=DestroyCacheView(flop_view);
1471 image_view=DestroyCacheView(image_view);
1472 flop_image->type=image->type;
1473 if (page.width != 0)
1474 page.x=(ssize_t) (page.width-flop_image->columns-page.x);
1475 flop_image->page=page;
1476 if (status == MagickFalse)
1477 flop_image=DestroyImage(flop_image);
1511 static MagickBooleanType CopyImageRegion(
Image *destination,
const Image *source,
const size_t columns,
const size_t rows,
const ssize_t sx,
const ssize_t sy,
1527 source_view=AcquireVirtualCacheView(source,exception);
1528 destination_view=AcquireAuthenticCacheView(destination,exception);
1529 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1530 #pragma omp parallel for schedule(static) shared(status) \
1531 magick_number_threads(source,destination,rows,1)
1533 for (y=0; y < (ssize_t) rows; y++)
1539 *magick_restrict indexes;
1545 *magick_restrict destination_indexes;
1553 if (status == MagickFalse)
1555 p=GetCacheViewVirtualPixels(source_view,sx,sy+y,columns,1,exception);
1556 q=GetCacheViewAuthenticPixels(destination_view,dx,dy+y,columns,1,exception);
1562 indexes=GetCacheViewVirtualIndexQueue(source_view);
1563 (void) memcpy(q,p,(
size_t) columns*
sizeof(*p));
1564 if (indexes != (IndexPacket *) NULL)
1566 destination_indexes=GetCacheViewAuthenticIndexQueue(destination_view);
1567 if (destination_indexes != (IndexPacket *) NULL)
1568 (void) memcpy(destination_indexes,indexes,(
size_t)
1569 columns*
sizeof(*indexes));
1571 sync=SyncCacheViewAuthenticPixels(destination_view,exception);
1572 if (sync == MagickFalse)
1575 destination_view=DestroyCacheView(destination_view);
1576 source_view=DestroyCacheView(source_view);
1580 MagickExport
Image *RollImage(
const Image *image,
const ssize_t x_offset,
1583 #define RollImageTag "Roll/Image"
1597 assert(image != (
const Image *) NULL);
1598 assert(image->signature == MagickCoreSignature);
1600 assert(exception->signature == MagickCoreSignature);
1601 if (IsEventLogging() != MagickFalse)
1602 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1603 roll_image=CloneImage(image,0,0,MagickTrue,exception);
1604 if (roll_image == (
Image *) NULL)
1605 return((
Image *) NULL);
1608 while (offset.x < 0)
1609 offset.x+=(ssize_t) image->columns;
1610 while (offset.x >= (ssize_t) image->columns)
1611 offset.x-=(ssize_t) image->columns;
1612 while (offset.y < 0)
1613 offset.y+=(ssize_t) image->rows;
1614 while (offset.y >= (ssize_t) image->rows)
1615 offset.y-=(ssize_t) image->rows;
1619 status=CopyImageRegion(roll_image,image,(
size_t) offset.x,
1620 (
size_t) offset.y,(ssize_t) image->columns-offset.x,(ssize_t) image->rows-
1621 offset.y,0,0,exception);
1622 (void) SetImageProgress(image,RollImageTag,0,3);
1623 status&=CopyImageRegion(roll_image,image,image->columns-offset.x,
1624 (
size_t) offset.y,0,(ssize_t) image->rows-offset.y,offset.x,0,
1626 (void) SetImageProgress(image,RollImageTag,1,3);
1627 status&=CopyImageRegion(roll_image,image,(
size_t) offset.x,image->rows-
1628 offset.y,(ssize_t) image->columns-offset.x,0,0,offset.y,exception);
1629 (void) SetImageProgress(image,RollImageTag,2,3);
1630 status&=CopyImageRegion(roll_image,image,image->columns-offset.x,image->rows-
1631 offset.y,0,0,offset.x,offset.y,exception);
1632 (void) SetImageProgress(image,RollImageTag,3,3);
1633 roll_image->type=image->type;
1634 if (status == MagickFalse)
1635 roll_image=DestroyImage(roll_image);
1673 MagickExport
Image *ShaveImage(
const Image *image,
1682 assert(image != (
const Image *) NULL);
1683 assert(image->signature == MagickCoreSignature);
1684 if (IsEventLogging() != MagickFalse)
1685 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1686 if (((2*shave_info->width) >= image->columns) ||
1687 ((2*shave_info->height) >= image->rows))
1688 ThrowImageException(OptionWarning,
"GeometryDoesNotContainImage");
1689 SetGeometry(image,&geometry);
1690 geometry.width-=2*shave_info->width;
1691 geometry.height-=2*shave_info->height;
1692 geometry.x=(ssize_t) shave_info->width+image->page.x;
1693 geometry.y=(ssize_t) shave_info->height+image->page.y;
1694 shave_image=CropImage(image,&geometry,exception);
1695 if (shave_image == (
Image *) NULL)
1696 return((
Image *) NULL);
1697 shave_image->page.width-=2*shave_info->width;
1698 shave_image->page.height-=2*shave_info->height;
1699 shave_image->page.x-=(ssize_t) shave_info->width;
1700 shave_image->page.y-=(ssize_t) shave_info->height;
1701 return(shave_image);
1733 MagickExport
Image *SpliceImage(
const Image *image,
1736 #define SpliceImageTag "Splice/Image"
1761 assert(image != (
const Image *) NULL);
1762 assert(image->signature == MagickCoreSignature);
1765 assert(exception->signature == MagickCoreSignature);
1766 if (IsEventLogging() != MagickFalse)
1767 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1768 splice_geometry=(*geometry);
1769 splice_image=CloneImage(image,image->columns+splice_geometry.width,
1770 image->rows+splice_geometry.height,MagickTrue,exception);
1771 if (splice_image == (
Image *) NULL)
1772 return((
Image *) NULL);
1773 if (SetImageStorageClass(splice_image,DirectClass) == MagickFalse)
1775 InheritException(exception,&splice_image->exception);
1776 splice_image=DestroyImage(splice_image);
1777 return((
Image *) NULL);
1779 (void) SetImageBackgroundColor(splice_image);
1783 switch (image->gravity)
1786 case UndefinedGravity:
1787 case NorthWestGravity:
1791 splice_geometry.x+=(ssize_t) splice_geometry.width/2;
1794 case NorthEastGravity:
1796 splice_geometry.x+=(ssize_t) splice_geometry.width;
1801 splice_geometry.y+=(ssize_t) splice_geometry.width/2;
1807 splice_geometry.x+=(ssize_t) splice_geometry.width/2;
1808 splice_geometry.y+=(ssize_t) splice_geometry.height/2;
1813 splice_geometry.x+=(ssize_t) splice_geometry.width;
1814 splice_geometry.y+=(ssize_t) splice_geometry.height/2;
1817 case SouthWestGravity:
1819 splice_geometry.y+=(ssize_t) splice_geometry.height;
1824 splice_geometry.x+=(ssize_t) splice_geometry.width/2;
1825 splice_geometry.y+=(ssize_t) splice_geometry.height;
1828 case SouthEastGravity:
1830 splice_geometry.x+=(ssize_t) splice_geometry.width;
1831 splice_geometry.y+=(ssize_t) splice_geometry.height;
1840 columns=MagickMin(splice_geometry.x,(ssize_t) splice_image->columns);
1841 image_view=AcquireVirtualCacheView(image,exception);
1842 splice_view=AcquireAuthenticCacheView(splice_image,exception);
1843 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1844 #pragma omp parallel for schedule(static) shared(progress,status) \
1845 magick_number_threads(image,splice_image,splice_geometry.y,1)
1847 for (y=0; y < (ssize_t) splice_geometry.y; y++)
1853 *magick_restrict indexes,
1854 *magick_restrict splice_indexes;
1862 if (status == MagickFalse)
1864 p=GetCacheViewVirtualPixels(image_view,0,y,splice_image->columns,1,
1866 q=QueueCacheViewAuthenticPixels(splice_view,0,y,splice_image->columns,1,
1873 indexes=GetCacheViewAuthenticIndexQueue(image_view);
1874 splice_indexes=GetCacheViewAuthenticIndexQueue(splice_view);
1875 for (x=0; x < columns; x++)
1877 SetPixelRed(q,GetPixelRed(p));
1878 SetPixelGreen(q,GetPixelGreen(p));
1879 SetPixelBlue(q,GetPixelBlue(p));
1880 SetPixelOpacity(q,OpaqueOpacity);
1881 if (image->matte != MagickFalse)
1882 SetPixelOpacity(q,GetPixelOpacity(p));
1883 if (image->colorspace == CMYKColorspace)
1884 SetPixelIndex(splice_indexes+x,GetPixelIndex(indexes));
1889 for ( ; x < (ssize_t) (splice_geometry.x+splice_geometry.width); x++)
1891 for ( ; x < (ssize_t) splice_image->columns; x++)
1893 SetPixelRed(q,GetPixelRed(p));
1894 SetPixelGreen(q,GetPixelGreen(p));
1895 SetPixelBlue(q,GetPixelBlue(p));
1896 SetPixelOpacity(q,OpaqueOpacity);
1897 if (image->matte != MagickFalse)
1898 SetPixelOpacity(q,GetPixelOpacity(p));
1899 if (image->colorspace == CMYKColorspace)
1900 SetPixelIndex(splice_indexes+x,GetPixelIndex(indexes));
1905 if (SyncCacheViewAuthenticPixels(splice_view,exception) == MagickFalse)
1907 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1912 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1916 proceed=SetImageProgress(image,SpliceImageTag,progress,
1917 splice_image->rows);
1918 if (proceed == MagickFalse)
1922 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1923 #pragma omp parallel for schedule(static) shared(progress,status) \
1924 magick_number_threads(image,splice_image,splice_image->rows,1)
1926 for (y=(ssize_t) (splice_geometry.y+splice_geometry.height);
1927 y < (ssize_t) splice_image->rows; y++)
1933 *magick_restrict indexes,
1934 *magick_restrict splice_indexes;
1942 if (status == MagickFalse)
1944 if ((y < 0) || (y >= (ssize_t)splice_image->rows))
1946 p=GetCacheViewVirtualPixels(image_view,0,y-(ssize_t) splice_geometry.height,
1947 splice_image->columns,1,exception);
1948 q=QueueCacheViewAuthenticPixels(splice_view,0,y,splice_image->columns,1,
1955 indexes=GetCacheViewAuthenticIndexQueue(image_view);
1956 splice_indexes=GetCacheViewAuthenticIndexQueue(splice_view);
1957 for (x=0; x < columns; x++)
1959 SetPixelRed(q,GetPixelRed(p));
1960 SetPixelGreen(q,GetPixelGreen(p));
1961 SetPixelBlue(q,GetPixelBlue(p));
1962 SetPixelOpacity(q,OpaqueOpacity);
1963 if (image->matte != MagickFalse)
1964 SetPixelOpacity(q,GetPixelOpacity(p));
1965 if (image->colorspace == CMYKColorspace)
1966 SetPixelIndex(splice_indexes+x,GetPixelIndex(indexes));
1971 for ( ; x < (ssize_t) (splice_geometry.x+splice_geometry.width); x++)
1973 for ( ; x < (ssize_t) splice_image->columns; x++)
1975 SetPixelRed(q,GetPixelRed(p));
1976 SetPixelGreen(q,GetPixelGreen(p));
1977 SetPixelBlue(q,GetPixelBlue(p));
1978 SetPixelOpacity(q,OpaqueOpacity);
1979 if (image->matte != MagickFalse)
1980 SetPixelOpacity(q,GetPixelOpacity(p));
1981 if (image->colorspace == CMYKColorspace)
1982 SetPixelIndex(splice_indexes+x,GetPixelIndex(indexes));
1987 if (SyncCacheViewAuthenticPixels(splice_view,exception) == MagickFalse)
1989 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1994 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1998 proceed=SetImageProgress(image,SpliceImageTag,progress,
1999 splice_image->rows);
2000 if (proceed == MagickFalse)
2004 splice_view=DestroyCacheView(splice_view);
2005 image_view=DestroyCacheView(image_view);
2006 if (status == MagickFalse)
2007 splice_image=DestroyImage(splice_image);
2008 return(splice_image);
2058 MagickExport MagickBooleanType TransformImage(
Image **image,
2059 const char *crop_geometry,
const char *image_geometry)
2071 assert(image != (
Image **) NULL);
2072 assert((*image)->signature == MagickCoreSignature);
2073 if (IsEventLogging() != MagickFalse)
2074 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",(*image)->filename);
2075 transform_image=(*image);
2076 if (crop_geometry != (
const char *) NULL)
2084 crop_image=CropImageToTiles(*image,crop_geometry,&(*image)->exception);
2085 if (crop_image == (
Image *) NULL)
2086 transform_image=CloneImage(*image,0,0,MagickTrue,&(*image)->exception);
2089 transform_image=DestroyImage(transform_image);
2090 transform_image=GetFirstImageInList(crop_image);
2092 *image=transform_image;
2094 if (image_geometry == (
const char *) NULL)
2100 flags=ParseRegionGeometry(transform_image,image_geometry,&geometry,
2101 &(*image)->exception);
2103 if ((transform_image->columns == geometry.width) &&
2104 (transform_image->rows == geometry.height))
2106 resize_image=ResizeImage(transform_image,geometry.width,geometry.height,
2107 transform_image->filter,transform_image->blur,&(*image)->exception);
2108 if (resize_image == (
Image *) NULL)
2109 return(MagickFalse);
2110 transform_image=DestroyImage(transform_image);
2111 transform_image=resize_image;
2112 *image=transform_image;
2145 MagickExport MagickBooleanType TransformImages(
Image **images,
2146 const char *crop_geometry,
const char *image_geometry)
2159 assert(images != (
Image **) NULL);
2160 assert((*images)->signature == MagickCoreSignature);
2161 if (IsEventLogging() != MagickFalse)
2162 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
2163 (*images)->filename);
2164 image_list=ImageListToArray(*images,&(*images)->exception);
2165 if (image_list == (
Image **) NULL)
2166 return(MagickFalse);
2168 transform_images=NewImageList();
2169 for (i=0; image_list[i] != (
Image *) NULL; i++)
2171 image=image_list[i];
2172 status&=TransformImage(&image,crop_geometry,image_geometry);
2173 AppendImageToList(&transform_images,image);
2175 *images=transform_images;
2176 image_list=(
Image **) RelinquishMagickMemory(image_list);
2177 return(status != 0 ? MagickTrue : MagickFalse);
2207 #define TransposeImageTag "Transpose/Image"
2228 assert(image != (
const Image *) NULL);
2229 assert(image->signature == MagickCoreSignature);
2230 if (IsEventLogging() != MagickFalse)
2231 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2233 assert(exception->signature == MagickCoreSignature);
2234 transpose_image=CloneImage(image,image->rows,image->columns,MagickTrue,
2236 if (transpose_image == (
Image *) NULL)
2237 return((
Image *) NULL);
2243 image_view=AcquireVirtualCacheView(image,exception);
2244 transpose_view=AcquireAuthenticCacheView(transpose_image,exception);
2245 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2246 #pragma omp parallel for schedule(static) shared(progress,status) \
2247 magick_number_threads(image,transpose_image,image->rows,1)
2249 for (y=0; y < (ssize_t) image->rows; y++)
2255 *magick_restrict transpose_indexes,
2256 *magick_restrict indexes;
2261 if (status == MagickFalse)
2263 p=GetCacheViewVirtualPixels(image_view,0,(ssize_t) image->rows-y-1,
2264 image->columns,1,exception);
2265 q=QueueCacheViewAuthenticPixels(transpose_view,(ssize_t) (image->rows-y-1),
2266 0,1,transpose_image->rows,exception);
2272 (void) memcpy(q,p,(
size_t) image->columns*
sizeof(*q));
2273 indexes=GetCacheViewAuthenticIndexQueue(image_view);
2274 if (indexes != (IndexPacket *) NULL)
2276 transpose_indexes=GetCacheViewAuthenticIndexQueue(transpose_view);
2277 if (transpose_indexes != (IndexPacket *) NULL)
2278 (void) memcpy(transpose_indexes,indexes,(
size_t)
2279 image->columns*
sizeof(*transpose_indexes));
2281 if (SyncCacheViewAuthenticPixels(transpose_view,exception) == MagickFalse)
2283 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2288 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2292 proceed=SetImageProgress(image,TransposeImageTag,progress,
2294 if (proceed == MagickFalse)
2298 transpose_view=DestroyCacheView(transpose_view);
2299 image_view=DestroyCacheView(image_view);
2300 transpose_image->type=image->type;
2301 page=transpose_image->page;
2302 Swap(page.width,page.height);
2303 Swap(page.x,page.y);
2304 transpose_image->page=page;
2305 if (status == MagickFalse)
2306 transpose_image=DestroyImage(transpose_image);
2307 return(transpose_image);
2337 #define TransverseImageTag "Transverse/Image"
2358 assert(image != (
const Image *) NULL);
2359 assert(image->signature == MagickCoreSignature);
2360 if (IsEventLogging() != MagickFalse)
2361 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2363 assert(exception->signature == MagickCoreSignature);
2364 transverse_image=CloneImage(image,image->rows,image->columns,MagickTrue,
2366 if (transverse_image == (
Image *) NULL)
2367 return((
Image *) NULL);
2373 image_view=AcquireVirtualCacheView(image,exception);
2374 transverse_view=AcquireAuthenticCacheView(transverse_image,exception);
2375 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2376 #pragma omp parallel for schedule(static) shared(progress,status) \
2377 magick_number_threads(image,transverse_image,image->rows,1)
2379 for (y=0; y < (ssize_t) image->rows; y++)
2388 *magick_restrict transverse_indexes,
2389 *magick_restrict indexes;
2397 if (status == MagickFalse)
2399 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
2400 q=QueueCacheViewAuthenticPixels(transverse_view,(ssize_t) (image->rows-y-
2401 1),0,1,transverse_image->rows,exception);
2408 for (x=0; x < (ssize_t) image->columns; x++)
2410 indexes=GetCacheViewAuthenticIndexQueue(image_view);
2411 if (indexes != (IndexPacket *) NULL)
2413 transverse_indexes=GetCacheViewAuthenticIndexQueue(transverse_view);
2414 if (transverse_indexes != (IndexPacket *) NULL)
2415 for (x=0; x < (ssize_t) image->columns; x++)
2416 SetPixelIndex(transverse_indexes+image->columns-x-1,
2417 GetPixelIndex(indexes+x));
2419 sync=SyncCacheViewAuthenticPixels(transverse_view,exception);
2420 if (sync == MagickFalse)
2422 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2427 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2431 proceed=SetImageProgress(image,TransverseImageTag,progress,image->rows);
2432 if (proceed == MagickFalse)
2436 transverse_view=DestroyCacheView(transverse_view);
2437 image_view=DestroyCacheView(image_view);
2438 transverse_image->type=image->type;
2439 page=transverse_image->page;
2440 Swap(page.width,page.height);
2441 Swap(page.x,page.y);
2442 if (page.width != 0)
2443 page.x=(ssize_t) (page.width-transverse_image->columns-page.x);
2444 if (page.height != 0)
2445 page.y=(ssize_t) (page.height-transverse_image->rows-page.y);
2446 transverse_image->page=page;
2447 if (status == MagickFalse)
2448 transverse_image=DestroyImage(transverse_image);
2449 return(transverse_image);
2483 assert(image != (
const Image *) NULL);
2484 assert(image->signature == MagickCoreSignature);
2485 if (IsEventLogging() != MagickFalse)
2486 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2487 geometry=GetImageBoundingBox(image,exception);
2488 if ((geometry.width == 0) || (geometry.height == 0))
2493 crop_image=CloneImage(image,1,1,MagickTrue,exception);
2494 if (crop_image == (
Image *) NULL)
2495 return((
Image *) NULL);
2496 crop_image->background_color.opacity=(Quantum) TransparentOpacity;
2497 (void) SetImageBackgroundColor(crop_image);
2498 crop_image->page=image->page;
2499 crop_image->page.x=(-1);
2500 crop_image->page.y=(-1);
2503 geometry.x+=image->page.x;
2504 geometry.y+=image->page.y;
2505 return(CropImage(image,&geometry,exception));