42#include "MagickCore/studio.h"
43#include "MagickCore/attribute.h"
44#include "MagickCore/artifact.h"
45#include "MagickCore/cache.h"
46#include "MagickCore/cache-view.h"
47#include "MagickCore/color.h"
48#include "MagickCore/color-private.h"
49#include "MagickCore/colorspace-private.h"
50#include "MagickCore/composite.h"
51#include "MagickCore/composite-private.h"
52#include "MagickCore/distort.h"
53#include "MagickCore/draw.h"
54#include "MagickCore/effect.h"
55#include "MagickCore/exception.h"
56#include "MagickCore/exception-private.h"
57#include "MagickCore/geometry.h"
58#include "MagickCore/image.h"
59#include "MagickCore/memory_.h"
60#include "MagickCore/layer.h"
61#include "MagickCore/list.h"
62#include "MagickCore/monitor.h"
63#include "MagickCore/monitor-private.h"
64#include "MagickCore/pixel-accessor.h"
65#include "MagickCore/profile-private.h"
66#include "MagickCore/property.h"
67#include "MagickCore/resource_.h"
68#include "MagickCore/resize.h"
69#include "MagickCore/statistic.h"
70#include "MagickCore/string_.h"
71#include "MagickCore/thread-private.h"
72#include "MagickCore/transform.h"
73#include "MagickCore/transform-private.h"
103MagickExport Image *AutoOrientImage(
const Image *image,
104 const OrientationType orientation,ExceptionInfo *exception)
109 assert(image != (
const Image *) NULL);
110 assert(image->signature == MagickCoreSignature);
111 assert(exception != (ExceptionInfo *) NULL);
112 assert(exception->signature == MagickCoreSignature);
113 orient_image=(Image *) NULL;
116 case UndefinedOrientation:
117 case TopLeftOrientation:
120 orient_image=CloneImage(image,0,0,MagickTrue,exception);
123 case TopRightOrientation:
125 orient_image=FlopImage(image,exception);
128 case BottomRightOrientation:
130 orient_image=RotateImage(image,180.0,exception);
133 case BottomLeftOrientation:
135 orient_image=FlipImage(image,exception);
138 case LeftTopOrientation:
140 orient_image=TransposeImage(image,exception);
143 case RightTopOrientation:
145 orient_image=RotateImage(image,90.0,exception);
148 case RightBottomOrientation:
150 orient_image=TransverseImage(image,exception);
153 case LeftBottomOrientation:
155 orient_image=RotateImage(image,270.0,exception);
159 if (orient_image != (Image *) NULL)
160 orient_image->orientation=TopLeftOrientation;
161 return(orient_image);
192MagickExport Image *ChopImage(
const Image *image,
const RectangleInfo *chop_info,
193 ExceptionInfo *exception)
195#define ChopImageTag "Chop/Image"
219 assert(image != (
const Image *) NULL);
220 assert(image->signature == MagickCoreSignature);
221 assert(exception != (ExceptionInfo *) NULL);
222 assert(exception->signature == MagickCoreSignature);
223 assert(chop_info != (RectangleInfo *) NULL);
224 if (IsEventLogging() != MagickFalse)
225 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
226 if (((chop_info->x+(ssize_t) chop_info->width) < 0) ||
227 ((chop_info->y+(ssize_t) chop_info->height) < 0) ||
228 (chop_info->x > (ssize_t) image->columns) ||
229 (chop_info->y > (ssize_t) image->rows))
230 ThrowImageException(OptionWarning,
"GeometryDoesNotContainImage");
232 if ((extent.x+(ssize_t) extent.width) > (ssize_t) image->columns)
233 extent.width=(size_t) ((ssize_t) image->columns-extent.x);
234 if ((extent.y+(ssize_t) extent.height) > (ssize_t) image->rows)
235 extent.height=(size_t) ((ssize_t) image->rows-extent.y);
238 extent.width-=(size_t) (-extent.x);
243 extent.height-=(size_t) (-extent.y);
246 if ((extent.width >= image->columns) || (extent.height >= image->rows))
247 ThrowImageException(OptionWarning,
"GeometryDoesNotContainImage");
248 chop_image=CloneImage(image,image->columns-extent.width,image->rows-
249 extent.height,MagickTrue,exception);
250 if (chop_image == (Image *) NULL)
251 return((Image *) NULL);
257 image_view=AcquireVirtualCacheView(image,exception);
258 chop_view=AcquireAuthenticCacheView(chop_image,exception);
259#if defined(MAGICKCORE_OPENMP_SUPPORT)
260 #pragma omp parallel for schedule(static) shared(status) \
261 magick_number_threads(image,chop_image,(size_t) extent.y,2)
263 for (y=0; y < (ssize_t) extent.y; y++)
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,
279 if ((p == (
const Quantum *) NULL) || (q == (Quantum *) NULL))
284 for (x=0; x < (ssize_t) image->columns; x++)
286 if ((x < extent.x) || (x >= (extent.x+(ssize_t) extent.width)))
291 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
293 PixelChannel channel = GetPixelChannelChannel(image,i);
294 PixelTrait traits = GetPixelChannelTraits(image,channel);
295 PixelTrait chop_traits=GetPixelChannelTraits(chop_image,channel);
296 if ((traits == UndefinedPixelTrait) ||
297 (chop_traits == UndefinedPixelTrait))
299 SetPixelChannel(chop_image,channel,p[i],q);
301 q+=(ptrdiff_t) GetPixelChannels(chop_image);
303 p+=(ptrdiff_t) GetPixelChannels(image);
305 if (SyncCacheViewAuthenticPixels(chop_view,exception) == MagickFalse)
307 if (image->progress_monitor != (MagickProgressMonitor) NULL)
312#if defined(MAGICKCORE_OPENMP_SUPPORT)
316 proceed=SetImageProgress(image,ChopImageTag,progress,image->rows);
317 if (proceed == MagickFalse)
324#if defined(MAGICKCORE_OPENMP_SUPPORT)
325 #pragma omp parallel for schedule(static) shared(progress,status) \
326 magick_number_threads(image,chop_image,image->rows-((size_t) extent.y+extent.height),2)
328 for (y=0; y < (ssize_t) (image->rows-((size_t) extent.y+extent.height)); y++)
339 if (status == MagickFalse)
341 p=GetCacheViewVirtualPixels(image_view,0,extent.y+(ssize_t) extent.height+y,
342 image->columns,1,exception);
343 q=QueueCacheViewAuthenticPixels(chop_view,0,extent.y+y,chop_image->columns,
345 if ((p == (
const Quantum *) NULL) || (q == (Quantum *) NULL))
350 for (x=0; x < (ssize_t) image->columns; x++)
352 if ((x < extent.x) || (x >= (extent.x+(ssize_t) extent.width)))
357 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
359 PixelChannel channel = GetPixelChannelChannel(image,i);
360 PixelTrait traits = GetPixelChannelTraits(image,channel);
361 PixelTrait chop_traits=GetPixelChannelTraits(chop_image,channel);
362 if ((traits == UndefinedPixelTrait) ||
363 (chop_traits == UndefinedPixelTrait))
365 SetPixelChannel(chop_image,channel,p[i],q);
367 q+=(ptrdiff_t) GetPixelChannels(chop_image);
369 p+=(ptrdiff_t) GetPixelChannels(image);
371 if (SyncCacheViewAuthenticPixels(chop_view,exception) == MagickFalse)
373 if (image->progress_monitor != (MagickProgressMonitor) NULL)
378#if defined(MAGICKCORE_OPENMP_SUPPORT)
382 proceed=SetImageProgress(image,ChopImageTag,progress,image->rows);
383 if (proceed == MagickFalse)
387 chop_view=DestroyCacheView(chop_view);
388 image_view=DestroyCacheView(image_view);
389 chop_image->type=image->type;
390 if (status == MagickFalse)
391 chop_image=DestroyImage(chop_image);
420MagickExport Image *ConsolidateCMYKImages(
const Image *images,
421 ExceptionInfo *exception)
439 assert(images != (Image *) NULL);
440 assert(images->signature == MagickCoreSignature);
441 assert(exception != (ExceptionInfo *) NULL);
442 assert(exception->signature == MagickCoreSignature);
443 if (IsEventLogging() != MagickFalse)
444 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",images->filename);
445 cmyk_images=NewImageList();
446 p_image=GetFirstImageInList(images);
447 for (j=0; j < (ssize_t) GetImageListLength(p_image); j+=4)
459 for (i=0; i < 4; i++)
461 if (q_image == (
const Image *) NULL)
463 plane_images[i]=q_image;
464 q_image=GetNextImageInList(q_image);
468 ThrowMagickException(exception,GetMagickModule(),OptionError,
469 "ImagesAreNotTheSameSize",
"`%s'",p_image->filename);
472 if ((plane_images[1]->columns != plane_images[0]->columns) ||
473 (plane_images[1]->rows != plane_images[0]->rows) ||
474 (plane_images[2]->columns != plane_images[0]->columns) ||
475 (plane_images[2]->rows != plane_images[0]->rows) ||
476 (plane_images[3]->columns != plane_images[0]->columns) ||
477 (plane_images[3]->rows != plane_images[0]->rows))
479 ThrowMagickException(exception,GetMagickModule(),OptionError,
480 "ImagesAreNotTheSameSize",
"`%s'",p_image->filename);
483 cmyk_image=CloneImage(plane_images[0],0,0,MagickTrue,exception);
484 if (cmyk_image == (Image *) NULL)
486 if (SetImageStorageClass(cmyk_image,DirectClass,exception) == MagickFalse)
488 cmyk_image=DestroyImage(cmyk_image);
491 (void) SetImageColorspace(cmyk_image,CMYKColorspace,exception);
492 cmyk_view=AcquireAuthenticCacheView(cmyk_image,exception);
493 for (i=0; i < 4; i++)
495 image_view=AcquireVirtualCacheView(plane_images[i],exception);
496 for (y=0; y < (ssize_t) plane_images[i]->rows; y++)
507 p=GetCacheViewVirtualPixels(image_view,0,y,plane_images[i]->columns,1,
509 q=QueueCacheViewAuthenticPixels(cmyk_view,0,y,cmyk_image->columns,1,
511 if ((p == (
const Quantum *) NULL) || (q == (Quantum *) NULL))
513 for (x=0; x < (ssize_t) plane_images[i]->columns; x++)
518 pixel=ClampToQuantum((
double) QuantumRange-
519 GetPixelIntensity(plane_images[i],p));
522 case 0: SetPixelCyan(cmyk_image,pixel,q);
break;
523 case 1: SetPixelMagenta(cmyk_image,pixel,q);
break;
524 case 2: SetPixelYellow(cmyk_image,pixel,q);
break;
525 case 3: SetPixelBlack(cmyk_image,pixel,q);
break;
528 p+=(ptrdiff_t) GetPixelChannels(plane_images[i]);
529 q+=(ptrdiff_t) GetPixelChannels(cmyk_image);
532 image_view=DestroyCacheView(image_view);
534 if (SyncCacheViewAuthenticPixels(cmyk_view,exception) == MagickFalse)
536 cmyk_view=DestroyCacheView(cmyk_view);
537 cmyk_image=DestroyImage(cmyk_image);
540 cmyk_view=DestroyCacheView(cmyk_view);
541 AppendImageToList(&cmyk_images,cmyk_image);
542 for (i=0; (i < 4) && (p_image != (Image *) NULL); i++)
543 p_image=GetNextImageInList(p_image);
545 if (j < (ssize_t) GetImageListLength(images))
546 cmyk_images=DestroyImageList(cmyk_images);
580MagickExport Image *CropImage(
const Image *image,
const RectangleInfo *geometry,
581 ExceptionInfo *exception)
583#define CropImageTag "Crop/Image"
611 assert(image != (
const Image *) NULL);
612 assert(image->signature == MagickCoreSignature);
613 assert(geometry != (
const RectangleInfo *) NULL);
614 assert(exception != (ExceptionInfo *) NULL);
615 assert(exception->signature == MagickCoreSignature);
616 if (IsEventLogging() != MagickFalse)
617 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
618 bounding_box=image->page;
619 if ((bounding_box.width == 0) || (bounding_box.height == 0))
621 bounding_box.width=image->columns;
622 bounding_box.height=image->rows;
626 page.width=bounding_box.width;
627 if (page.height == 0)
628 page.height=bounding_box.height;
629 if ((((
double) bounding_box.x-page.x) >= (
double) page.width) ||
630 (((
double) bounding_box.y-page.y) >= (
double) page.height) ||
631 (((
double) page.x-bounding_box.x) > (
double) image->columns) ||
632 (((
double) page.y-bounding_box.y) > (
double) image->rows))
637 (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
638 "GeometryDoesNotContainImage",
"(\"%.17gx%.17g%+.20g%+.20g\") `%s'",
639 (
double) geometry->width,(
double) geometry->height,
640 (
double) geometry->x,(
double) geometry->y,image->filename);
641 crop_image=CloneImage(image,1,1,MagickTrue,exception);
642 if (crop_image == (Image *) NULL)
643 return((Image *) NULL);
644 crop_image->background_color.alpha_trait=BlendPixelTrait;
645 crop_image->background_color.alpha=(MagickRealType) TransparentAlpha;
646 (void) SetImageBackgroundColor(crop_image,exception);
647 crop_image->page=bounding_box;
648 crop_image->page.x=(-1);
649 crop_image->page.y=(-1);
650 if (crop_image->dispose == BackgroundDispose)
651 crop_image->dispose=NoneDispose;
654 if ((page.x < 0) && (bounding_box.x >= 0))
656 page.width=CastDoubleToSizeT((
double) page.width+page.x-bounding_box.x);
661 page.width=CastDoubleToSizeT((
double) page.width-(bounding_box.x-page.x));
662 page.x-=bounding_box.x;
666 if ((page.y < 0) && (bounding_box.y >= 0))
668 page.height=CastDoubleToSizeT((
double) page.height+page.y-bounding_box.y);
673 page.height=CastDoubleToSizeT((
double) page.height-(bounding_box.y-
675 page.y-=bounding_box.y;
679 if ((page.x+(ssize_t) page.width) > (ssize_t) image->columns)
680 page.width=(size_t) ((ssize_t) image->columns-page.x);
681 if ((geometry->width != 0) && (page.width > geometry->width))
682 page.width=geometry->width;
683 if ((page.y+(ssize_t) page.height) > (ssize_t) image->rows)
684 page.height=CastDoubleToSizeT((
double) image->rows-page.y);
685 if ((geometry->height != 0) && (page.height > geometry->height))
686 page.height=geometry->height;
687 bounding_box.x+=page.x;
688 bounding_box.y+=page.y;
689 if ((page.width == 0) || (page.height == 0))
691 (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
692 "GeometryDoesNotContainImage",
"`%s'",image->filename);
693 return((Image *) NULL);
698 crop_image=CloneImage(image,page.width,page.height,MagickTrue,exception);
699 if (crop_image == (Image *) NULL)
700 return((Image *) NULL);
701 crop_image->page.width=image->page.width;
702 crop_image->page.height=image->page.height;
703 offset.x=bounding_box.x+(ssize_t) bounding_box.width;
704 offset.y=bounding_box.y+(ssize_t) bounding_box.height;
705 if ((offset.x > (ssize_t) image->page.width) ||
706 (offset.y > (ssize_t) image->page.height))
708 crop_image->page.width=bounding_box.width;
709 crop_image->page.height=bounding_box.height;
711 crop_image->page.x=bounding_box.x;
712 crop_image->page.y=bounding_box.y;
718 image_view=AcquireVirtualCacheView(image,exception);
719 crop_view=AcquireAuthenticCacheView(crop_image,exception);
720#if defined(MAGICKCORE_OPENMP_SUPPORT)
721 #pragma omp parallel for schedule(static) shared(status) \
722 magick_number_threads(image,crop_image,crop_image->rows,2)
724 for (y=0; y < (ssize_t) crop_image->rows; y++)
735 if (status == MagickFalse)
737 p=GetCacheViewVirtualPixels(image_view,page.x,page.y+y,crop_image->columns,
739 q=QueueCacheViewAuthenticPixels(crop_view,0,y,crop_image->columns,1,
741 if ((p == (
const Quantum *) NULL) || (q == (Quantum *) NULL))
746 for (x=0; x < (ssize_t) crop_image->columns; x++)
751 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
753 PixelChannel channel = GetPixelChannelChannel(image,i);
754 PixelTrait traits = GetPixelChannelTraits(image,channel);
755 PixelTrait crop_traits=GetPixelChannelTraits(crop_image,channel);
756 if ((traits == UndefinedPixelTrait) ||
757 (crop_traits == UndefinedPixelTrait))
759 SetPixelChannel(crop_image,channel,p[i],q);
761 p+=(ptrdiff_t) GetPixelChannels(image);
762 q+=(ptrdiff_t) GetPixelChannels(crop_image);
764 if (SyncCacheViewAuthenticPixels(crop_view,exception) == MagickFalse)
766 if (image->progress_monitor != (MagickProgressMonitor) NULL)
771#if defined(MAGICKCORE_OPENMP_SUPPORT)
775 proceed=SetImageProgress(image,CropImageTag,progress,image->rows);
776 if (proceed == MagickFalse)
780 crop_view=DestroyCacheView(crop_view);
781 image_view=DestroyCacheView(image_view);
782 crop_image->type=image->type;
783 if (status != MagickFalse)
786 transform[MagickPathExtent];
788 (void) FormatLocaleString(transform,MagickPathExtent,
789 "crop %.17gx%.17g %.17gx%.17g%+.20g%+.20g",
790 (
double) image->columns,(
double) image->rows,(
double) page.width,
791 (
double) page.height,(
double) page.x,(
double) page.y);
792 AppendImageProfileProperty(crop_image,
"hdrgm",
"hdrgm:Transform",
793 transform,exception);
795 if (status == MagickFalse)
796 crop_image=DestroyImage(crop_image);
828static inline ssize_t PixelRoundOffset(
double x)
833 if ((x-floor(x)) < (ceil(x)-x))
834 return(CastDoubleToSsizeT(floor(x)));
835 return(CastDoubleToSsizeT(ceil(x)));
838MagickExport Image *CropImageToTiles(
const Image *image,
839 const char *crop_geometry,ExceptionInfo *exception)
851 assert(image != (Image *) NULL);
852 assert(image->signature == MagickCoreSignature);
853 if (IsEventLogging() != MagickFalse)
854 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
855 flags=ParseGravityGeometry(image,crop_geometry,&geometry,exception);
856 if ((flags & AreaValue) != 0)
872 crop_image=NewImageList();
873 width=image->columns;
875 if (geometry.width == 0)
877 if (geometry.height == 0)
879 if ((flags & AspectValue) == 0)
881 width=(size_t) ((ssize_t) width-(geometry.x < 0 ? -1 : 1)*geometry.x);
882 height=(size_t) ((ssize_t) height-(geometry.y < 0 ? -1 : 1)*
887 width=(size_t) ((ssize_t) width+(geometry.x < 0 ? -1 : 1)*geometry.x);
888 height=(size_t) ((ssize_t) height+(geometry.y < 0 ? -1 : 1)*
891 delta.x=(double) width/geometry.width;
892 delta.y=(double) height/geometry.height;
897 for (offset.y=0; offset.y < (
double) height; )
899 if ((flags & AspectValue) == 0)
901 crop.y=PixelRoundOffset((
double) (offset.y-
902 (geometry.y > 0 ? 0 : geometry.y)));
904 crop.height=(size_t) PixelRoundOffset((
double) (offset.y+
905 (geometry.y < 0 ? 0 : geometry.y)));
909 crop.y=PixelRoundOffset((
double) (offset.y-
910 (geometry.y > 0 ? geometry.y : 0)));
912 crop.height=(size_t) PixelRoundOffset((
double)
913 (offset.y+(geometry.y < -1 ? geometry.y : 0)));
915 crop.height=(size_t) ((ssize_t) crop.height-crop.y);
916 crop.y+=image->page.y;
917 for (offset.x=0; offset.x < (
double) width; )
919 if ((flags & AspectValue) == 0)
921 crop.x=PixelRoundOffset((
double) (offset.x-
922 (geometry.x > 0 ? 0 : geometry.x)));
924 crop.width=(size_t) PixelRoundOffset((
double) (offset.x+
925 (geometry.x < 0 ? 0 : geometry.x)));
929 crop.x=PixelRoundOffset((
double) (offset.x-
930 (geometry.x > 0 ? geometry.x : 0)));
932 crop.width=(size_t) PixelRoundOffset((
double) (offset.x+
933 (geometry.x < 0 ? geometry.x : 0)));
935 crop.width=(size_t) ((ssize_t) crop.width-crop.x);
936 crop.x+=image->page.x;
937 next=CropImage(image,&crop,exception);
938 if (next != (Image *) NULL)
939 AppendImageToList(&crop_image,next);
942 ClearMagickException(exception);
945 if (((geometry.width == 0) && (geometry.height == 0)) ||
946 ((flags & XValue) != 0) || ((flags & YValue) != 0))
951 crop_image=CropImage(image,&geometry,exception);
952 if ((crop_image != (Image *) NULL) && ((flags & AspectValue) != 0))
954 crop_image->page.width=geometry.width;
955 crop_image->page.height=geometry.height;
956 crop_image->page.x-=geometry.x;
957 crop_image->page.y-=geometry.y;
961 if ((image->columns > geometry.width) || (image->rows > geometry.height))
979 page.width=image->columns;
980 if (page.height == 0)
981 page.height=image->rows;
982 width=geometry.width;
985 height=geometry.height;
989 crop_image=NewImageList();
990 for (y=0; y < (ssize_t) page.height; y+=(ssize_t) height)
992 for (x=0; x < (ssize_t) page.width; x+=(ssize_t) width)
994 geometry.width=width;
995 geometry.height=height;
998 next=CropImage(image,&geometry,exception);
999 if (next == (Image *) NULL)
1001 AppendImageToList(&crop_image,next);
1003 if (next == (Image *) NULL)
1008 return(CloneImage(image,0,0,MagickTrue,exception));
1039MagickExport Image *ExcerptImage(
const Image *image,
1040 const RectangleInfo *geometry,ExceptionInfo *exception)
1042#define ExcerptImageTag "Excerpt/Image"
1063 assert(image != (
const Image *) NULL);
1064 assert(image->signature == MagickCoreSignature);
1065 assert(geometry != (
const RectangleInfo *) NULL);
1066 assert(exception != (ExceptionInfo *) NULL);
1067 assert(exception->signature == MagickCoreSignature);
1068 if (IsEventLogging() != MagickFalse)
1069 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1070 excerpt_image=CloneImage(image,geometry->width,geometry->height,MagickTrue,
1072 if (excerpt_image == (Image *) NULL)
1073 return((Image *) NULL);
1079 image_view=AcquireVirtualCacheView(image,exception);
1080 excerpt_view=AcquireAuthenticCacheView(excerpt_image,exception);
1081#if defined(MAGICKCORE_OPENMP_SUPPORT)
1082 #pragma omp parallel for schedule(static) shared(progress,status) \
1083 magick_number_threads(image,excerpt_image,excerpt_image->rows,2)
1085 for (y=0; y < (ssize_t) excerpt_image->rows; y++)
1096 if (status == MagickFalse)
1098 p=GetCacheViewVirtualPixels(image_view,geometry->x,geometry->y+y,
1099 geometry->width,1,exception);
1100 q=GetCacheViewAuthenticPixels(excerpt_view,0,y,excerpt_image->columns,1,
1102 if ((p == (
const Quantum *) NULL) || (q == (Quantum *) NULL))
1107 for (x=0; x < (ssize_t) excerpt_image->columns; x++)
1112 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1114 PixelChannel channel = GetPixelChannelChannel(image,i);
1115 PixelTrait traits = GetPixelChannelTraits(image,channel);
1116 PixelTrait excerpt_traits=GetPixelChannelTraits(excerpt_image,channel);
1117 if ((traits == UndefinedPixelTrait) ||
1118 (excerpt_traits == UndefinedPixelTrait))
1120 SetPixelChannel(excerpt_image,channel,p[i],q);
1122 p+=(ptrdiff_t) GetPixelChannels(image);
1123 q+=(ptrdiff_t) GetPixelChannels(excerpt_image);
1125 if (SyncCacheViewAuthenticPixels(excerpt_view,exception) == MagickFalse)
1127 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1132#if defined(MAGICKCORE_OPENMP_SUPPORT)
1136 proceed=SetImageProgress(image,ExcerptImageTag,progress,image->rows);
1137 if (proceed == MagickFalse)
1141 excerpt_view=DestroyCacheView(excerpt_view);
1142 image_view=DestroyCacheView(image_view);
1143 excerpt_image->type=image->type;
1144 if (status == MagickFalse)
1145 excerpt_image=DestroyImage(excerpt_image);
1146 return(excerpt_image);
1179MagickExport Image *ExtentImage(
const Image *image,
1180 const RectangleInfo *geometry,ExceptionInfo *exception)
1191 assert(image != (
const Image *) NULL);
1192 assert(image->signature == MagickCoreSignature);
1193 assert(geometry != (
const RectangleInfo *) NULL);
1194 assert(exception != (ExceptionInfo *) NULL);
1195 assert(exception->signature == MagickCoreSignature);
1196 if (IsEventLogging() != MagickFalse)
1197 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1198 extent_image=CloneImage(image,geometry->width,geometry->height,MagickTrue,
1200 if (extent_image == (Image *) NULL)
1201 return((Image *) NULL);
1202 status=SetImageBackgroundColor(extent_image,exception);
1203 if (status == MagickFalse)
1205 extent_image=DestroyImage(extent_image);
1206 return((Image *) NULL);
1208 DisableCompositeClampUnlessSpecified(extent_image);
1209 status=CompositeImage(extent_image,image,image->compose,MagickTrue,
1210 -geometry->x,-geometry->y,exception);
1211 if (status != MagickFalse)
1212 Update8BIMClipPath(extent_image,image->columns,image->rows,geometry);
1213 return(extent_image);
1241MagickExport Image *FlipImage(
const Image *image,ExceptionInfo *exception)
1243#define FlipImageTag "Flip/Image"
1264 assert(image != (
const Image *) NULL);
1265 assert(image->signature == MagickCoreSignature);
1266 assert(exception != (ExceptionInfo *) NULL);
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,2)
1285 for (y=0; y < (ssize_t) flip_image->rows; y++)
1296 if (status == MagickFalse)
1298 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
1299 q=QueueCacheViewAuthenticPixels(flip_view,0,((ssize_t) flip_image->rows-y-
1300 1),flip_image->columns,1,exception);
1301 if ((p == (
const Quantum *) NULL) || (q == (Quantum *) NULL))
1306 for (x=0; x < (ssize_t) flip_image->columns; x++)
1311 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1313 PixelChannel channel = GetPixelChannelChannel(image,i);
1314 PixelTrait traits = GetPixelChannelTraits(image,channel);
1315 PixelTrait flip_traits = GetPixelChannelTraits(flip_image,channel);
1316 if ((traits == UndefinedPixelTrait) ||
1317 (flip_traits == UndefinedPixelTrait))
1319 SetPixelChannel(flip_image,channel,p[i],q);
1321 p+=(ptrdiff_t) GetPixelChannels(image);
1322 q+=(ptrdiff_t) GetPixelChannels(flip_image);
1324 if (SyncCacheViewAuthenticPixels(flip_view,exception) == MagickFalse)
1326 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1331#if defined(MAGICKCORE_OPENMP_SUPPORT)
1335 proceed=SetImageProgress(image,FlipImageTag,progress,image->rows);
1336 if (proceed == MagickFalse)
1340 flip_view=DestroyCacheView(flip_view);
1341 image_view=DestroyCacheView(image_view);
1342 flip_image->type=image->type;
1343 if (page.height != 0)
1344 page.y=((ssize_t) page.height-(ssize_t) flip_image->rows-page.y);
1345 flip_image->page=page;
1346 if (status != MagickFalse)
1349 transform[MagickPathExtent];
1351 (void) FormatLocaleString(transform,MagickPathExtent,
1352 "flip %.17gx%.17g",(
double) image->columns,(
double) image->rows);
1353 AppendImageProfileProperty(flip_image,
"hdrgm",
"hdrgm:Transform",
1354 transform,exception);
1356 if (status == MagickFalse)
1357 flip_image=DestroyImage(flip_image);
1386MagickExport Image *FlopImage(
const Image *image,ExceptionInfo *exception)
1388#define FlopImageTag "Flop/Image"
1409 assert(image != (
const Image *) NULL);
1410 assert(image->signature == MagickCoreSignature);
1411 assert(exception != (ExceptionInfo *) NULL);
1412 assert(exception->signature == MagickCoreSignature);
1413 if (IsEventLogging() != MagickFalse)
1414 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1415 flop_image=CloneImage(image,0,0,MagickTrue,exception);
1416 if (flop_image == (Image *) NULL)
1417 return((Image *) NULL);
1424 image_view=AcquireVirtualCacheView(image,exception);
1425 flop_view=AcquireAuthenticCacheView(flop_image,exception);
1426#if defined(MAGICKCORE_OPENMP_SUPPORT)
1427 #pragma omp parallel for schedule(static) shared(status) \
1428 magick_number_threads(image,flop_image,flop_image->rows,2)
1430 for (y=0; y < (ssize_t) flop_image->rows; y++)
1441 if (status == MagickFalse)
1443 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
1444 q=QueueCacheViewAuthenticPixels(flop_view,0,y,flop_image->columns,1,
1446 if ((p == (
const Quantum *) NULL) || (q == (Quantum *) NULL))
1451 q+=(ptrdiff_t) GetPixelChannels(flop_image)*flop_image->columns;
1452 for (x=0; x < (ssize_t) flop_image->columns; x++)
1457 q-=GetPixelChannels(flop_image);
1458 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1460 PixelChannel channel = GetPixelChannelChannel(image,i);
1461 PixelTrait traits = GetPixelChannelTraits(image,channel);
1462 PixelTrait flop_traits=GetPixelChannelTraits(flop_image,channel);
1463 if ((traits == UndefinedPixelTrait) ||
1464 (flop_traits == UndefinedPixelTrait))
1466 SetPixelChannel(flop_image,channel,p[i],q);
1468 p+=(ptrdiff_t) GetPixelChannels(image);
1470 if (SyncCacheViewAuthenticPixels(flop_view,exception) == MagickFalse)
1472 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1477#if defined(MAGICKCORE_OPENMP_SUPPORT)
1481 proceed=SetImageProgress(image,FlopImageTag,progress,image->rows);
1482 if (proceed == MagickFalse)
1486 flop_view=DestroyCacheView(flop_view);
1487 image_view=DestroyCacheView(image_view);
1488 flop_image->type=image->type;
1489 if (page.width != 0)
1490 page.x=((ssize_t) page.width-(ssize_t) flop_image->columns-page.x);
1491 flop_image->page=page;
1492 if (status != MagickFalse)
1495 transform[MagickPathExtent];
1497 (void) FormatLocaleString(transform,MagickPathExtent,
1498 "flop %.17gx%.17g",(
double) image->columns,(
double) image->rows);
1499 AppendImageProfileProperty(flop_image,
"hdrgm",
"hdrgm:Transform",
1500 transform,exception);
1502 if (status == MagickFalse)
1503 flop_image=DestroyImage(flop_image);
1537static MagickBooleanType CopyImageRegion(Image *destination,
const Image *source,
const size_t columns,
const size_t rows,
const ssize_t sx,
const ssize_t sy,
1538 const ssize_t dx,
const ssize_t dy,ExceptionInfo *exception)
1553 source_view=AcquireVirtualCacheView(source,exception);
1554 destination_view=AcquireAuthenticCacheView(destination,exception);
1555#if defined(MAGICKCORE_OPENMP_SUPPORT)
1556 #pragma omp parallel for schedule(static) shared(status) \
1557 magick_number_threads(source,destination,rows,2)
1559 for (y=0; y < (ssize_t) rows; y++)
1576 if (status == MagickFalse)
1578 p=GetCacheViewVirtualPixels(source_view,sx,sy+y,columns,1,exception);
1579 q=GetCacheViewAuthenticPixels(destination_view,dx,dy+y,columns,1,exception);
1580 if ((p == (
const Quantum *) NULL) || (q == (Quantum *) NULL))
1585 for (x=0; x < (ssize_t) columns; x++)
1590 for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
1592 PixelChannel channel = GetPixelChannelChannel(source,i);
1593 PixelTrait source_traits=GetPixelChannelTraits(source,channel);
1594 PixelTrait destination_traits=GetPixelChannelTraits(destination,
1596 if ((source_traits == UndefinedPixelTrait) ||
1597 (destination_traits == UndefinedPixelTrait))
1599 SetPixelChannel(destination,channel,p[i],q);
1601 p+=(ptrdiff_t) GetPixelChannels(source);
1602 q+=(ptrdiff_t) GetPixelChannels(destination);
1604 sync=SyncCacheViewAuthenticPixels(destination_view,exception);
1605 if (sync == MagickFalse)
1608 destination_view=DestroyCacheView(destination_view);
1609 source_view=DestroyCacheView(source_view);
1613MagickExport Image *RollImage(
const Image *image,
const ssize_t x_offset,
1614 const ssize_t y_offset,ExceptionInfo *exception)
1616#define RollImageTag "Roll/Image"
1630 assert(image != (
const Image *) NULL);
1631 assert(image->signature == MagickCoreSignature);
1632 assert(exception != (ExceptionInfo *) NULL);
1633 assert(exception->signature == MagickCoreSignature);
1634 if (IsEventLogging() != MagickFalse)
1635 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1636 roll_image=CloneImage(image,0,0,MagickTrue,exception);
1637 if (roll_image == (Image *) NULL)
1638 return((Image *) NULL);
1641 while (offset.x < 0)
1642 offset.x+=(ssize_t) image->columns;
1643 while (offset.x >= (ssize_t) image->columns)
1644 offset.x-=(ssize_t) image->columns;
1645 while (offset.y < 0)
1646 offset.y+=(ssize_t) image->rows;
1647 while (offset.y >= (ssize_t) image->rows)
1648 offset.y-=(ssize_t) image->rows;
1652 status=CopyImageRegion(roll_image,image,(
size_t) offset.x,
1653 (
size_t) offset.y,(ssize_t) image->columns-offset.x,(ssize_t) image->rows-
1654 offset.y,0,0,exception);
1655 (void) SetImageProgress(image,RollImageTag,0,3);
1656 status&=(MagickStatusType) CopyImageRegion(roll_image,image,(
size_t)
1657 ((ssize_t) image->columns-offset.x),(
size_t) offset.y,0,(ssize_t)
1658 image->rows-offset.y,offset.x,0,exception);
1659 (void) SetImageProgress(image,RollImageTag,1,3);
1660 status&=(MagickStatusType) CopyImageRegion(roll_image,image,(
size_t)
1661 offset.x,(
size_t) ((ssize_t) image->rows-offset.y),(ssize_t)
1662 image->columns-offset.x,0,0,offset.y,exception);
1663 (void) SetImageProgress(image,RollImageTag,2,3);
1664 status&=(MagickStatusType) CopyImageRegion(roll_image,image,(
size_t)
1665 ((ssize_t) image->columns-offset.x),(
size_t) ((ssize_t) image->rows-
1666 offset.y),0,0,offset.x,offset.y,exception);
1667 (void) SetImageProgress(image,RollImageTag,3,3);
1668 roll_image->type=image->type;
1669 if (status == MagickFalse)
1670 roll_image=DestroyImage(roll_image);
1708MagickExport Image *ShaveImage(
const Image *image,
1709 const RectangleInfo *shave_info,ExceptionInfo *exception)
1717 assert(image != (
const Image *) NULL);
1718 assert(image->signature == MagickCoreSignature);
1719 if (IsEventLogging() != MagickFalse)
1720 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1721 if (((2*shave_info->width) >= image->columns) ||
1722 ((2*shave_info->height) >= image->rows))
1723 ThrowImageException(OptionWarning,
"GeometryDoesNotContainImage");
1724 SetGeometry(image,&geometry);
1725 geometry.width-=2*shave_info->width;
1726 geometry.height-=2*shave_info->height;
1727 geometry.x=(ssize_t) shave_info->width+image->page.x;
1728 geometry.y=(ssize_t) shave_info->height+image->page.y;
1729 shave_image=CropImage(image,&geometry,exception);
1730 if (shave_image == (Image *) NULL)
1731 return((Image *) NULL);
1732 shave_image->page.width-=2*shave_info->width;
1733 shave_image->page.height-=2*shave_info->height;
1734 shave_image->page.x-=(ssize_t) shave_info->width;
1735 shave_image->page.y-=(ssize_t) shave_info->height;
1736 return(shave_image);
1768MagickExport Image *SpliceImage(
const Image *image,
1769 const RectangleInfo *geometry,ExceptionInfo *exception)
1771#define SpliceImageTag "Splice/Image"
1797 assert(image != (
const Image *) NULL);
1798 assert(image->signature == MagickCoreSignature);
1799 if (IsEventLogging() != MagickFalse)
1800 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1801 assert(geometry != (
const RectangleInfo *) NULL);
1802 assert(exception != (ExceptionInfo *) NULL);
1803 assert(exception->signature == MagickCoreSignature);
1804 splice_geometry=(*geometry);
1805 splice_image=CloneImage(image,image->columns+splice_geometry.width,
1806 image->rows+splice_geometry.height,MagickTrue,exception);
1807 if (splice_image == (Image *) NULL)
1808 return((Image *) NULL);
1809 if (SetImageStorageClass(splice_image,DirectClass,exception) == MagickFalse)
1811 splice_image=DestroyImage(splice_image);
1812 return((Image *) NULL);
1814 if ((IsPixelInfoGray(&splice_image->background_color) == MagickFalse) &&
1815 (IsGrayColorspace(splice_image->colorspace) != MagickFalse))
1816 (void) SetImageColorspace(splice_image,sRGBColorspace,exception);
1817 if ((splice_image->background_color.alpha_trait != UndefinedPixelTrait) &&
1818 (splice_image->alpha_trait == UndefinedPixelTrait))
1819 (void) SetImageAlpha(splice_image,OpaqueAlpha,exception);
1820 (void) SetImageBackgroundColor(splice_image,exception);
1824 switch (image->gravity)
1827 case UndefinedGravity:
1828 case NorthWestGravity:
1832 splice_geometry.x+=(ssize_t) splice_geometry.width/2;
1835 case NorthEastGravity:
1837 splice_geometry.x+=(ssize_t) splice_geometry.width;
1842 splice_geometry.y+=(ssize_t) splice_geometry.width/2;
1847 splice_geometry.x+=(ssize_t) splice_geometry.width/2;
1848 splice_geometry.y+=(ssize_t) splice_geometry.height/2;
1853 splice_geometry.x+=(ssize_t) splice_geometry.width;
1854 splice_geometry.y+=(ssize_t) splice_geometry.height/2;
1857 case SouthWestGravity:
1859 splice_geometry.y+=(ssize_t) splice_geometry.height;
1864 splice_geometry.x+=(ssize_t) splice_geometry.width/2;
1865 splice_geometry.y+=(ssize_t) splice_geometry.height;
1868 case SouthEastGravity:
1870 splice_geometry.x+=(ssize_t) splice_geometry.width;
1871 splice_geometry.y+=(ssize_t) splice_geometry.height;
1880 columns=MagickMin(splice_geometry.x,(ssize_t) splice_image->columns);
1881 rows=MagickMin(splice_geometry.y,(ssize_t) splice_image->rows);
1882 image_view=AcquireVirtualCacheView(image,exception);
1883 splice_view=AcquireAuthenticCacheView(splice_image,exception);
1884#if defined(MAGICKCORE_OPENMP_SUPPORT)
1885 #pragma omp parallel for schedule(static) shared(progress,status) \
1886 magick_number_threads(image,splice_image,rows,2)
1888 for (y=0; y < rows; y++)
1899 if (status == MagickFalse)
1901 p=GetCacheViewVirtualPixels(image_view,0,y,splice_image->columns,1,
1903 q=QueueCacheViewAuthenticPixels(splice_view,0,y,splice_image->columns,1,
1905 if ((p == (
const Quantum *) NULL) || (q == (Quantum *) NULL))
1910 for (x=0; x < columns; x++)
1915 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1917 PixelChannel channel = GetPixelChannelChannel(image,i);
1918 PixelTrait traits = GetPixelChannelTraits(image,channel);
1919 PixelTrait splice_traits=GetPixelChannelTraits(splice_image,channel);
1920 if ((traits == UndefinedPixelTrait) ||
1921 (splice_traits == UndefinedPixelTrait))
1923 SetPixelChannel(splice_image,channel,p[i],q);
1925 SetPixelRed(splice_image,GetPixelRed(image,p),q);
1926 SetPixelGreen(splice_image,GetPixelGreen(image,p),q);
1927 SetPixelBlue(splice_image,GetPixelBlue(image,p),q);
1928 SetPixelAlpha(splice_image,GetPixelAlpha(image,p),q);
1929 p+=(ptrdiff_t) GetPixelChannels(image);
1930 q+=(ptrdiff_t) GetPixelChannels(splice_image);
1932 for ( ; x < (splice_geometry.x+(ssize_t) splice_geometry.width); x++)
1933 q+=(ptrdiff_t) GetPixelChannels(splice_image);
1934 for ( ; x < (ssize_t) splice_image->columns; x++)
1939 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1941 PixelChannel channel = GetPixelChannelChannel(image,i);
1942 PixelTrait traits = GetPixelChannelTraits(image,channel);
1943 PixelTrait splice_traits=GetPixelChannelTraits(splice_image,channel);
1944 if ((traits == UndefinedPixelTrait) ||
1945 (splice_traits == UndefinedPixelTrait))
1947 SetPixelChannel(splice_image,channel,p[i],q);
1949 SetPixelRed(splice_image,GetPixelRed(image,p),q);
1950 SetPixelGreen(splice_image,GetPixelGreen(image,p),q);
1951 SetPixelBlue(splice_image,GetPixelBlue(image,p),q);
1952 SetPixelAlpha(splice_image,GetPixelAlpha(image,p),q);
1953 p+=(ptrdiff_t) GetPixelChannels(image);
1954 q+=(ptrdiff_t) GetPixelChannels(splice_image);
1956 if (SyncCacheViewAuthenticPixels(splice_view,exception) == MagickFalse)
1958 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1963#if defined(MAGICKCORE_OPENMP_SUPPORT)
1967 proceed=SetImageProgress(image,SpliceImageTag,progress,
1968 splice_image->rows);
1969 if (proceed == MagickFalse)
1973#if defined(MAGICKCORE_OPENMP_SUPPORT)
1974 #pragma omp parallel for schedule(static) shared(progress,status) \
1975 magick_number_threads(image,splice_image,splice_image->rows,2)
1977 for (y=splice_geometry.y+(ssize_t) splice_geometry.height; y < (ssize_t) splice_image->rows; y++)
1988 if (status == MagickFalse)
1990 if ((y < 0) || (y >= (ssize_t) splice_image->rows))
1992 p=GetCacheViewVirtualPixels(image_view,0,y-(ssize_t) splice_geometry.height,
1993 splice_image->columns,1,exception);
1994 q=QueueCacheViewAuthenticPixels(splice_view,0,y,splice_image->columns,1,
1996 if ((p == (
const Quantum *) NULL) || (q == (Quantum *) NULL))
2001 for (x=0; x < columns; x++)
2006 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
2008 PixelChannel channel = GetPixelChannelChannel(image,i);
2009 PixelTrait traits = GetPixelChannelTraits(image,channel);
2010 PixelTrait splice_traits=GetPixelChannelTraits(splice_image,channel);
2011 if ((traits == UndefinedPixelTrait) ||
2012 (splice_traits == UndefinedPixelTrait))
2014 SetPixelChannel(splice_image,channel,p[i],q);
2016 SetPixelRed(splice_image,GetPixelRed(image,p),q);
2017 SetPixelGreen(splice_image,GetPixelGreen(image,p),q);
2018 SetPixelBlue(splice_image,GetPixelBlue(image,p),q);
2019 SetPixelAlpha(splice_image,GetPixelAlpha(image,p),q);
2020 p+=(ptrdiff_t) GetPixelChannels(image);
2021 q+=(ptrdiff_t) GetPixelChannels(splice_image);
2023 for ( ; x < (splice_geometry.x+(ssize_t) splice_geometry.width); x++)
2024 q+=(ptrdiff_t) GetPixelChannels(splice_image);
2025 for ( ; x < (ssize_t) splice_image->columns; x++)
2030 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
2032 PixelChannel channel = GetPixelChannelChannel(image,i);
2033 PixelTrait traits = GetPixelChannelTraits(image,channel);
2034 PixelTrait splice_traits=GetPixelChannelTraits(splice_image,channel);
2035 if ((traits == UndefinedPixelTrait) ||
2036 (splice_traits == UndefinedPixelTrait))
2038 SetPixelChannel(splice_image,channel,p[i],q);
2040 SetPixelRed(splice_image,GetPixelRed(image,p),q);
2041 SetPixelGreen(splice_image,GetPixelGreen(image,p),q);
2042 SetPixelBlue(splice_image,GetPixelBlue(image,p),q);
2043 SetPixelAlpha(splice_image,GetPixelAlpha(image,p),q);
2044 p+=(ptrdiff_t) GetPixelChannels(image);
2045 q+=(ptrdiff_t) GetPixelChannels(splice_image);
2047 if (SyncCacheViewAuthenticPixels(splice_view,exception) == MagickFalse)
2049 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2054#if defined(MAGICKCORE_OPENMP_SUPPORT)
2058 proceed=SetImageProgress(image,SpliceImageTag,progress,
2059 splice_image->rows);
2060 if (proceed == MagickFalse)
2064 splice_view=DestroyCacheView(splice_view);
2065 image_view=DestroyCacheView(image_view);
2066 if (status == MagickFalse)
2067 splice_image=DestroyImage(splice_image);
2068 return(splice_image);
2118MagickPrivate MagickBooleanType TransformImage(Image **image,
2119 const char *crop_geometry,
const char *image_geometry,ExceptionInfo *exception)
2128 assert(image != (Image **) NULL);
2129 assert((*image)->signature == MagickCoreSignature);
2130 if (IsEventLogging() != MagickFalse)
2131 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",(*image)->filename);
2132 transform_image=(*image);
2133 if (crop_geometry != (
const char *) NULL)
2141 crop_image=CropImageToTiles(*image,crop_geometry,exception);
2142 if (crop_image == (Image *) NULL)
2143 transform_image=CloneImage(*image,0,0,MagickTrue,exception);
2146 transform_image=DestroyImage(transform_image);
2147 transform_image=GetFirstImageInList(crop_image);
2149 *image=transform_image;
2151 if (transform_image == (Image *) NULL)
2152 return(MagickFalse);
2156 if (image_geometry == (
const char *) NULL)
2158 (void) ParseRegionGeometry(transform_image,image_geometry,&geometry,
2160 if ((transform_image->columns == geometry.width) &&
2161 (transform_image->rows == geometry.height))
2163 resize_image=ResizeImage(transform_image,geometry.width,geometry.height,
2164 transform_image->filter,exception);
2165 if (resize_image == (Image *) NULL)
2166 return(MagickFalse);
2167 transform_image=DestroyImage(transform_image);
2168 transform_image=resize_image;
2169 *image=transform_image;
2198MagickExport Image *TransposeImage(
const Image *image,ExceptionInfo *exception)
2200#define TransposeImageTag "Transpose/Image"
2221 assert(image != (
const Image *) NULL);
2222 assert(image->signature == MagickCoreSignature);
2223 assert(exception != (ExceptionInfo *) NULL);
2224 assert(exception->signature == MagickCoreSignature);
2225 if (IsEventLogging() != MagickFalse)
2226 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2227 transpose_image=CloneImage(image,image->rows,image->columns,MagickTrue,
2229 if (transpose_image == (Image *) NULL)
2230 return((Image *) NULL);
2236 image_view=AcquireVirtualCacheView(image,exception);
2237 transpose_view=AcquireAuthenticCacheView(transpose_image,exception);
2238#if defined(MAGICKCORE_OPENMP_SUPPORT)
2239 #pragma omp parallel for schedule(static) shared(progress,status) \
2240 magick_number_threads(image,transpose_image,image->rows,2)
2242 for (y=0; y < (ssize_t) image->rows; y++)
2253 if (status == MagickFalse)
2255 p=GetCacheViewVirtualPixels(image_view,0,(ssize_t) image->rows-y-1,
2256 image->columns,1,exception);
2257 q=QueueCacheViewAuthenticPixels(transpose_view,(ssize_t) image->rows-y-1,
2258 0,1,transpose_image->rows,exception);
2259 if ((p == (
const Quantum *) NULL) || (q == (Quantum *) NULL))
2264 for (x=0; x < (ssize_t) image->columns; x++)
2269 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
2271 PixelChannel channel = GetPixelChannelChannel(image,i);
2272 PixelTrait traits = GetPixelChannelTraits(image,channel);
2273 PixelTrait transpose_traits=GetPixelChannelTraits(transpose_image,
2275 if ((traits == UndefinedPixelTrait) ||
2276 (transpose_traits == UndefinedPixelTrait))
2278 SetPixelChannel(transpose_image,channel,p[i],q);
2280 p+=(ptrdiff_t) GetPixelChannels(image);
2281 q+=(ptrdiff_t) GetPixelChannels(transpose_image);
2283 if (SyncCacheViewAuthenticPixels(transpose_view,exception) == MagickFalse)
2285 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2290#if defined(MAGICKCORE_OPENMP_SUPPORT)
2294 proceed=SetImageProgress(image,TransposeImageTag,progress,image->rows);
2295 if (proceed == MagickFalse)
2299 transpose_view=DestroyCacheView(transpose_view);
2300 image_view=DestroyCacheView(image_view);
2301 transpose_image->type=image->type;
2302 page=transpose_image->page;
2303 Swap(page.width,page.height);
2304 Swap(page.x,page.y);
2305 transpose_image->page=page;
2306 if (status != MagickFalse)
2309 transform[MagickPathExtent];
2311 (void) FormatLocaleString(transform,MagickPathExtent,
2312 "transpose %.17gx%.17g",(
double) image->columns,
2313 (
double) image->rows);
2314 AppendImageProfileProperty(transpose_image,
"hdrgm",
"hdrgm:Transform",
2315 transform,exception);
2317 if (status == MagickFalse)
2318 transpose_image=DestroyImage(transpose_image);
2319 return(transpose_image);
2347MagickExport Image *TransverseImage(
const Image *image,ExceptionInfo *exception)
2349#define TransverseImageTag "Transverse/Image"
2370 assert(image != (
const Image *) NULL);
2371 assert(image->signature == MagickCoreSignature);
2372 assert(exception != (ExceptionInfo *) NULL);
2373 assert(exception->signature == MagickCoreSignature);
2374 if (IsEventLogging() != MagickFalse)
2375 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2376 transverse_image=CloneImage(image,image->rows,image->columns,MagickTrue,
2378 if (transverse_image == (Image *) NULL)
2379 return((Image *) NULL);
2385 image_view=AcquireVirtualCacheView(image,exception);
2386 transverse_view=AcquireAuthenticCacheView(transverse_image,exception);
2387#if defined(MAGICKCORE_OPENMP_SUPPORT)
2388 #pragma omp parallel for schedule(static) shared(progress,status) \
2389 magick_number_threads(image,transverse_image,image->rows,2)
2391 for (y=0; y < (ssize_t) image->rows; y++)
2405 if (status == MagickFalse)
2407 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
2408 q=QueueCacheViewAuthenticPixels(transverse_view,(ssize_t) image->rows-y-1,
2409 0,1,transverse_image->rows,exception);
2410 if ((p == (
const Quantum *) NULL) || (q == (Quantum *) NULL))
2415 q+=(ptrdiff_t) GetPixelChannels(transverse_image)*image->columns;
2416 for (x=0; x < (ssize_t) image->columns; x++)
2421 q-=GetPixelChannels(transverse_image);
2422 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
2424 PixelChannel channel = GetPixelChannelChannel(image,i);
2425 PixelTrait traits = GetPixelChannelTraits(image,channel);
2426 PixelTrait transverse_traits=GetPixelChannelTraits(transverse_image,
2428 if ((traits == UndefinedPixelTrait) ||
2429 (transverse_traits == UndefinedPixelTrait))
2431 SetPixelChannel(transverse_image,channel,p[i],q);
2433 p+=(ptrdiff_t) GetPixelChannels(image);
2435 sync=SyncCacheViewAuthenticPixels(transverse_view,exception);
2436 if (sync == MagickFalse)
2438 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2443#if defined(MAGICKCORE_OPENMP_SUPPORT)
2447 proceed=SetImageProgress(image,TransverseImageTag,progress,image->rows);
2448 if (proceed == MagickFalse)
2452 transverse_view=DestroyCacheView(transverse_view);
2453 image_view=DestroyCacheView(image_view);
2454 transverse_image->type=image->type;
2455 page=transverse_image->page;
2456 Swap(page.width,page.height);
2457 Swap(page.x,page.y);
2458 if (page.width != 0)
2459 page.x=(ssize_t) page.width-(ssize_t) transverse_image->columns-page.x;
2460 if (page.height != 0)
2461 page.y=(ssize_t) page.height-(ssize_t) transverse_image->rows-page.y;
2462 transverse_image->page=page;
2463 if (status != MagickFalse)
2466 transform[MagickPathExtent];
2468 (void) FormatLocaleString(transform,MagickPathExtent,
2469 "transverse %.17gx%.17g",(
double) image->columns,
2470 (
double) image->rows);
2471 AppendImageProfileProperty(transverse_image,
"hdrgm",
"hdrgm:Transform",
2472 transform,exception);
2474 if (status == MagickFalse)
2475 transverse_image=DestroyImage(transverse_image);
2476 return(transverse_image);
2505MagickExport Image *TrimImage(
const Image *image,ExceptionInfo *exception)
2516 assert(image != (
const Image *) NULL);
2517 assert(image->signature == MagickCoreSignature);
2518 if (IsEventLogging() != MagickFalse)
2519 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2520 geometry=GetImageBoundingBox(image,exception);
2521 if ((geometry.width == 0) || (geometry.height == 0))
2526 trim_image=CloneImage(image,1,1,MagickTrue,exception);
2527 if (trim_image != (Image *) NULL)
2529 trim_image->background_color.alpha_trait=BlendPixelTrait;
2530 trim_image->background_color.alpha=(MagickRealType) TransparentAlpha;
2531 (void) SetImageBackgroundColor(trim_image,exception);
2532 trim_image->page.width=image->columns;
2533 trim_image->page.height=image->rows;
2534 trim_image->page.x=(-1);
2535 trim_image->page.y=(-1);
2539 artifact=GetImageArtifact(image,
"trim:minSize");
2540 if (artifact != (
const char *) NULL)
2549 (void) ParseAbsoluteGeometry(artifact,&minSize);
2550 if ((geometry.width < minSize.width) ||
2551 (geometry.height < minSize.height))
2553 minSize.x=(geometry.width < minSize.width) ? (ssize_t)
2554 (minSize.width-geometry.width) : 0;
2555 minSize.y=(geometry.height < minSize.height) ? (ssize_t)
2556 (minSize.height-geometry.height) : 0;
2557 switch (image->gravity)
2559 case NorthWestGravity:
2561 geometry.x-=minSize.x;
2562 geometry.y-=minSize.y;
2567 geometry.x-=minSize.x/2;
2568 geometry.y-=minSize.y;
2571 case NorthEastGravity:
2573 geometry.y-=minSize.y;
2578 geometry.x-=minSize.x;
2579 geometry.y-=minSize.y/2;
2584 geometry.y-=minSize.y/2;
2587 case SouthWestGravity:
2589 geometry.x-=minSize.x;
2594 geometry.x-=minSize.x/2;
2599 geometry.x-=minSize.x/2;
2600 geometry.y-=minSize.y/2;
2603 case UndefinedGravity:
2604 case SouthEastGravity:
2608 if (geometry.width < minSize.width)
2609 geometry.width=minSize.width;
2610 if (geometry.height < minSize.height)
2611 geometry.height=minSize.height;
2612 if (geometry.width > image->columns)
2613 geometry.width=image->columns;
2614 if (geometry.height > image->rows)
2615 geometry.height=image->rows;
2618 if ((geometry.x+(ssize_t) geometry.width) > (ssize_t) image->columns)
2619 geometry.x=(ssize_t) image->columns-(ssize_t) geometry.width;
2622 if ((geometry.y+(ssize_t) geometry.height) > (ssize_t) image->rows)
2623 geometry.y=(ssize_t) image->rows-(ssize_t) geometry.height;
2626 geometry.x+=image->page.x;
2627 geometry.y+=image->page.y;
2628 trim_image=CropImage(image,&geometry,exception);
2629 if (trim_image != (Image *) NULL)
2631 trim_image->page.width=image->columns;
2632 trim_image->page.height=image->rows;
2633 if (trim_image->page.x == 0)
2634 trim_image->page.x=geometry.x;
2635 if (trim_image->page.y == 0)
2636 trim_image->page.y=geometry.y;