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"
1796 assert(image != (
const Image *) NULL);
1797 assert(image->signature == MagickCoreSignature);
1798 if (IsEventLogging() != MagickFalse)
1799 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1800 assert(geometry != (
const RectangleInfo *) NULL);
1801 assert(exception != (ExceptionInfo *) NULL);
1802 assert(exception->signature == MagickCoreSignature);
1803 splice_geometry=(*geometry);
1804 splice_image=CloneImage(image,image->columns+splice_geometry.width,
1805 image->rows+splice_geometry.height,MagickTrue,exception);
1806 if (splice_image == (Image *) NULL)
1807 return((Image *) NULL);
1808 if (SetImageStorageClass(splice_image,DirectClass,exception) == MagickFalse)
1810 splice_image=DestroyImage(splice_image);
1811 return((Image *) NULL);
1813 if ((IsPixelInfoGray(&splice_image->background_color) == MagickFalse) &&
1814 (IsGrayColorspace(splice_image->colorspace) != MagickFalse))
1815 (void) SetImageColorspace(splice_image,sRGBColorspace,exception);
1816 if ((splice_image->background_color.alpha_trait != UndefinedPixelTrait) &&
1817 (splice_image->alpha_trait == UndefinedPixelTrait))
1818 (void) SetImageAlpha(splice_image,OpaqueAlpha,exception);
1819 (void) SetImageBackgroundColor(splice_image,exception);
1823 switch (image->gravity)
1826 case UndefinedGravity:
1827 case NorthWestGravity:
1831 splice_geometry.x+=(ssize_t) splice_geometry.width/2;
1834 case NorthEastGravity:
1836 splice_geometry.x+=(ssize_t) splice_geometry.width;
1841 splice_geometry.y+=(ssize_t) splice_geometry.width/2;
1846 splice_geometry.x+=(ssize_t) splice_geometry.width/2;
1847 splice_geometry.y+=(ssize_t) splice_geometry.height/2;
1852 splice_geometry.x+=(ssize_t) splice_geometry.width;
1853 splice_geometry.y+=(ssize_t) splice_geometry.height/2;
1856 case SouthWestGravity:
1858 splice_geometry.y+=(ssize_t) splice_geometry.height;
1863 splice_geometry.x+=(ssize_t) splice_geometry.width/2;
1864 splice_geometry.y+=(ssize_t) splice_geometry.height;
1867 case SouthEastGravity:
1869 splice_geometry.x+=(ssize_t) splice_geometry.width;
1870 splice_geometry.y+=(ssize_t) splice_geometry.height;
1879 columns=MagickMin(splice_geometry.x,(ssize_t) splice_image->columns);
1880 image_view=AcquireVirtualCacheView(image,exception);
1881 splice_view=AcquireAuthenticCacheView(splice_image,exception);
1882#if defined(MAGICKCORE_OPENMP_SUPPORT)
1883 #pragma omp parallel for schedule(static) shared(progress,status) \
1884 magick_number_threads(image,splice_image,(size_t) splice_geometry.y,2)
1886 for (y=0; y < MagickMin(splice_geometry.y,(ssize_t) splice_image->rows); y++)
1897 if (status == MagickFalse)
1899 p=GetCacheViewVirtualPixels(image_view,0,y,splice_image->columns,1,
1901 q=QueueCacheViewAuthenticPixels(splice_view,0,y,splice_image->columns,1,
1903 if ((p == (
const Quantum *) NULL) || (q == (Quantum *) NULL))
1908 for (x=0; x < columns; x++)
1913 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1915 PixelChannel channel = GetPixelChannelChannel(image,i);
1916 PixelTrait traits = GetPixelChannelTraits(image,channel);
1917 PixelTrait splice_traits=GetPixelChannelTraits(splice_image,channel);
1918 if ((traits == UndefinedPixelTrait) ||
1919 (splice_traits == UndefinedPixelTrait))
1921 SetPixelChannel(splice_image,channel,p[i],q);
1923 SetPixelRed(splice_image,GetPixelRed(image,p),q);
1924 SetPixelGreen(splice_image,GetPixelGreen(image,p),q);
1925 SetPixelBlue(splice_image,GetPixelBlue(image,p),q);
1926 SetPixelAlpha(splice_image,GetPixelAlpha(image,p),q);
1927 p+=(ptrdiff_t) GetPixelChannels(image);
1928 q+=(ptrdiff_t) GetPixelChannels(splice_image);
1930 for ( ; x < (splice_geometry.x+(ssize_t) splice_geometry.width); x++)
1931 q+=(ptrdiff_t) GetPixelChannels(splice_image);
1932 for ( ; x < (ssize_t) splice_image->columns; x++)
1937 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1939 PixelChannel channel = GetPixelChannelChannel(image,i);
1940 PixelTrait traits = GetPixelChannelTraits(image,channel);
1941 PixelTrait splice_traits=GetPixelChannelTraits(splice_image,channel);
1942 if ((traits == UndefinedPixelTrait) ||
1943 (splice_traits == UndefinedPixelTrait))
1945 SetPixelChannel(splice_image,channel,p[i],q);
1947 SetPixelRed(splice_image,GetPixelRed(image,p),q);
1948 SetPixelGreen(splice_image,GetPixelGreen(image,p),q);
1949 SetPixelBlue(splice_image,GetPixelBlue(image,p),q);
1950 SetPixelAlpha(splice_image,GetPixelAlpha(image,p),q);
1951 p+=(ptrdiff_t) GetPixelChannels(image);
1952 q+=(ptrdiff_t) GetPixelChannels(splice_image);
1954 if (SyncCacheViewAuthenticPixels(splice_view,exception) == MagickFalse)
1956 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1961#if defined(MAGICKCORE_OPENMP_SUPPORT)
1965 proceed=SetImageProgress(image,SpliceImageTag,progress,
1966 splice_image->rows);
1967 if (proceed == MagickFalse)
1971#if defined(MAGICKCORE_OPENMP_SUPPORT)
1972 #pragma omp parallel for schedule(static) shared(progress,status) \
1973 magick_number_threads(image,splice_image,splice_image->rows,2)
1975 for (y=splice_geometry.y+(ssize_t) splice_geometry.height; y < (ssize_t) splice_image->rows; y++)
1986 if (status == MagickFalse)
1988 if ((y < 0) || (y >= (ssize_t) splice_image->rows))
1990 p=GetCacheViewVirtualPixels(image_view,0,y-(ssize_t) splice_geometry.height,
1991 splice_image->columns,1,exception);
1992 q=QueueCacheViewAuthenticPixels(splice_view,0,y,splice_image->columns,1,
1994 if ((p == (
const Quantum *) NULL) || (q == (Quantum *) NULL))
1999 for (x=0; x < columns; x++)
2004 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
2006 PixelChannel channel = GetPixelChannelChannel(image,i);
2007 PixelTrait traits = GetPixelChannelTraits(image,channel);
2008 PixelTrait splice_traits=GetPixelChannelTraits(splice_image,channel);
2009 if ((traits == UndefinedPixelTrait) ||
2010 (splice_traits == UndefinedPixelTrait))
2012 SetPixelChannel(splice_image,channel,p[i],q);
2014 SetPixelRed(splice_image,GetPixelRed(image,p),q);
2015 SetPixelGreen(splice_image,GetPixelGreen(image,p),q);
2016 SetPixelBlue(splice_image,GetPixelBlue(image,p),q);
2017 SetPixelAlpha(splice_image,GetPixelAlpha(image,p),q);
2018 p+=(ptrdiff_t) GetPixelChannels(image);
2019 q+=(ptrdiff_t) GetPixelChannels(splice_image);
2021 for ( ; x < (splice_geometry.x+(ssize_t) splice_geometry.width); x++)
2022 q+=(ptrdiff_t) GetPixelChannels(splice_image);
2023 for ( ; x < (ssize_t) splice_image->columns; x++)
2028 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
2030 PixelChannel channel = GetPixelChannelChannel(image,i);
2031 PixelTrait traits = GetPixelChannelTraits(image,channel);
2032 PixelTrait splice_traits=GetPixelChannelTraits(splice_image,channel);
2033 if ((traits == UndefinedPixelTrait) ||
2034 (splice_traits == UndefinedPixelTrait))
2036 SetPixelChannel(splice_image,channel,p[i],q);
2038 SetPixelRed(splice_image,GetPixelRed(image,p),q);
2039 SetPixelGreen(splice_image,GetPixelGreen(image,p),q);
2040 SetPixelBlue(splice_image,GetPixelBlue(image,p),q);
2041 SetPixelAlpha(splice_image,GetPixelAlpha(image,p),q);
2042 p+=(ptrdiff_t) GetPixelChannels(image);
2043 q+=(ptrdiff_t) GetPixelChannels(splice_image);
2045 if (SyncCacheViewAuthenticPixels(splice_view,exception) == MagickFalse)
2047 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2052#if defined(MAGICKCORE_OPENMP_SUPPORT)
2056 proceed=SetImageProgress(image,SpliceImageTag,progress,
2057 splice_image->rows);
2058 if (proceed == MagickFalse)
2062 splice_view=DestroyCacheView(splice_view);
2063 image_view=DestroyCacheView(image_view);
2064 if (status == MagickFalse)
2065 splice_image=DestroyImage(splice_image);
2066 return(splice_image);
2116MagickPrivate MagickBooleanType TransformImage(Image **image,
2117 const char *crop_geometry,
const char *image_geometry,ExceptionInfo *exception)
2126 assert(image != (Image **) NULL);
2127 assert((*image)->signature == MagickCoreSignature);
2128 if (IsEventLogging() != MagickFalse)
2129 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",(*image)->filename);
2130 transform_image=(*image);
2131 if (crop_geometry != (
const char *) NULL)
2139 crop_image=CropImageToTiles(*image,crop_geometry,exception);
2140 if (crop_image == (Image *) NULL)
2141 transform_image=CloneImage(*image,0,0,MagickTrue,exception);
2144 transform_image=DestroyImage(transform_image);
2145 transform_image=GetFirstImageInList(crop_image);
2147 *image=transform_image;
2149 if (transform_image == (Image *) NULL)
2150 return(MagickFalse);
2154 if (image_geometry == (
const char *) NULL)
2156 (void) ParseRegionGeometry(transform_image,image_geometry,&geometry,
2158 if ((transform_image->columns == geometry.width) &&
2159 (transform_image->rows == geometry.height))
2161 resize_image=ResizeImage(transform_image,geometry.width,geometry.height,
2162 transform_image->filter,exception);
2163 if (resize_image == (Image *) NULL)
2164 return(MagickFalse);
2165 transform_image=DestroyImage(transform_image);
2166 transform_image=resize_image;
2167 *image=transform_image;
2196MagickExport Image *TransposeImage(
const Image *image,ExceptionInfo *exception)
2198#define TransposeImageTag "Transpose/Image"
2219 assert(image != (
const Image *) NULL);
2220 assert(image->signature == MagickCoreSignature);
2221 assert(exception != (ExceptionInfo *) NULL);
2222 assert(exception->signature == MagickCoreSignature);
2223 if (IsEventLogging() != MagickFalse)
2224 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2225 transpose_image=CloneImage(image,image->rows,image->columns,MagickTrue,
2227 if (transpose_image == (Image *) NULL)
2228 return((Image *) NULL);
2234 image_view=AcquireVirtualCacheView(image,exception);
2235 transpose_view=AcquireAuthenticCacheView(transpose_image,exception);
2236#if defined(MAGICKCORE_OPENMP_SUPPORT)
2237 #pragma omp parallel for schedule(static) shared(progress,status) \
2238 magick_number_threads(image,transpose_image,image->rows,2)
2240 for (y=0; y < (ssize_t) image->rows; y++)
2251 if (status == MagickFalse)
2253 p=GetCacheViewVirtualPixels(image_view,0,(ssize_t) image->rows-y-1,
2254 image->columns,1,exception);
2255 q=QueueCacheViewAuthenticPixels(transpose_view,(ssize_t) image->rows-y-1,
2256 0,1,transpose_image->rows,exception);
2257 if ((p == (
const Quantum *) NULL) || (q == (Quantum *) NULL))
2262 for (x=0; x < (ssize_t) image->columns; x++)
2267 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
2269 PixelChannel channel = GetPixelChannelChannel(image,i);
2270 PixelTrait traits = GetPixelChannelTraits(image,channel);
2271 PixelTrait transpose_traits=GetPixelChannelTraits(transpose_image,
2273 if ((traits == UndefinedPixelTrait) ||
2274 (transpose_traits == UndefinedPixelTrait))
2276 SetPixelChannel(transpose_image,channel,p[i],q);
2278 p+=(ptrdiff_t) GetPixelChannels(image);
2279 q+=(ptrdiff_t) GetPixelChannels(transpose_image);
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,image->rows);
2293 if (proceed == MagickFalse)
2297 transpose_view=DestroyCacheView(transpose_view);
2298 image_view=DestroyCacheView(image_view);
2299 transpose_image->type=image->type;
2300 page=transpose_image->page;
2301 Swap(page.width,page.height);
2302 Swap(page.x,page.y);
2303 transpose_image->page=page;
2304 if (status != MagickFalse)
2307 transform[MagickPathExtent];
2309 (void) FormatLocaleString(transform,MagickPathExtent,
2310 "transpose %.17gx%.17g",(
double) image->columns,
2311 (
double) image->rows);
2312 AppendImageProfileProperty(transpose_image,
"hdrgm",
"hdrgm:Transform",
2313 transform,exception);
2315 if (status == MagickFalse)
2316 transpose_image=DestroyImage(transpose_image);
2317 return(transpose_image);
2345MagickExport Image *TransverseImage(
const Image *image,ExceptionInfo *exception)
2347#define TransverseImageTag "Transverse/Image"
2368 assert(image != (
const Image *) NULL);
2369 assert(image->signature == MagickCoreSignature);
2370 assert(exception != (ExceptionInfo *) NULL);
2371 assert(exception->signature == MagickCoreSignature);
2372 if (IsEventLogging() != MagickFalse)
2373 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2374 transverse_image=CloneImage(image,image->rows,image->columns,MagickTrue,
2376 if (transverse_image == (Image *) NULL)
2377 return((Image *) NULL);
2383 image_view=AcquireVirtualCacheView(image,exception);
2384 transverse_view=AcquireAuthenticCacheView(transverse_image,exception);
2385#if defined(MAGICKCORE_OPENMP_SUPPORT)
2386 #pragma omp parallel for schedule(static) shared(progress,status) \
2387 magick_number_threads(image,transverse_image,image->rows,2)
2389 for (y=0; y < (ssize_t) image->rows; y++)
2403 if (status == MagickFalse)
2405 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
2406 q=QueueCacheViewAuthenticPixels(transverse_view,(ssize_t) image->rows-y-1,
2407 0,1,transverse_image->rows,exception);
2408 if ((p == (
const Quantum *) NULL) || (q == (Quantum *) NULL))
2413 q+=(ptrdiff_t) GetPixelChannels(transverse_image)*image->columns;
2414 for (x=0; x < (ssize_t) image->columns; x++)
2419 q-=GetPixelChannels(transverse_image);
2420 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
2422 PixelChannel channel = GetPixelChannelChannel(image,i);
2423 PixelTrait traits = GetPixelChannelTraits(image,channel);
2424 PixelTrait transverse_traits=GetPixelChannelTraits(transverse_image,
2426 if ((traits == UndefinedPixelTrait) ||
2427 (transverse_traits == UndefinedPixelTrait))
2429 SetPixelChannel(transverse_image,channel,p[i],q);
2431 p+=(ptrdiff_t) GetPixelChannels(image);
2433 sync=SyncCacheViewAuthenticPixels(transverse_view,exception);
2434 if (sync == MagickFalse)
2436 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2441#if defined(MAGICKCORE_OPENMP_SUPPORT)
2445 proceed=SetImageProgress(image,TransverseImageTag,progress,image->rows);
2446 if (proceed == MagickFalse)
2450 transverse_view=DestroyCacheView(transverse_view);
2451 image_view=DestroyCacheView(image_view);
2452 transverse_image->type=image->type;
2453 page=transverse_image->page;
2454 Swap(page.width,page.height);
2455 Swap(page.x,page.y);
2456 if (page.width != 0)
2457 page.x=(ssize_t) page.width-(ssize_t) transverse_image->columns-page.x;
2458 if (page.height != 0)
2459 page.y=(ssize_t) page.height-(ssize_t) transverse_image->rows-page.y;
2460 transverse_image->page=page;
2461 if (status != MagickFalse)
2464 transform[MagickPathExtent];
2466 (void) FormatLocaleString(transform,MagickPathExtent,
2467 "transverse %.17gx%.17g",(
double) image->columns,
2468 (
double) image->rows);
2469 AppendImageProfileProperty(transverse_image,
"hdrgm",
"hdrgm:Transform",
2470 transform,exception);
2472 if (status == MagickFalse)
2473 transverse_image=DestroyImage(transverse_image);
2474 return(transverse_image);
2503MagickExport Image *TrimImage(
const Image *image,ExceptionInfo *exception)
2514 assert(image != (
const Image *) NULL);
2515 assert(image->signature == MagickCoreSignature);
2516 if (IsEventLogging() != MagickFalse)
2517 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2518 geometry=GetImageBoundingBox(image,exception);
2519 if ((geometry.width == 0) || (geometry.height == 0))
2524 trim_image=CloneImage(image,1,1,MagickTrue,exception);
2525 if (trim_image != (Image *) NULL)
2527 trim_image->background_color.alpha_trait=BlendPixelTrait;
2528 trim_image->background_color.alpha=(MagickRealType) TransparentAlpha;
2529 (void) SetImageBackgroundColor(trim_image,exception);
2530 trim_image->page.width=image->columns;
2531 trim_image->page.height=image->rows;
2532 trim_image->page.x=(-1);
2533 trim_image->page.y=(-1);
2537 artifact=GetImageArtifact(image,
"trim:minSize");
2538 if (artifact != (
const char *) NULL)
2547 (void) ParseAbsoluteGeometry(artifact,&minSize);
2548 if ((geometry.width < minSize.width) ||
2549 (geometry.height < minSize.height))
2551 minSize.x=(geometry.width < minSize.width) ? (ssize_t)
2552 (minSize.width-geometry.width) : 0;
2553 minSize.y=(geometry.height < minSize.height) ? (ssize_t)
2554 (minSize.height-geometry.height) : 0;
2555 switch (image->gravity)
2557 case NorthWestGravity:
2559 geometry.x-=minSize.x;
2560 geometry.y-=minSize.y;
2565 geometry.x-=minSize.x/2;
2566 geometry.y-=minSize.y;
2569 case NorthEastGravity:
2571 geometry.y-=minSize.y;
2576 geometry.x-=minSize.x;
2577 geometry.y-=minSize.y/2;
2582 geometry.y-=minSize.y/2;
2585 case SouthWestGravity:
2587 geometry.x-=minSize.x;
2592 geometry.x-=minSize.x/2;
2597 geometry.x-=minSize.x/2;
2598 geometry.y-=minSize.y/2;
2601 case UndefinedGravity:
2602 case SouthEastGravity:
2606 if (geometry.width < minSize.width)
2607 geometry.width=minSize.width;
2608 if (geometry.height < minSize.height)
2609 geometry.height=minSize.height;
2610 if (geometry.width > image->columns)
2611 geometry.width=image->columns;
2612 if (geometry.height > image->rows)
2613 geometry.height=image->rows;
2616 if ((geometry.x+(ssize_t) geometry.width) > (ssize_t) image->columns)
2617 geometry.x=(ssize_t) image->columns-(ssize_t) geometry.width;
2620 if ((geometry.y+(ssize_t) geometry.height) > (ssize_t) image->rows)
2621 geometry.y=(ssize_t) image->rows-(ssize_t) geometry.height;
2624 geometry.x+=image->page.x;
2625 geometry.y+=image->page.y;
2626 trim_image=CropImage(image,&geometry,exception);
2627 if (trim_image != (Image *) NULL)
2629 trim_image->page.width=image->columns;
2630 trim_image->page.height=image->rows;
2631 if (trim_image->page.x == 0)
2632 trim_image->page.x=geometry.x;
2633 if (trim_image->page.y == 0)
2634 trim_image->page.y=geometry.y;