49 #include "magick/studio.h"
50 #include "magick/accelerate-private.h"
51 #include "magick/annotate.h"
52 #include "magick/artifact.h"
53 #include "magick/attribute.h"
54 #include "magick/cache.h"
55 #include "magick/cache-view.h"
56 #include "magick/channel.h"
57 #include "magick/color.h"
58 #include "magick/color-private.h"
59 #include "magick/colorspace.h"
60 #include "magick/colorspace-private.h"
61 #include "magick/composite.h"
62 #include "magick/decorate.h"
63 #include "magick/distort.h"
64 #include "magick/draw.h"
65 #include "magick/effect.h"
66 #include "magick/enhance.h"
67 #include "magick/exception.h"
68 #include "magick/exception-private.h"
69 #include "magick/gem.h"
70 #include "magick/geometry.h"
71 #include "magick/layer.h"
72 #include "magick/list.h"
73 #include "magick/log.h"
74 #include "magick/image.h"
75 #include "magick/image-private.h"
76 #include "magick/magick.h"
77 #include "magick/memory_.h"
78 #include "magick/memory-private.h"
79 #include "magick/monitor.h"
80 #include "magick/monitor-private.h"
81 #include "magick/opencl-private.h"
82 #include "magick/option.h"
83 #include "magick/pixel-accessor.h"
84 #include "magick/pixel-private.h"
85 #include "magick/property.h"
86 #include "magick/quantum.h"
87 #include "magick/quantum-private.h"
88 #include "magick/random_.h"
89 #include "magick/random-private.h"
90 #include "magick/resample.h"
91 #include "magick/resample-private.h"
92 #include "magick/resize.h"
93 #include "magick/resource_.h"
94 #include "magick/splay-tree.h"
95 #include "magick/statistic.h"
96 #include "magick/string_.h"
97 #include "magick/string-private.h"
98 #include "magick/thread-private.h"
99 #include "magick/threshold.h"
100 #include "magick/transform.h"
101 #include "magick/utility.h"
102 #include "magick/visual-effects.h"
136 MagickExport
Image *AddNoiseImage(
const Image *image,
const NoiseType noise_type,
142 noise_image=AddNoiseImageChannel(image,DefaultChannels,noise_type,exception);
146 MagickExport
Image *AddNoiseImageChannel(
const Image *image,
147 const ChannelType channel,
const NoiseType noise_type,
ExceptionInfo *exception)
149 #define AddNoiseImageTag "AddNoise/Image"
171 **magick_restrict random_info;
176 #if defined(MAGICKCORE_OPENMP_SUPPORT)
184 assert(image != (
const Image *) NULL);
185 assert(image->signature == MagickCoreSignature);
187 assert(exception->signature == MagickCoreSignature);
188 if (IsEventLogging() != MagickFalse)
189 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
190 #if defined(MAGICKCORE_OPENCL_SUPPORT)
191 noise_image=AccelerateAddNoiseImage(image,channel,noise_type,exception);
192 if (noise_image != (
Image *) NULL)
195 noise_image=CloneImage(image,0,0,MagickTrue,exception);
196 if (noise_image == (
Image *) NULL)
197 return((
Image *) NULL);
198 if (SetImageStorageClass(noise_image,DirectClass) == MagickFalse)
200 InheritException(exception,&noise_image->exception);
201 noise_image=DestroyImage(noise_image);
202 return((
Image *) NULL);
208 option=GetImageArtifact(image,
"attenuate");
209 if (option != (
char *) NULL)
210 attenuate=StringToDouble(option,(
char **) NULL);
213 random_info=AcquireRandomInfoTLS();
214 image_view=AcquireVirtualCacheView(image,exception);
215 noise_view=AcquireAuthenticCacheView(noise_image,exception);
216 #if defined(MAGICKCORE_OPENMP_SUPPORT)
217 key=GetRandomSecretKey(random_info[0]);
218 #pragma omp parallel for schedule(static) shared(progress,status) \
219 magick_number_threads(image,noise_image,image->rows,key == ~0UL)
221 for (y=0; y < (ssize_t) image->rows; y++)
224 id = GetOpenMPThreadId();
230 *magick_restrict indexes;
236 *magick_restrict noise_indexes;
244 if (status == MagickFalse)
246 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
247 q=GetCacheViewAuthenticPixels(noise_view,0,y,noise_image->columns,1,
254 indexes=GetCacheViewVirtualIndexQueue(image_view);
255 noise_indexes=GetCacheViewAuthenticIndexQueue(noise_view);
256 for (x=0; x < (ssize_t) image->columns; x++)
258 if ((channel & RedChannel) != 0)
259 SetPixelRed(q,ClampToQuantum(GenerateDifferentialNoise(random_info[
id],
260 GetPixelRed(p),noise_type,attenuate)));
261 if (IsGrayColorspace(image->colorspace) != MagickFalse)
263 SetPixelGreen(q,GetPixelRed(q));
264 SetPixelBlue(q,GetPixelRed(q));
268 if ((channel & GreenChannel) != 0)
269 SetPixelGreen(q,ClampToQuantum(GenerateDifferentialNoise(
270 random_info[
id],GetPixelGreen(p),noise_type,attenuate)));
271 if ((channel & BlueChannel) != 0)
272 SetPixelBlue(q,ClampToQuantum(GenerateDifferentialNoise(
273 random_info[
id],GetPixelBlue(p),noise_type,attenuate)));
275 if ((channel & OpacityChannel) != 0)
276 SetPixelOpacity(q,ClampToQuantum(GenerateDifferentialNoise(
277 random_info[
id],GetPixelOpacity(p),noise_type,attenuate)));
278 if (((channel & IndexChannel) != 0) &&
279 (image->colorspace == CMYKColorspace))
280 SetPixelIndex(noise_indexes+x,ClampToQuantum(
281 GenerateDifferentialNoise(random_info[
id],GetPixelIndex(
282 indexes+x),noise_type,attenuate)));
286 sync=SyncCacheViewAuthenticPixels(noise_view,exception);
287 if (sync == MagickFalse)
289 if (image->progress_monitor != (MagickProgressMonitor) NULL)
294 #if defined(MAGICKCORE_OPENMP_SUPPORT)
298 proceed=SetImageProgress(image,AddNoiseImageTag,progress,image->rows);
299 if (proceed == MagickFalse)
303 noise_view=DestroyCacheView(noise_view);
304 image_view=DestroyCacheView(image_view);
305 random_info=DestroyRandomInfoTLS(random_info);
306 if (status == MagickFalse)
307 noise_image=DestroyImage(noise_image);
339 MagickExport
Image *BlueShiftImage(
const Image *image,
const double factor,
342 #define BlueShiftImageTag "BlueShift/Image"
363 assert(image != (
const Image *) NULL);
364 assert(image->signature == MagickCoreSignature);
366 assert(exception->signature == MagickCoreSignature);
367 if (IsEventLogging() != MagickFalse)
368 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
369 shift_image=CloneImage(image,0,0,MagickTrue,exception);
370 if (shift_image == (
Image *) NULL)
371 return((
Image *) NULL);
372 if (SetImageStorageClass(shift_image,DirectClass) == MagickFalse)
374 InheritException(exception,&shift_image->exception);
375 shift_image=DestroyImage(shift_image);
376 return((
Image *) NULL);
383 image_view=AcquireVirtualCacheView(image,exception);
384 shift_view=AcquireAuthenticCacheView(shift_image,exception);
385 #if defined(MAGICKCORE_OPENMP_SUPPORT)
386 #pragma omp parallel for schedule(static) shared(progress,status) \
387 magick_number_threads(image,shift_image,image->rows,1)
389 for (y=0; y < (ssize_t) image->rows; y++)
409 if (status == MagickFalse)
411 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
412 q=QueueCacheViewAuthenticPixels(shift_view,0,y,shift_image->columns,1,
419 for (x=0; x < (ssize_t) image->columns; x++)
421 quantum=GetPixelRed(p);
422 if (GetPixelGreen(p) < quantum)
423 quantum=GetPixelGreen(p);
424 if (GetPixelBlue(p) < quantum)
425 quantum=GetPixelBlue(p);
426 pixel.red=0.5*(GetPixelRed(p)+factor*quantum);
427 pixel.green=0.5*(GetPixelGreen(p)+factor*quantum);
428 pixel.blue=0.5*(GetPixelBlue(p)+factor*quantum);
429 quantum=GetPixelRed(p);
430 if (GetPixelGreen(p) > quantum)
431 quantum=GetPixelGreen(p);
432 if (GetPixelBlue(p) > quantum)
433 quantum=GetPixelBlue(p);
434 pixel.red=0.5*(pixel.red+factor*quantum);
435 pixel.green=0.5*(pixel.green+factor*quantum);
436 pixel.blue=0.5*(pixel.blue+factor*quantum);
437 SetPixelRed(q,ClampToQuantum(pixel.red));
438 SetPixelGreen(q,ClampToQuantum(pixel.green));
439 SetPixelBlue(q,ClampToQuantum(pixel.blue));
443 sync=SyncCacheViewAuthenticPixels(shift_view,exception);
444 if (sync == MagickFalse)
446 if (image->progress_monitor != (MagickProgressMonitor) NULL)
451 #if defined(MAGICKCORE_OPENMP_SUPPORT)
455 proceed=SetImageProgress(image,BlueShiftImageTag,progress,image->rows);
456 if (proceed == MagickFalse)
460 image_view=DestroyCacheView(image_view);
461 shift_view=DestroyCacheView(shift_view);
462 if (status == MagickFalse)
463 shift_image=DestroyImage(shift_image);
498 MagickExport
Image *CharcoalImage(
const Image *image,
const double radius,
508 assert(image != (
Image *) NULL);
509 assert(image->signature == MagickCoreSignature);
511 assert(exception->signature == MagickCoreSignature);
512 if (IsEventLogging() != MagickFalse)
513 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
514 edge_image=EdgeImage(image,radius,exception);
515 if (edge_image == (
Image *) NULL)
516 return((
Image *) NULL);
517 charcoal_image=(
Image *) NULL;
518 status=ClampImage(edge_image);
519 if (status != MagickFalse)
520 charcoal_image=BlurImage(edge_image,radius,sigma,exception);
521 edge_image=DestroyImage(edge_image);
522 if (charcoal_image == (
Image *) NULL)
523 return((
Image *) NULL);
524 status=NormalizeImage(charcoal_image);
525 if (status != MagickFalse)
526 status=NegateImage(charcoal_image,MagickFalse);
527 if (status != MagickFalse)
528 status=GrayscaleImage(charcoal_image,image->intensity);
529 if (status == MagickFalse)
530 charcoal_image=DestroyImage(charcoal_image);
531 return(charcoal_image);
567 MagickExport
Image *ColorizeImage(
const Image *image,
const char *opacity,
570 #define ColorizeImageTag "Colorize/Image"
600 assert(image != (
const Image *) NULL);
601 assert(image->signature == MagickCoreSignature);
603 assert(exception->signature == MagickCoreSignature);
604 if (IsEventLogging() != MagickFalse)
605 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
606 colorize_image=CloneImage(image,0,0,MagickTrue,exception);
607 if (colorize_image == (
Image *) NULL)
608 return((
Image *) NULL);
609 if (SetImageStorageClass(colorize_image,DirectClass) == MagickFalse)
611 InheritException(exception,&colorize_image->exception);
612 colorize_image=DestroyImage(colorize_image);
613 return((
Image *) NULL);
615 if ((IsGrayColorspace(image->colorspace) != MagickFalse) ||
616 (IsPixelGray(&colorize) != MagickFalse))
617 (void) SetImageColorspace(colorize_image,sRGBColorspace);
618 if ((colorize_image->matte == MagickFalse) &&
619 (colorize.opacity != OpaqueOpacity))
620 (void) SetImageAlphaChannel(colorize_image,OpaqueAlphaChannel);
621 if (opacity == (
const char *) NULL)
622 return(colorize_image);
626 flags=ParseGeometry(opacity,&geometry_info);
627 pixel.red=geometry_info.rho;
628 pixel.green=geometry_info.rho;
629 pixel.blue=geometry_info.rho;
630 pixel.opacity=(MagickRealType) OpaqueOpacity;
631 if ((flags & SigmaValue) != 0)
632 pixel.green=geometry_info.sigma;
633 if ((flags & XiValue) != 0)
634 pixel.blue=geometry_info.xi;
635 if ((flags & PsiValue) != 0)
636 pixel.opacity=geometry_info.psi;
642 image_view=AcquireVirtualCacheView(image,exception);
643 colorize_view=AcquireAuthenticCacheView(colorize_image,exception);
644 #if defined(MAGICKCORE_OPENMP_SUPPORT)
645 #pragma omp parallel for schedule(static) shared(progress,status) \
646 magick_number_threads(image,colorize_image,image->rows,1)
648 for (y=0; y < (ssize_t) image->rows; y++)
662 if (status == MagickFalse)
664 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
665 q=QueueCacheViewAuthenticPixels(colorize_view,0,y,colorize_image->columns,1,
672 for (x=0; x < (ssize_t) image->columns; x++)
674 SetPixelRed(q,((GetPixelRed(p)*(100.0-pixel.red)+
675 colorize.red*pixel.red)/100.0));
676 SetPixelGreen(q,((GetPixelGreen(p)*(100.0-pixel.green)+
677 colorize.green*pixel.green)/100.0));
678 SetPixelBlue(q,((GetPixelBlue(p)*(100.0-pixel.blue)+
679 colorize.blue*pixel.blue)/100.0));
680 if (colorize_image->matte == MagickFalse)
681 SetPixelOpacity(q,GetPixelOpacity(p));
683 SetPixelOpacity(q,((GetPixelOpacity(p)*(100.0-pixel.opacity)+
684 colorize.opacity*pixel.opacity)/100.0));
688 sync=SyncCacheViewAuthenticPixels(colorize_view,exception);
689 if (sync == MagickFalse)
691 if (image->progress_monitor != (MagickProgressMonitor) NULL)
696 #if defined(MAGICKCORE_OPENMP_SUPPORT)
700 proceed=SetImageProgress(image,ColorizeImageTag,progress,image->rows);
701 if (proceed == MagickFalse)
705 image_view=DestroyCacheView(image_view);
706 colorize_view=DestroyCacheView(colorize_view);
707 if (status == MagickFalse)
708 colorize_image=DestroyImage(colorize_image);
709 return(colorize_image);
745 MagickExport
Image *ColorMatrixImage(
const Image *image,
748 #define ColorMatrixImageTag "ColorMatrix/Image"
757 { 1.0, 0.0, 0.0, 0.0, 0.0, 0.0 },
758 { 0.0, 1.0, 0.0, 0.0, 0.0, 0.0 },
759 { 0.0, 0.0, 1.0, 0.0, 0.0, 0.0 },
760 { 0.0, 0.0, 0.0, 1.0, 0.0, 0.0 },
761 { 0.0, 0.0, 0.0, 0.0, 1.0, 0.0 },
762 { 0.0, 0.0, 0.0, 0.0, 0.0, 1.0 }
785 assert(image != (
Image *) NULL);
786 assert(image->signature == MagickCoreSignature);
788 assert(exception->signature == MagickCoreSignature);
789 if (IsEventLogging() != MagickFalse)
790 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
792 for (v=0; v < (ssize_t) color_matrix->height; v++)
793 for (u=0; u < (ssize_t) color_matrix->width; u++)
795 if ((v < 6) && (u < 6))
796 ColorMatrix[v][u]=color_matrix->values[i];
802 color_image=CloneImage(image,0,0,MagickTrue,exception);
803 if (color_image == (
Image *) NULL)
804 return((
Image *) NULL);
805 if (SetImageStorageClass(color_image,DirectClass) == MagickFalse)
807 InheritException(exception,&color_image->exception);
808 color_image=DestroyImage(color_image);
809 return((
Image *) NULL);
811 if (image->debug != MagickFalse)
814 format[MaxTextExtent],
817 (void) LogMagickEvent(TransformEvent,GetMagickModule(),
818 " ColorMatrix image with color matrix:");
819 message=AcquireString(
"");
820 for (v=0; v < 6; v++)
823 (void) FormatLocaleString(format,MaxTextExtent,
"%.20g: ",(
double) v);
824 (void) ConcatenateString(&message,format);
825 for (u=0; u < 6; u++)
827 (void) FormatLocaleString(format,MaxTextExtent,
"%+f ",
829 (void) ConcatenateString(&message,format);
831 (void) LogMagickEvent(TransformEvent,GetMagickModule(),
"%s",message);
833 message=DestroyString(message);
840 image_view=AcquireVirtualCacheView(image,exception);
841 color_view=AcquireAuthenticCacheView(color_image,exception);
842 #if defined(MAGICKCORE_OPENMP_SUPPORT)
843 #pragma omp parallel for schedule(static) shared(progress,status) \
844 magick_number_threads(image,color_image,image->rows,1)
846 for (y=0; y < (ssize_t) image->rows; y++)
852 *magick_restrict indexes;
861 *magick_restrict color_indexes;
866 if (status == MagickFalse)
868 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
869 q=GetCacheViewAuthenticPixels(color_view,0,y,color_image->columns,1,
876 indexes=GetCacheViewVirtualIndexQueue(image_view);
877 color_indexes=GetCacheViewAuthenticIndexQueue(color_view);
878 for (x=0; x < (ssize_t) image->columns; x++)
886 height=color_matrix->height > 6 ? 6UL : color_matrix->height;
887 for (v=0; v < (ssize_t) height; v++)
889 pixel=ColorMatrix[v][0]*GetPixelRed(p)+ColorMatrix[v][1]*
890 GetPixelGreen(p)+ColorMatrix[v][2]*GetPixelBlue(p);
891 if (image->matte != MagickFalse)
892 pixel+=ColorMatrix[v][3]*(QuantumRange-GetPixelOpacity(p));
893 if (image->colorspace == CMYKColorspace)
894 pixel+=ColorMatrix[v][4]*GetPixelIndex(indexes+x);
895 pixel+=QuantumRange*ColorMatrix[v][5];
898 case 0: SetPixelRed(q,ClampToQuantum(pixel));
break;
899 case 1: SetPixelGreen(q,ClampToQuantum(pixel));
break;
900 case 2: SetPixelBlue(q,ClampToQuantum(pixel));
break;
903 if (image->matte != MagickFalse)
904 SetPixelAlpha(q,ClampToQuantum(pixel));
909 if (image->colorspace == CMYKColorspace)
910 SetPixelIndex(color_indexes+x,ClampToQuantum(pixel));
918 if (SyncCacheViewAuthenticPixels(color_view,exception) == MagickFalse)
920 if (image->progress_monitor != (MagickProgressMonitor) NULL)
925 #if defined(MAGICKCORE_OPENMP_SUPPORT)
929 proceed=SetImageProgress(image,ColorMatrixImageTag,progress,
931 if (proceed == MagickFalse)
935 color_view=DestroyCacheView(color_view);
936 image_view=DestroyCacheView(image_view);
937 if (status == MagickFalse)
938 color_image=DestroyImage(color_image);
976 MagickExport
Image *ImplodeImage(
const Image *image,
const double amount,
979 #define ImplodeImageTag "Implode/Image"
1010 assert(image != (
Image *) NULL);
1011 assert(image->signature == MagickCoreSignature);
1013 assert(exception->signature == MagickCoreSignature);
1014 if (IsEventLogging() != MagickFalse)
1015 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1016 implode_image=CloneImage(image,0,0,MagickTrue,exception);
1017 if (implode_image == (
Image *) NULL)
1018 return((
Image *) NULL);
1019 if (SetImageStorageClass(implode_image,DirectClass) == MagickFalse)
1021 InheritException(exception,&implode_image->exception);
1022 implode_image=DestroyImage(implode_image);
1023 return((
Image *) NULL);
1025 if (implode_image->background_color.opacity != OpaqueOpacity)
1026 implode_image->matte=MagickTrue;
1032 center.x=0.5*image->columns;
1033 center.y=0.5*image->rows;
1035 if (image->columns > image->rows)
1036 scale.y=(double) image->columns*PerceptibleReciprocal((
double)
1039 if (image->columns < image->rows)
1041 scale.x=(double) image->rows*PerceptibleReciprocal((
double)
1050 GetMagickPixelPacket(implode_image,&zero);
1051 image_view=AcquireVirtualCacheView(image,exception);
1052 implode_view=AcquireAuthenticCacheView(implode_image,exception);
1053 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1054 #pragma omp parallel for schedule(static) shared(progress,status) \
1055 magick_number_threads(image,implode_image,image->rows,1)
1057 for (y=0; y < (ssize_t) image->rows; y++)
1069 *magick_restrict implode_indexes;
1077 if (status == MagickFalse)
1079 q=GetCacheViewAuthenticPixels(implode_view,0,y,implode_image->columns,1,
1086 implode_indexes=GetCacheViewAuthenticIndexQueue(implode_view);
1087 delta.y=scale.y*(double) (y-center.y);
1089 for (x=0; x < (ssize_t) image->columns; x++)
1094 delta.x=scale.x*(double) (x-center.x);
1095 distance=delta.x*delta.x+delta.y*delta.y;
1096 if (distance < (radius*radius))
1106 factor=pow(sin((
double) (MagickPI*sqrt((
double) distance)*
1107 PerceptibleReciprocal(radius)/2)),-amount);
1108 status=InterpolateMagickPixelPacket(image,image_view,
1109 UndefinedInterpolatePixel,(
double) (factor*delta.x*PerceptibleReciprocal(scale.x)+
1110 center.x),(
double) (factor*delta.y*PerceptibleReciprocal(scale.y)+center.y),&pixel,
1112 if (status == MagickFalse)
1114 SetPixelPacket(implode_image,&pixel,q,implode_indexes+x);
1118 if (SyncCacheViewAuthenticPixels(implode_view,exception) == MagickFalse)
1120 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1125 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1129 proceed=SetImageProgress(image,ImplodeImageTag,progress,image->rows);
1130 if (proceed == MagickFalse)
1134 implode_view=DestroyCacheView(implode_view);
1135 image_view=DestroyCacheView(image_view);
1136 if (status == MagickFalse)
1137 implode_image=DestroyImage(implode_image);
1138 return(implode_image);
1171 MagickExport
Image *MorphImages(
const Image *image,
1174 #define MorphImageTag "Morph/Image"
1202 assert(image != (
Image *) NULL);
1203 assert(image->signature == MagickCoreSignature);
1205 assert(exception->signature == MagickCoreSignature);
1206 if (IsEventLogging() != MagickFalse)
1207 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1208 morph_images=CloneImage(image,0,0,MagickTrue,exception);
1209 if (morph_images == (
Image *) NULL)
1210 return((
Image *) NULL);
1211 if (GetNextImageInList(image) == (
Image *) NULL)
1216 for (i=1; i < (ssize_t) number_frames; i++)
1218 morph_image=CloneImage(image,0,0,MagickTrue,exception);
1219 if (morph_image == (
Image *) NULL)
1221 morph_images=DestroyImageList(morph_images);
1222 return((
Image *) NULL);
1224 AppendImageToList(&morph_images,morph_image);
1225 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1230 proceed=SetImageProgress(image,MorphImageTag,(MagickOffsetType) i,
1232 if (proceed == MagickFalse)
1236 return(GetFirstImageInList(morph_images));
1244 for ( ; GetNextImageInList(next) != (
Image *) NULL; next=GetNextImageInList(next))
1246 for (i=0; i < (ssize_t) number_frames; i++)
1252 beta=(double) (i+1.0)/(double) (number_frames+1.0);
1254 morph_image=ResizeImage(next,(
size_t) (alpha*next->columns+beta*
1255 GetNextImageInList(next)->columns+0.5),(
size_t) (alpha*
1256 next->rows+beta*GetNextImageInList(next)->rows+0.5),
1257 next->filter,next->blur,exception);
1258 if (morph_image == (
Image *) NULL)
1260 morph_images=DestroyImageList(morph_images);
1261 return((
Image *) NULL);
1263 if (SetImageStorageClass(morph_image,DirectClass) == MagickFalse)
1265 InheritException(exception,&morph_image->exception);
1266 morph_image=DestroyImage(morph_image);
1267 return((
Image *) NULL);
1269 AppendImageToList(&morph_images,morph_image);
1270 morph_images=GetLastImageInList(morph_images);
1271 morph_image=ResizeImage(GetNextImageInList(next),morph_images->columns,
1272 morph_images->rows,GetNextImageInList(next)->filter,
1273 GetNextImageInList(next)->blur,exception);
1274 if (morph_image == (
Image *) NULL)
1276 morph_images=DestroyImageList(morph_images);
1277 return((
Image *) NULL);
1279 image_view=AcquireVirtualCacheView(morph_image,exception);
1280 morph_view=AcquireAuthenticCacheView(morph_images,exception);
1281 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1282 #pragma omp parallel for schedule(static) shared(status) \
1283 magick_number_threads(morph_image,morph_image,morph_image->rows,1)
1285 for (y=0; y < (ssize_t) morph_images->rows; y++)
1299 if (status == MagickFalse)
1301 p=GetCacheViewVirtualPixels(image_view,0,y,morph_image->columns,1,
1303 q=GetCacheViewAuthenticPixels(morph_view,0,y,morph_images->columns,1,
1310 for (x=0; x < (ssize_t) morph_images->columns; x++)
1312 SetPixelRed(q,ClampToQuantum(alpha*
1313 GetPixelRed(q)+beta*GetPixelRed(p)));
1314 SetPixelGreen(q,ClampToQuantum(alpha*
1315 GetPixelGreen(q)+beta*GetPixelGreen(p)));
1316 SetPixelBlue(q,ClampToQuantum(alpha*
1317 GetPixelBlue(q)+beta*GetPixelBlue(p)));
1318 SetPixelOpacity(q,ClampToQuantum(alpha*
1319 GetPixelOpacity(q)+beta*GetPixelOpacity(p)));
1323 sync=SyncCacheViewAuthenticPixels(morph_view,exception);
1324 if (sync == MagickFalse)
1327 morph_view=DestroyCacheView(morph_view);
1328 image_view=DestroyCacheView(image_view);
1329 morph_image=DestroyImage(morph_image);
1331 if (i < (ssize_t) number_frames)
1336 morph_image=CloneImage(GetNextImageInList(next),0,0,MagickTrue,exception);
1337 if (morph_image == (
Image *) NULL)
1339 morph_images=DestroyImageList(morph_images);
1340 return((
Image *) NULL);
1342 AppendImageToList(&morph_images,morph_image);
1343 morph_images=GetLastImageInList(morph_images);
1344 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1349 proceed=SetImageProgress(image,MorphImageTag,scene,
1350 GetImageListLength(image));
1351 if (proceed == MagickFalse)
1356 if (GetNextImageInList(next) != (
Image *) NULL)
1358 morph_images=DestroyImageList(morph_images);
1359 return((
Image *) NULL);
1361 return(GetFirstImageInList(morph_images));
1396 static inline Quantum PlasmaPixel(
RandomInfo *magick_restrict random_info,
1397 const MagickRealType pixel,
const double noise)
1402 plasma=pixel+noise*GetPseudoRandomValue(random_info)-noise/2.0;
1403 return(ClampToQuantum(plasma));
1406 MagickExport MagickBooleanType PlasmaImageProxy(
Image *image,
1409 const SegmentInfo *magick_restrict segment,
size_t attenuate,
size_t depth)
1430 if ((fabs(segment->x2-segment->x1) < MagickEpsilon) &&
1431 (fabs(segment->y2-segment->y1) < MagickEpsilon))
1443 x_mid=CastDoubleToLong(ceil((segment->x1+segment->x2)/2-0.5));
1444 y_mid=CastDoubleToLong(ceil((segment->y1+segment->y2)/2-0.5));
1445 local_info=(*segment);
1446 local_info.x2=(double) x_mid;
1447 local_info.y2=(double) y_mid;
1448 status=PlasmaImageProxy(image,image_view,u_view,v_view,random_info,
1449 &local_info,attenuate,depth);
1450 local_info=(*segment);
1451 local_info.y1=(double) y_mid;
1452 local_info.x2=(double) x_mid;
1453 status&=PlasmaImageProxy(image,image_view,u_view,v_view,random_info,
1454 &local_info,attenuate,depth);
1455 local_info=(*segment);
1456 local_info.x1=(double) x_mid;
1457 local_info.y2=(double) y_mid;
1458 status&=PlasmaImageProxy(image,image_view,u_view,v_view,random_info,
1459 &local_info,attenuate,depth);
1460 local_info=(*segment);
1461 local_info.x1=(double) x_mid;
1462 local_info.y1=(double) y_mid;
1463 status&=PlasmaImageProxy(image,image_view,u_view,v_view,random_info,
1464 &local_info,attenuate,depth);
1465 return(status == 0 ? MagickFalse : MagickTrue);
1467 x_mid=CastDoubleToLong(ceil((segment->x1+segment->x2)/2-0.5));
1468 y_mid=CastDoubleToLong(ceil((segment->y1+segment->y2)/2-0.5));
1469 if ((fabs(segment->x1-x_mid) < MagickEpsilon) &&
1470 (fabs(segment->x2-x_mid) < MagickEpsilon) &&
1471 (fabs(segment->y1-y_mid) < MagickEpsilon) &&
1472 (fabs(segment->y2-y_mid) < MagickEpsilon))
1473 return(MagickFalse);
1478 exception=(&image->exception);
1479 plasma=(double) QuantumRange/(2.0*attenuate);
1480 if ((fabs(segment->x1-x_mid) >= MagickEpsilon) ||
1481 (fabs(segment->x2-x_mid) >= MagickEpsilon))
1489 x=CastDoubleToLong(ceil(segment->x1-0.5));
1490 (void) GetOneCacheViewVirtualPixel(u_view,x,CastDoubleToLong(ceil(
1491 segment->y1-0.5)),&u,exception);
1492 (void) GetOneCacheViewVirtualPixel(v_view,x,CastDoubleToLong(ceil(
1493 segment->y2-0.5)),&v,exception);
1494 q=QueueCacheViewAuthenticPixels(image_view,x,y_mid,1,1,exception);
1497 SetPixelRed(q,PlasmaPixel(random_info,((MagickRealType) u.red+
1498 v.red)/2.0,plasma));
1499 SetPixelGreen(q,PlasmaPixel(random_info,((MagickRealType) u.green+
1500 v.green)/2.0,plasma));
1501 SetPixelBlue(q,PlasmaPixel(random_info,((MagickRealType) u.blue+
1502 v.blue)/2.0,plasma));
1503 status=SyncCacheViewAuthenticPixels(image_view,exception);
1504 if (fabs(segment->x1-segment->x2) >= MagickEpsilon)
1509 x=CastDoubleToLong(ceil(segment->x2-0.5));
1510 (void) GetOneCacheViewVirtualPixel(u_view,x,CastDoubleToLong(ceil(
1511 segment->y1-0.5)),&u,exception);
1512 (void) GetOneCacheViewVirtualPixel(v_view,x,CastDoubleToLong(ceil(
1513 segment->y2-0.5)),&v,exception);
1514 q=QueueCacheViewAuthenticPixels(image_view,x,y_mid,1,1,exception);
1516 return(MagickFalse);
1517 SetPixelRed(q,PlasmaPixel(random_info,((MagickRealType) u.red+
1518 v.red)/2.0,plasma));
1519 SetPixelGreen(q,PlasmaPixel(random_info,((MagickRealType) u.green+
1520 v.green)/2.0,plasma));
1521 SetPixelBlue(q,PlasmaPixel(random_info,((MagickRealType) u.blue+
1522 v.blue)/2.0,plasma));
1523 status=SyncCacheViewAuthenticPixels(image_view,exception);
1526 if ((fabs(segment->y1-y_mid) >= MagickEpsilon) ||
1527 (fabs(segment->y2-y_mid) >= MagickEpsilon))
1529 if ((fabs(segment->x1-x_mid) >= MagickEpsilon) ||
1530 (fabs(segment->y2-y_mid) >= MagickEpsilon))
1538 y=CastDoubleToLong(ceil(segment->y2-0.5));
1539 (void) GetOneCacheViewVirtualPixel(u_view,CastDoubleToLong(ceil(
1540 segment->x1-0.5)),y,&u,exception);
1541 (void) GetOneCacheViewVirtualPixel(v_view,CastDoubleToLong(ceil(
1542 segment->x2-0.5)),y,&v,exception);
1543 q=QueueCacheViewAuthenticPixels(image_view,x_mid,y,1,1,exception);
1546 SetPixelRed(q,PlasmaPixel(random_info,((MagickRealType) u.red+
1547 v.red)/2.0,plasma));
1548 SetPixelGreen(q,PlasmaPixel(random_info,((MagickRealType) u.green+
1549 v.green)/2.0,plasma));
1550 SetPixelBlue(q,PlasmaPixel(random_info,((MagickRealType) u.blue+
1551 v.blue)/2.0,plasma));
1552 status=SyncCacheViewAuthenticPixels(image_view,exception);
1554 if (fabs(segment->y1-segment->y2) >= MagickEpsilon)
1562 y=CastDoubleToLong(ceil(segment->y1-0.5));
1563 (void) GetOneCacheViewVirtualPixel(u_view,CastDoubleToLong(ceil(
1564 segment->x1-0.5)),y,&u,exception);
1565 (void) GetOneCacheViewVirtualPixel(v_view,CastDoubleToLong(ceil(
1566 segment->x2-0.5)),y,&v,exception);
1567 q=QueueCacheViewAuthenticPixels(image_view,x_mid,y,1,1,exception);
1570 SetPixelRed(q,PlasmaPixel(random_info,((MagickRealType) u.red+
1571 v.red)/2.0,plasma));
1572 SetPixelGreen(q,PlasmaPixel(random_info,((MagickRealType) u.green+
1573 v.green)/2.0,plasma));
1574 SetPixelBlue(q,PlasmaPixel(random_info,((MagickRealType) u.blue+
1575 v.blue)/2.0,plasma));
1576 status=SyncCacheViewAuthenticPixels(image_view,exception);
1579 if ((fabs(segment->x1-segment->x2) >= MagickEpsilon) ||
1580 (fabs(segment->y1-segment->y2) >= MagickEpsilon))
1588 x=CastDoubleToLong(ceil(segment->x1-0.5));
1589 y=CastDoubleToLong(ceil(segment->y1-0.5));
1590 (void) GetOneCacheViewVirtualPixel(u_view,x,y,&u,exception);
1591 x=CastDoubleToLong(ceil(segment->x2-0.5));
1592 y=CastDoubleToLong(ceil(segment->y2-0.5));
1593 (void) GetOneCacheViewVirtualPixel(v_view,x,y,&v,exception);
1594 q=QueueCacheViewAuthenticPixels(image_view,x_mid,y_mid,1,1,exception);
1597 SetPixelRed(q,PlasmaPixel(random_info,((MagickRealType) u.red+
1598 v.red)/2.0,plasma));
1599 SetPixelGreen(q,PlasmaPixel(random_info,((MagickRealType) u.green+
1600 v.green)/2.0,plasma));
1601 SetPixelBlue(q,PlasmaPixel(random_info,((MagickRealType) u.blue+
1602 v.blue)/2.0,plasma));
1603 status=SyncCacheViewAuthenticPixels(image_view,exception);
1605 if ((fabs(segment->x2-segment->x1) < 3.0) &&
1606 (fabs(segment->y2-segment->y1) < 3.0))
1607 return(status == 0 ? MagickFalse : MagickTrue);
1608 return(MagickFalse);
1611 MagickExport MagickBooleanType PlasmaImage(
Image *image,
1612 const SegmentInfo *segment,
size_t attenuate,
size_t depth)
1625 assert(image != (
Image *) NULL);
1626 assert(image->signature == MagickCoreSignature);
1627 if (IsEventLogging() != MagickFalse)
1628 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
1629 if (SetImageStorageClass(image,DirectClass) == MagickFalse)
1630 return(MagickFalse);
1631 image_view=AcquireAuthenticCacheView(image,&image->exception);
1632 u_view=AcquireVirtualCacheView(image,&image->exception);
1633 v_view=AcquireVirtualCacheView(image,&image->exception);
1634 random_info=AcquireRandomInfo();
1635 status=PlasmaImageProxy(image,image_view,u_view,v_view,random_info,segment,
1637 random_info=DestroyRandomInfo(random_info);
1638 v_view=DestroyCacheView(v_view);
1639 u_view=DestroyCacheView(u_view);
1640 image_view=DestroyCacheView(image_view);
1697 assert(image != (
Image *) NULL);
1698 assert(image->signature == MagickCoreSignature);
1700 assert(exception->signature == MagickCoreSignature);
1701 if (IsEventLogging() != MagickFalse)
1702 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1703 quantum=(ssize_t) MagickMax(MagickMax((
double) image->columns,(double)
1704 image->rows)/25.0,10.0);
1705 height=image->rows+2*quantum;
1706 caption_image=(
Image *) NULL;
1707 value=GetImageProperty(image,
"Caption");
1708 if (value != (
const char *) NULL)
1716 caption_image=CloneImage(image,image->columns,1,MagickTrue,exception);
1717 if (caption_image == (
Image *) NULL)
1718 return((
Image *) NULL);
1719 caption=InterpretImageProperties((
ImageInfo *) NULL,(
Image *) image,
1721 if (caption != (
char *) NULL)
1724 geometry[MaxTextExtent];
1738 annotate_info=CloneDrawInfo((
const ImageInfo *) NULL,draw_info);
1739 (void) CloneString(&annotate_info->text,caption);
1740 count=FormatMagickCaption(caption_image,annotate_info,MagickTrue,
1742 status=SetImageExtent(caption_image,image->columns,(
size_t)
1743 ((count+1)*(metrics.ascent-metrics.descent)+0.5));
1744 if (status == MagickFalse)
1745 caption_image=DestroyImage(caption_image);
1748 caption_image->background_color=image->border_color;
1749 (void) SetImageBackgroundColor(caption_image);
1750 (void) CloneString(&annotate_info->text,caption);
1751 (void) FormatLocaleString(geometry,MaxTextExtent,
"+0+%.20g",
1753 if (annotate_info->gravity == UndefinedGravity)
1754 (void) CloneString(&annotate_info->geometry,AcquireString(
1756 (void) AnnotateImage(caption_image,annotate_info);
1757 height+=caption_image->rows;
1759 annotate_info=DestroyDrawInfo(annotate_info);
1760 caption=DestroyString(caption);
1763 picture_image=CloneImage(image,image->columns+2*quantum,height,MagickTrue,
1765 if (picture_image == (
Image *) NULL)
1767 if (caption_image != (
Image *) NULL)
1768 caption_image=DestroyImage(caption_image);
1769 return((
Image *) NULL);
1771 picture_image->background_color=image->border_color;
1772 (void) SetImageBackgroundColor(picture_image);
1773 (void) CompositeImage(picture_image,OverCompositeOp,image,quantum,quantum);
1774 if (caption_image != (
Image *) NULL)
1776 (void) CompositeImage(picture_image,OverCompositeOp,caption_image,
1777 quantum,(ssize_t) (image->rows+3*quantum/2));
1778 caption_image=DestroyImage(caption_image);
1780 (void) QueryColorDatabase(
"none",&picture_image->background_color,exception);
1781 (void) SetImageAlphaChannel(picture_image,OpaqueAlphaChannel);
1782 rotate_image=RotateImage(picture_image,90.0,exception);
1783 picture_image=DestroyImage(picture_image);
1784 if (rotate_image == (
Image *) NULL)
1785 return((
Image *) NULL);
1786 picture_image=rotate_image;
1787 bend_image=WaveImage(picture_image,0.01*picture_image->rows,2.0*
1788 picture_image->columns,exception);
1789 picture_image=DestroyImage(picture_image);
1790 if (bend_image == (
Image *) NULL)
1791 return((
Image *) NULL);
1792 InheritException(&bend_image->exception,exception);
1793 picture_image=bend_image;
1794 rotate_image=RotateImage(picture_image,-90.0,exception);
1795 picture_image=DestroyImage(picture_image);
1796 if (rotate_image == (
Image *) NULL)
1797 return((
Image *) NULL);
1798 picture_image=rotate_image;
1799 picture_image->background_color=image->background_color;
1800 polaroid_image=ShadowImage(picture_image,80.0,2.0,quantum/3,quantum/3,
1802 if (polaroid_image == (
Image *) NULL)
1804 picture_image=DestroyImage(picture_image);
1805 return(picture_image);
1807 flop_image=FlopImage(polaroid_image,exception);
1808 polaroid_image=DestroyImage(polaroid_image);
1809 if (flop_image == (
Image *) NULL)
1811 picture_image=DestroyImage(picture_image);
1812 return(picture_image);
1814 polaroid_image=flop_image;
1815 (void) CompositeImage(polaroid_image,OverCompositeOp,picture_image,
1816 (ssize_t) (-0.01*picture_image->columns/2.0),0L);
1817 picture_image=DestroyImage(picture_image);
1818 (void) QueryColorDatabase(
"none",&polaroid_image->background_color,exception);
1819 rotate_image=RotateImage(polaroid_image,angle,exception);
1820 polaroid_image=DestroyImage(polaroid_image);
1821 if (rotate_image == (
Image *) NULL)
1822 return((
Image *) NULL);
1823 polaroid_image=rotate_image;
1824 trim_image=TrimImage(polaroid_image,exception);
1825 polaroid_image=DestroyImage(polaroid_image);
1826 if (trim_image == (
Image *) NULL)
1827 return((
Image *) NULL);
1828 polaroid_image=trim_image;
1829 return(polaroid_image);
1862 MagickExport
Image *SepiaToneImage(
const Image *image,
const double threshold,
1865 #define SepiaToneImageTag "SepiaTone/Image"
1886 assert(image != (
const Image *) NULL);
1887 assert(image->signature == MagickCoreSignature);
1889 assert(exception->signature == MagickCoreSignature);
1890 if (IsEventLogging() != MagickFalse)
1891 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1892 sepia_image=CloneImage(image,0,0,MagickTrue,exception);
1893 if (sepia_image == (
Image *) NULL)
1894 return((
Image *) NULL);
1895 if (SetImageStorageClass(sepia_image,DirectClass) == MagickFalse)
1897 InheritException(exception,&sepia_image->exception);
1898 sepia_image=DestroyImage(sepia_image);
1899 return((
Image *) NULL);
1906 image_view=AcquireVirtualCacheView(image,exception);
1907 sepia_view=AcquireAuthenticCacheView(sepia_image,exception);
1908 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1909 #pragma omp parallel for schedule(static) shared(progress,status) \
1910 magick_number_threads(image,sepia_image,image->rows,1)
1912 for (y=0; y < (ssize_t) image->rows; y++)
1923 if (status == MagickFalse)
1925 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
1926 q=QueueCacheViewAuthenticPixels(sepia_view,0,y,sepia_image->columns,1,
1933 for (x=0; x < (ssize_t) image->columns; x++)
1939 intensity=GetPixelIntensity(image,p);
1940 tone=intensity > threshold ? (double) QuantumRange : intensity+
1941 (
double) QuantumRange-threshold;
1942 SetPixelRed(q,ClampToQuantum(tone));
1943 tone=intensity > (7.0*threshold/6.0) ? (
double) QuantumRange :
1944 intensity+(
double) QuantumRange-7.0*threshold/6.0;
1945 SetPixelGreen(q,ClampToQuantum(tone));
1946 tone=intensity < (threshold/6.0) ? 0 : intensity-threshold/6.0;
1947 SetPixelBlue(q,ClampToQuantum(tone));
1949 if ((
double) GetPixelGreen(q) < tone)
1950 SetPixelGreen(q,ClampToQuantum(tone));
1951 if ((
double) GetPixelBlue(q) < tone)
1952 SetPixelBlue(q,ClampToQuantum(tone));
1953 SetPixelOpacity(q,GetPixelOpacity(p));
1957 if (SyncCacheViewAuthenticPixels(sepia_view,exception) == MagickFalse)
1959 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1964 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1968 proceed=SetImageProgress(image,SepiaToneImageTag,progress,image->rows);
1969 if (proceed == MagickFalse)
1973 sepia_view=DestroyCacheView(sepia_view);
1974 image_view=DestroyCacheView(image_view);
1975 (void) NormalizeImage(sepia_image);
1976 (void) ContrastImage(sepia_image,MagickTrue);
1977 if (status == MagickFalse)
1978 sepia_image=DestroyImage(sepia_image);
1979 return(sepia_image);
2016 MagickExport
Image *ShadowImage(
const Image *image,
const double opacity,
2017 const double sigma,
const ssize_t x_offset,
const ssize_t y_offset,
2020 #define ShadowImageTag "Shadow/Image"
2042 assert(image != (
Image *) NULL);
2043 assert(image->signature == MagickCoreSignature);
2045 assert(exception->signature == MagickCoreSignature);
2046 if (IsEventLogging() != MagickFalse)
2047 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2048 clone_image=CloneImage(image,0,0,MagickTrue,exception);
2049 if (clone_image == (
Image *) NULL)
2050 return((
Image *) NULL);
2051 if (IsGrayColorspace(image->colorspace) != MagickFalse)
2052 (void) SetImageColorspace(clone_image,sRGBColorspace);
2053 (void) SetImageVirtualPixelMethod(clone_image,EdgeVirtualPixelMethod);
2054 clone_image->compose=OverCompositeOp;
2055 border_info.width=(size_t) floor(2.0*sigma+0.5);
2056 border_info.height=(size_t) floor(2.0*sigma+0.5);
2059 (void) QueryColorDatabase(
"none",&clone_image->border_color,exception);
2060 border_image=BorderImage(clone_image,&border_info,exception);
2061 clone_image=DestroyImage(clone_image);
2062 if (border_image == (
Image *) NULL)
2063 return((
Image *) NULL);
2064 if (border_image->matte == MagickFalse)
2065 (void) SetImageAlphaChannel(border_image,OpaqueAlphaChannel);
2071 image_view=AcquireAuthenticCacheView(border_image,exception);
2072 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2073 #pragma omp parallel for schedule(static) shared(progress,status) \
2074 magick_number_threads(border_image,border_image,border_image->rows,1)
2076 for (y=0; y < (ssize_t) border_image->rows; y++)
2084 if (status == MagickFalse)
2086 q=GetCacheViewAuthenticPixels(image_view,0,y,border_image->columns,1,
2093 for (x=0; x < (ssize_t) border_image->columns; x++)
2095 SetPixelRed(q,border_image->background_color.red);
2096 SetPixelGreen(q,border_image->background_color.green);
2097 SetPixelBlue(q,border_image->background_color.blue);
2098 if (border_image->matte == MagickFalse)
2099 SetPixelOpacity(q,border_image->background_color.opacity);
2101 SetPixelOpacity(q,ClampToQuantum((
double) (QuantumRange-
2102 GetPixelAlpha(q)*opacity/100.0)));
2105 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2107 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2112 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2116 proceed=SetImageProgress(image,ShadowImageTag,progress,
2117 border_image->rows);
2118 if (proceed == MagickFalse)
2122 image_view=DestroyCacheView(image_view);
2123 shadow_image=BlurImageChannel(border_image,AlphaChannel,0.0,sigma,exception);
2124 border_image=DestroyImage(border_image);
2125 if (shadow_image == (
Image *) NULL)
2126 return((
Image *) NULL);
2127 if (shadow_image->page.width == 0)
2128 shadow_image->page.width=shadow_image->columns;
2129 if (shadow_image->page.height == 0)
2130 shadow_image->page.height=shadow_image->rows;
2131 shadow_image->page.width+=x_offset-(ssize_t) border_info.width;
2132 shadow_image->page.height+=y_offset-(ssize_t) border_info.height;
2133 shadow_image->page.x+=x_offset-(ssize_t) border_info.width;
2134 shadow_image->page.y+=y_offset-(ssize_t) border_info.height;
2135 return(shadow_image);
2174 MagickExport
Image *SketchImage(
const Image *image,
const double radius,
2175 const double sigma,
const double angle,
ExceptionInfo *exception)
2194 **magick_restrict random_info;
2199 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2207 random_image=CloneImage(image,image->columns << 1,image->rows << 1,
2208 MagickTrue,exception);
2209 if (random_image == (
Image *) NULL)
2210 return((
Image *) NULL);
2212 GetMagickPixelPacket(random_image,&zero);
2213 random_info=AcquireRandomInfoTLS();
2214 random_view=AcquireAuthenticCacheView(random_image,exception);
2215 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2216 key=GetRandomSecretKey(random_info[0]);
2217 #pragma omp parallel for schedule(static) shared(status) \
2218 magick_number_threads(random_image,random_image,random_image->rows,key == ~0UL)
2220 for (y=0; y < (ssize_t) random_image->rows; y++)
2223 id = GetOpenMPThreadId();
2229 *magick_restrict indexes;
2237 if (status == MagickFalse)
2239 q=QueueCacheViewAuthenticPixels(random_view,0,y,random_image->columns,1,
2246 indexes=GetCacheViewAuthenticIndexQueue(random_view);
2248 for (x=0; x < (ssize_t) random_image->columns; x++)
2250 pixel.red=(MagickRealType) (QuantumRange*
2251 GetPseudoRandomValue(random_info[
id]));
2252 pixel.green=pixel.red;
2253 pixel.blue=pixel.red;
2254 if (image->colorspace == CMYKColorspace)
2255 pixel.index=pixel.red;
2256 SetPixelPacket(random_image,&pixel,q,indexes+x);
2259 if (SyncCacheViewAuthenticPixels(random_view,exception) == MagickFalse)
2262 random_info=DestroyRandomInfoTLS(random_info);
2263 if (status == MagickFalse)
2265 random_view=DestroyCacheView(random_view);
2266 random_image=DestroyImage(random_image);
2267 return(random_image);
2269 random_view=DestroyCacheView(random_view);
2271 blur_image=MotionBlurImage(random_image,radius,sigma,angle,exception);
2272 random_image=DestroyImage(random_image);
2273 if (blur_image == (
Image *) NULL)
2274 return((
Image *) NULL);
2275 dodge_image=EdgeImage(blur_image,radius,exception);
2276 blur_image=DestroyImage(blur_image);
2277 if (dodge_image == (
Image *) NULL)
2278 return((
Image *) NULL);
2279 status=ClampImage(dodge_image);
2280 if (status != MagickFalse)
2281 status=NormalizeImage(dodge_image);
2282 if (status != MagickFalse)
2283 status=NegateImage(dodge_image,MagickFalse);
2284 if (status != MagickFalse)
2285 status=TransformImage(&dodge_image,(
char *) NULL,
"50%");
2286 sketch_image=CloneImage(image,0,0,MagickTrue,exception);
2287 if (sketch_image == (
Image *) NULL)
2289 dodge_image=DestroyImage(dodge_image);
2290 return((
Image *) NULL);
2292 (void) CompositeImage(sketch_image,ColorDodgeCompositeOp,dodge_image,0,0);
2293 dodge_image=DestroyImage(dodge_image);
2294 blend_image=CloneImage(image,0,0,MagickTrue,exception);
2295 if (blend_image == (
Image *) NULL)
2297 sketch_image=DestroyImage(sketch_image);
2298 return((
Image *) NULL);
2300 (void) SetImageArtifact(blend_image,
"compose:args",
"20x80");
2301 (void) CompositeImage(sketch_image,BlendCompositeOp,blend_image,0,0);
2302 blend_image=DestroyImage(blend_image);
2303 return(sketch_image);
2340 MagickExport MagickBooleanType SolarizeImage(
Image *image,
2341 const double threshold)
2346 status=SolarizeImageChannel(image,DefaultChannels,threshold,
2351 MagickExport MagickBooleanType SolarizeImageChannel(
Image *image,
2352 const ChannelType channel,
const double threshold,
ExceptionInfo *exception)
2354 #define SolarizeImageTag "Solarize/Image"
2368 assert(image != (
Image *) NULL);
2369 assert(image->signature == MagickCoreSignature);
2370 if (IsEventLogging() != MagickFalse)
2371 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2372 if (IsGrayColorspace(image->colorspace) != MagickFalse)
2373 (
void) SetImageColorspace(image,sRGBColorspace);
2374 if (image->storage_class == PseudoClass)
2382 for (i=0; i < (ssize_t) image->colors; i++)
2384 if ((channel & RedChannel) != 0)
2385 if ((
double) image->colormap[i].red > threshold)
2386 image->colormap[i].red=QuantumRange-image->colormap[i].red;
2387 if ((channel & GreenChannel) != 0)
2388 if ((
double) image->colormap[i].green > threshold)
2389 image->colormap[i].green=QuantumRange-image->colormap[i].green;
2390 if ((channel & BlueChannel) != 0)
2391 if ((
double) image->colormap[i].blue > threshold)
2392 image->colormap[i].blue=QuantumRange-image->colormap[i].blue;
2400 image_view=AcquireAuthenticCacheView(image,exception);
2401 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2402 #pragma omp parallel for schedule(static) shared(progress,status) \
2403 magick_number_threads(image,image,image->rows,1)
2405 for (y=0; y < (ssize_t) image->rows; y++)
2413 if (status == MagickFalse)
2415 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2422 for (x=0; x < (ssize_t) image->columns; x++)
2424 if ((channel & RedChannel) != 0)
2425 if ((
double) GetPixelRed(q) > threshold)
2426 SetPixelRed(q,QuantumRange-GetPixelRed(q));
2427 if ((channel & GreenChannel) != 0)
2428 if ((
double) GetPixelGreen(q) > threshold)
2429 SetPixelGreen(q,QuantumRange-GetPixelGreen(q));
2430 if ((channel & BlueChannel) != 0)
2431 if ((
double) GetPixelBlue(q) > threshold)
2432 SetPixelBlue(q,QuantumRange-GetPixelBlue(q));
2435 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2437 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2442 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2446 proceed=SetImageProgress(image,SolarizeImageTag,progress,image->rows);
2447 if (proceed == MagickFalse)
2451 image_view=DestroyCacheView(image_view);
2484 MagickExport
Image *SteganoImage(
const Image *image,
const Image *watermark,
2487 #define GetBit(alpha,i) ((((size_t) (alpha) >> (size_t) (i)) & 0x01) != 0)
2488 #define SetBit(alpha,i,set) (alpha)=(Quantum) ((set) != 0 ? (size_t) (alpha) \
2489 | (one << (size_t) (i)) : (size_t) (alpha) & ~(one << (size_t) (i)))
2490 #define SteganoImageTag "Stegano/Image"
2527 assert(image != (
const Image *) NULL);
2528 assert(image->signature == MagickCoreSignature);
2529 assert(watermark != (
const Image *) NULL);
2530 assert(watermark->signature == MagickCoreSignature);
2532 assert(exception->signature == MagickCoreSignature);
2533 if (IsEventLogging() != MagickFalse)
2534 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2536 stegano_image=CloneImage(image,0,0,MagickTrue,exception);
2537 if (stegano_image == (
Image *) NULL)
2538 return((
Image *) NULL);
2539 if (SetImageStorageClass(stegano_image,DirectClass) == MagickFalse)
2541 InheritException(exception,&stegano_image->exception);
2542 stegano_image=DestroyImage(stegano_image);
2543 return((
Image *) NULL);
2545 stegano_image->depth=MAGICKCORE_QUANTUM_DEPTH;
2552 depth=stegano_image->depth;
2555 watermark_view=AcquireVirtualCacheView(watermark,exception);
2556 stegano_view=AcquireAuthenticCacheView(stegano_image,exception);
2557 for (i=(ssize_t) depth-1; (i >= 0) && (j < (ssize_t) depth); i--)
2559 for (y=0; (y < (ssize_t) watermark->rows) && (j < (ssize_t) depth); y++)
2561 for (x=0; (x < (ssize_t) watermark->columns) && (j < (ssize_t) depth); x++)
2563 (void) GetOneCacheViewVirtualPixel(watermark_view,x,y,&pixel,exception);
2564 if ((k/(ssize_t) stegano_image->columns) >= (ssize_t) stegano_image->rows)
2566 q=GetCacheViewAuthenticPixels(stegano_view,k % (ssize_t)
2567 stegano_image->columns,k/(ssize_t) stegano_image->columns,1,1,
2575 SetBit(GetPixelRed(q),j,GetBit(ClampToQuantum(GetPixelIntensity(
2581 SetBit(GetPixelGreen(q),j,GetBit(ClampToQuantum(GetPixelIntensity(
2587 SetBit(GetPixelBlue(q),j,GetBit(ClampToQuantum(GetPixelIntensity(
2592 if (SyncCacheViewAuthenticPixels(stegano_view,exception) == MagickFalse)
2598 if (k == (ssize_t) (stegano_image->columns*stegano_image->columns))
2600 if (k == image->offset)
2604 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2609 proceed=SetImageProgress(image,SteganoImageTag,(MagickOffsetType)
2611 if (proceed == MagickFalse)
2615 stegano_view=DestroyCacheView(stegano_view);
2616 watermark_view=DestroyCacheView(watermark_view);
2617 if (stegano_image->storage_class == PseudoClass)
2618 (void) SyncImage(stegano_image);
2619 if (status == MagickFalse)
2620 stegano_image=DestroyImage(stegano_image);
2621 return(stegano_image);
2663 MagickExport
Image *StereoImage(
const Image *left_image,
2666 return(StereoAnaglyphImage(left_image,right_image,0,0,exception));
2669 MagickExport
Image *StereoAnaglyphImage(
const Image *left_image,
2670 const Image *right_image,
const ssize_t x_offset,
const ssize_t y_offset,
2673 #define StereoImageTag "Stereo/Image"
2687 assert(left_image != (
const Image *) NULL);
2688 assert(left_image->signature == MagickCoreSignature);
2689 assert(right_image != (
const Image *) NULL);
2690 assert(right_image->signature == MagickCoreSignature);
2692 assert(exception->signature == MagickCoreSignature);
2693 if (IsEventLogging() != MagickFalse)
2694 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
2695 left_image->filename);
2697 if ((left_image->columns != right_image->columns) ||
2698 (left_image->rows != right_image->rows))
2699 ThrowImageException(ImageError,
"LeftAndRightImageSizesDiffer");
2703 stereo_image=CloneImage(left_image,left_image->columns,left_image->rows,
2704 MagickTrue,exception);
2705 if (stereo_image == (
Image *) NULL)
2706 return((
Image *) NULL);
2707 if (SetImageStorageClass(stereo_image,DirectClass) == MagickFalse)
2709 InheritException(exception,&stereo_image->exception);
2710 stereo_image=DestroyImage(stereo_image);
2711 return((
Image *) NULL);
2713 (void) SetImageColorspace(stereo_image,sRGBColorspace);
2718 for (y=0; y < (ssize_t) stereo_image->rows; y++)
2730 p=GetVirtualPixels(left_image,-x_offset,y-y_offset,image->columns,1,
2732 q=GetVirtualPixels(right_image,0,y,right_image->columns,1,exception);
2733 r=QueueAuthenticPixels(stereo_image,0,y,stereo_image->columns,1,exception);
2737 for (x=0; x < (ssize_t) stereo_image->columns; x++)
2739 SetPixelRed(r,GetPixelRed(p));
2740 SetPixelGreen(r,GetPixelGreen(q));
2741 SetPixelBlue(r,GetPixelBlue(q));
2742 SetPixelOpacity(r,(GetPixelOpacity(p)+q->opacity)/2);
2747 if (SyncAuthenticPixels(stereo_image,exception) == MagickFalse)
2749 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2754 proceed=SetImageProgress(image,StereoImageTag,(MagickOffsetType) y,
2755 stereo_image->rows);
2756 if (proceed == MagickFalse)
2760 if (status == MagickFalse)
2761 stereo_image=DestroyImage(stereo_image);
2762 return(stereo_image);
2794 MagickExport
Image *SwirlImage(
const Image *image,
double degrees,
2797 #define SwirlImageTag "Swirl/Image"
2828 assert(image != (
const Image *) NULL);
2829 assert(image->signature == MagickCoreSignature);
2831 assert(exception->signature == MagickCoreSignature);
2832 if (IsEventLogging() != MagickFalse)
2833 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2834 swirl_image=CloneImage(image,0,0,MagickTrue,exception);
2835 if (swirl_image == (
Image *) NULL)
2836 return((
Image *) NULL);
2837 if (SetImageStorageClass(swirl_image,DirectClass) == MagickFalse)
2839 InheritException(exception,&swirl_image->exception);
2840 swirl_image=DestroyImage(swirl_image);
2841 return((
Image *) NULL);
2843 if (swirl_image->background_color.opacity != OpaqueOpacity)
2844 swirl_image->matte=MagickTrue;
2848 center.x=(double) image->columns/2.0;
2849 center.y=(
double) image->rows/2.0;
2850 radius=MagickMax(center.x,center.y);
2853 if (image->columns > image->rows)
2854 scale.y=(double) image->columns/(
double) image->rows;
2856 if (image->columns < image->rows)
2857 scale.x=(double) image->rows/(
double) image->columns;
2858 degrees=(double) DegreesToRadians(degrees);
2864 GetMagickPixelPacket(swirl_image,&zero);
2865 image_view=AcquireVirtualCacheView(image,exception);
2866 swirl_view=AcquireAuthenticCacheView(swirl_image,exception);
2867 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2868 #pragma omp parallel for schedule(static) shared(progress,status) \
2869 magick_number_threads(image,swirl_image,image->rows,1)
2871 for (y=0; y < (ssize_t) image->rows; y++)
2883 *magick_restrict swirl_indexes;
2891 if (status == MagickFalse)
2893 q=GetCacheViewAuthenticPixels(swirl_view,0,y,swirl_image->columns,1,
2900 swirl_indexes=GetCacheViewAuthenticIndexQueue(swirl_view);
2901 delta.y=scale.y*(double) (y-center.y);
2903 for (x=0; x < (ssize_t) image->columns; x++)
2908 delta.x=scale.x*(double) (x-center.x);
2909 distance=delta.x*delta.x+delta.y*delta.y;
2910 if (distance < (radius*radius))
2920 factor=1.0-sqrt(distance)/radius;
2921 sine=sin((
double) (degrees*factor*factor));
2922 cosine=cos((
double) (degrees*factor*factor));
2923 status=InterpolateMagickPixelPacket(image,image_view,
2924 UndefinedInterpolatePixel,(
double) ((cosine*delta.x-sine*delta.y)/
2925 scale.x+center.x),(
double) ((sine*delta.x+cosine*delta.y)/scale.y+
2926 center.y),&pixel,exception);
2927 if (status == MagickFalse)
2929 SetPixelPacket(swirl_image,&pixel,q,swirl_indexes+x);
2933 if (SyncCacheViewAuthenticPixels(swirl_view,exception) == MagickFalse)
2935 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2940 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2944 proceed=SetImageProgress(image,SwirlImageTag,progress,image->rows);
2945 if (proceed == MagickFalse)
2949 swirl_view=DestroyCacheView(swirl_view);
2950 image_view=DestroyCacheView(image_view);
2951 if (status == MagickFalse)
2952 swirl_image=DestroyImage(swirl_image);
2953 return(swirl_image);
2987 MagickExport
Image *TintImage(
const Image *image,
const char *opacity,
2990 #define TintImageTag "Tint/Image"
3021 assert(image != (
const Image *) NULL);
3022 assert(image->signature == MagickCoreSignature);
3024 assert(exception->signature == MagickCoreSignature);
3025 if (IsEventLogging() != MagickFalse)
3026 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
3027 tint_image=CloneImage(image,0,0,MagickTrue,exception);
3028 if (tint_image == (
Image *) NULL)
3029 return((
Image *) NULL);
3030 if (SetImageStorageClass(tint_image,DirectClass) == MagickFalse)
3032 InheritException(exception,&tint_image->exception);
3033 tint_image=DestroyImage(tint_image);
3034 return((
Image *) NULL);
3036 if ((IsGrayColorspace(image->colorspace) != MagickFalse) &&
3037 (IsPixelGray(&tint) == MagickFalse))
3038 (void) SetImageColorspace(tint_image,sRGBColorspace);
3039 if (opacity == (
const char *) NULL)
3044 flags=ParseGeometry(opacity,&geometry_info);
3045 pixel.red=geometry_info.rho;
3046 pixel.green=geometry_info.rho;
3047 pixel.blue=geometry_info.rho;
3048 pixel.opacity=(MagickRealType) OpaqueOpacity;
3049 if ((flags & SigmaValue) != 0)
3050 pixel.green=geometry_info.sigma;
3051 if ((flags & XiValue) != 0)
3052 pixel.blue=geometry_info.xi;
3053 if ((flags & PsiValue) != 0)
3054 pixel.opacity=geometry_info.psi;
3055 color_vector.red=(MagickRealType) (pixel.red*tint.red/100.0-
3056 PixelPacketIntensity(&tint));
3057 color_vector.green=(MagickRealType) (pixel.green*tint.green/100.0-
3058 PixelPacketIntensity(&tint));
3059 color_vector.blue=(MagickRealType) (pixel.blue*tint.blue/100.0-
3060 PixelPacketIntensity(&tint));
3066 image_view=AcquireVirtualCacheView(image,exception);
3067 tint_view=AcquireAuthenticCacheView(tint_image,exception);
3068 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3069 #pragma omp parallel for schedule(static) shared(progress,status) \
3070 magick_number_threads(image,tint_image,image->rows,1)
3072 for (y=0; y < (ssize_t) image->rows; y++)
3083 if (status == MagickFalse)
3085 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
3086 q=QueueCacheViewAuthenticPixels(tint_view,0,y,tint_image->columns,1,
3093 for (x=0; x < (ssize_t) image->columns; x++)
3101 weight=QuantumScale*GetPixelRed(p)-0.5;
3102 pixel.red=(MagickRealType) GetPixelRed(p)+color_vector.red*(1.0-(4.0*
3104 SetPixelRed(q,ClampToQuantum(pixel.red));
3105 weight=QuantumScale*GetPixelGreen(p)-0.5;
3106 pixel.green=(MagickRealType) GetPixelGreen(p)+color_vector.green*(1.0-
3107 (4.0*(weight*weight)));
3108 SetPixelGreen(q,ClampToQuantum(pixel.green));
3109 weight=QuantumScale*GetPixelBlue(p)-0.5;
3110 pixel.blue=(MagickRealType) GetPixelBlue(p)+color_vector.blue*(1.0-(4.0*
3112 SetPixelBlue(q,ClampToQuantum(pixel.blue));
3113 SetPixelOpacity(q,GetPixelOpacity(p));
3117 if (SyncCacheViewAuthenticPixels(tint_view,exception) == MagickFalse)
3119 if (image->progress_monitor != (MagickProgressMonitor) NULL)
3124 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3128 proceed=SetImageProgress(image,TintImageTag,progress,image->rows);
3129 if (proceed == MagickFalse)
3133 tint_view=DestroyCacheView(tint_view);
3134 image_view=DestroyCacheView(image_view);
3135 if (status == MagickFalse)
3136 tint_image=DestroyImage(tint_image);
3172 MagickExport
Image *VignetteImage(
const Image *image,
const double radius,
3173 const double sigma,
const ssize_t x,
const ssize_t y,
ExceptionInfo *exception)
3176 ellipse[MaxTextExtent];
3187 assert(image != (
Image *) NULL);
3188 assert(image->signature == MagickCoreSignature);
3190 assert(exception->signature == MagickCoreSignature);
3191 if (IsEventLogging() != MagickFalse)
3192 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
3193 canvas_image=CloneImage(image,0,0,MagickTrue,exception);
3194 if (canvas_image == (
Image *) NULL)
3195 return((
Image *) NULL);
3196 if (SetImageStorageClass(canvas_image,DirectClass) == MagickFalse)
3198 InheritException(exception,&canvas_image->exception);
3199 canvas_image=DestroyImage(canvas_image);
3200 return((
Image *) NULL);
3202 canvas_image->matte=MagickTrue;
3203 oval_image=CloneImage(canvas_image,canvas_image->columns,canvas_image->rows,
3204 MagickTrue,exception);
3205 if (oval_image == (
Image *) NULL)
3207 canvas_image=DestroyImage(canvas_image);
3208 return((
Image *) NULL);
3210 (void) QueryColorDatabase(
"#000000",&oval_image->background_color,exception);
3211 (void) SetImageBackgroundColor(oval_image);
3213 (void) QueryColorDatabase(
"#ffffff",&draw_info->fill,exception);
3214 (void) QueryColorDatabase(
"#ffffff",&draw_info->stroke,exception);
3215 (void) FormatLocaleString(ellipse,MaxTextExtent,
3216 "ellipse %g,%g,%g,%g,0.0,360.0",image->columns/2.0,
3217 image->rows/2.0,image->columns/2.0-x,image->rows/2.0-y);
3218 draw_info->primitive=AcquireString(ellipse);
3219 (void) DrawImage(oval_image,draw_info);
3220 draw_info=DestroyDrawInfo(draw_info);
3221 blur_image=BlurImage(oval_image,radius,sigma,exception);
3222 oval_image=DestroyImage(oval_image);
3223 if (blur_image == (
Image *) NULL)
3225 canvas_image=DestroyImage(canvas_image);
3226 return((
Image *) NULL);
3228 blur_image->matte=MagickFalse;
3229 (void) CompositeImage(canvas_image,CopyOpacityCompositeOp,blur_image,0,0);
3230 blur_image=DestroyImage(blur_image);
3231 vignette_image=MergeImageLayers(canvas_image,FlattenLayer,exception);
3232 canvas_image=DestroyImage(canvas_image);
3233 if (vignette_image != (
Image *) NULL)
3234 (void) TransformImageColorspace(vignette_image,image->colorspace);
3235 return(vignette_image);
3268 MagickExport
Image *WaveImage(
const Image *image,
const double amplitude,
3271 #define WaveImageTag "Wave/Image"
3301 assert(image != (
Image *) NULL);
3302 assert(image->signature == MagickCoreSignature);
3304 assert(exception->signature == MagickCoreSignature);
3305 if (IsEventLogging() != MagickFalse)
3306 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
3307 wave_image=CloneImage(image,image->columns,(
size_t) (image->rows+2.0*
3308 fabs(amplitude)),MagickTrue,exception);
3309 if (wave_image == (
Image *) NULL)
3310 return((
Image *) NULL);
3311 if (SetImageStorageClass(wave_image,DirectClass) == MagickFalse)
3313 InheritException(exception,&wave_image->exception);
3314 wave_image=DestroyImage(wave_image);
3315 return((
Image *) NULL);
3317 if (wave_image->background_color.opacity != OpaqueOpacity)
3318 wave_image->matte=MagickTrue;
3322 sine_map=(
float *) AcquireQuantumMemory((
size_t) wave_image->columns,
3324 if (sine_map == (
float *) NULL)
3326 wave_image=DestroyImage(wave_image);
3327 ThrowImageException(ResourceLimitError,
"MemoryAllocationFailed");
3329 for (i=0; i < (ssize_t) wave_image->columns; i++)
3330 sine_map[i]=(float) fabs(amplitude)+amplitude*sin((
double)
3331 ((2.0*MagickPI*i)*PerceptibleReciprocal(wave_length)));
3337 GetMagickPixelPacket(wave_image,&zero);
3338 image_view=AcquireVirtualCacheView(image,exception);
3339 wave_view=AcquireAuthenticCacheView(wave_image,exception);
3340 (void) SetCacheViewVirtualPixelMethod(image_view,
3341 BackgroundVirtualPixelMethod);
3342 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3343 #pragma omp parallel for schedule(static) shared(progress,status) \
3344 magick_number_threads(image,wave_image,wave_image->rows,1)
3346 for (y=0; y < (ssize_t) wave_image->rows; y++)
3352 *magick_restrict indexes;
3360 if (status == MagickFalse)
3362 q=QueueCacheViewAuthenticPixels(wave_view,0,y,wave_image->columns,1,
3369 indexes=GetCacheViewAuthenticIndexQueue(wave_view);
3371 for (x=0; x < (ssize_t) wave_image->columns; x++)
3373 status=InterpolateMagickPixelPacket(image,image_view,
3374 UndefinedInterpolatePixel,(
double) x,(
double) (y-sine_map[x]),&pixel,
3376 if (status == MagickFalse)
3378 SetPixelPacket(wave_image,&pixel,q,indexes+x);
3381 if (SyncCacheViewAuthenticPixels(wave_view,exception) == MagickFalse)
3383 if (image->progress_monitor != (MagickProgressMonitor) NULL)
3388 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3392 proceed=SetImageProgress(image,WaveImageTag,progress,image->rows);
3393 if (proceed == MagickFalse)
3397 wave_view=DestroyCacheView(wave_view);
3398 image_view=DestroyCacheView(image_view);
3399 sine_map=(
float *) RelinquishMagickMemory(sine_map);
3400 if (status == MagickFalse)
3401 wave_image=DestroyImage(wave_image);
3440 static inline void HatTransform(
const float *magick_restrict pixels,
3441 const size_t stride,
const size_t extent,
const size_t scale,
float *kernel)
3452 q=pixels+scale*stride,
3453 r=pixels+scale*stride;
3454 for (i=0; i < (ssize_t) scale; i++)
3456 kernel[i]=0.25f*(*p+(*p)+(*q)+(*r));
3461 for ( ; i < (ssize_t) (extent-scale); i++)
3463 kernel[i]=0.25f*(2.0f*(*p)+*(p-scale*stride)+*(p+scale*stride));
3467 r=pixels+stride*(extent-2);
3468 for ( ; i < (ssize_t) extent; i++)
3470 kernel[i]=0.25f*(*p+(*p)+(*q)+(*r));
3477 MagickExport
Image *WaveletDenoiseImage(
const Image *image,
3478 const double threshold,
const double softness,
ExceptionInfo *exception)
3508 0.8002, 0.2735, 0.1202, 0.0585, 0.0291, 0.0152, 0.0080, 0.0044 };
3513 assert(image != (
const Image *) NULL);
3514 assert(image->signature == MagickCoreSignature);
3516 assert(exception->signature == MagickCoreSignature);
3517 if (IsEventLogging() != MagickFalse)
3518 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
3519 noise_image=(
Image *) NULL;
3520 #if defined(MAGICKCORE_OPENCL_SUPPORT)
3521 noise_image=AccelerateWaveletDenoiseImage(image,threshold,exception);
3522 if (noise_image != (
Image *) NULL)
3523 return(noise_image);
3525 noise_image=CloneImage(image,0,0,MagickTrue,exception);
3526 if (noise_image == (
Image *) NULL)
3527 return((
Image *) NULL);
3528 if (SetImageStorageClass(noise_image,DirectClass) == MagickFalse)
3530 noise_image=DestroyImage(noise_image);
3531 return((
Image *) NULL);
3533 if (AcquireMagickResource(WidthResource,3*image->columns) == MagickFalse)
3534 ThrowImageException(ResourceLimitError,
"MemoryAllocationFailed");
3535 pixels_info=AcquireVirtualMemory(3*image->columns,image->rows*
3537 kernel=(
float *) AcquireQuantumMemory(MagickMax(image->rows,image->columns)+1,
3538 GetOpenMPMaximumThreads()*
sizeof(*kernel));
3539 if ((pixels_info == (
MemoryInfo *) NULL) || (kernel == (
float *) NULL))
3541 if (kernel != (
float *) NULL)
3542 kernel=(
float *) RelinquishMagickMemory(kernel);
3544 pixels_info=RelinquishVirtualMemory(pixels_info);
3545 ThrowImageException(ResourceLimitError,
"MemoryAllocationFailed");
3547 pixels=(
float *) GetVirtualMemoryBlob(pixels_info);
3549 number_pixels=image->columns*image->rows;
3550 max_channels=(size_t) (image->colorspace == CMYKColorspace ? 4 : 3);
3551 image_view=AcquireAuthenticCacheView(image,exception);
3552 noise_view=AcquireAuthenticCacheView(noise_image,exception);
3553 for (channel=0; channel < (ssize_t) max_channels; channel++)
3566 if (status == MagickFalse)
3572 for (y=0; y < (ssize_t) image->rows; y++)
3575 *magick_restrict indexes;
3583 p=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3589 indexes=GetCacheViewVirtualIndexQueue(image_view);
3590 for (x=0; x < (ssize_t) image->columns; x++)
3594 case 0: pixels[i]=(float) GetPixelRed(p);
break;
3595 case 1: pixels[i]=(float) GetPixelGreen(p);
break;
3596 case 2: pixels[i]=(float) GetPixelBlue(p);
break;
3597 case 3: pixels[i]=(float) indexes[x];
break;
3610 for (level=0; level < 5; level++)
3619 low_pass=(size_t) (number_pixels*((level & 0x01)+1));
3620 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3621 #pragma omp parallel for schedule(static,1) \
3622 magick_number_threads(image,image,image->rows,1)
3624 for (y=0; y < (ssize_t) image->rows; y++)
3627 id = GetOpenMPThreadId();
3636 p=kernel+
id*image->columns;
3637 q=pixels+y*image->columns;
3638 HatTransform(q+high_pass,1,image->columns,(
size_t) (1UL << level),p);
3640 for (x=0; x < (ssize_t) image->columns; x++)
3643 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3644 #pragma omp parallel for schedule(static,1) \
3645 magick_number_threads(image,image,image->columns,1)
3647 for (x=0; x < (ssize_t) image->columns; x++)
3650 id = GetOpenMPThreadId();
3659 p=kernel+
id*image->rows;
3660 q=pixels+x+low_pass;
3661 HatTransform(q,image->columns,image->rows,(
size_t) (1UL << level),p);
3662 for (y=0; y < (ssize_t) image->rows; y++)
3672 magnitude=threshold*noise_levels[level];
3673 for (i=0; i < (ssize_t) number_pixels; ++i)
3675 pixels[high_pass+i]-=pixels[low_pass+i];
3676 if (pixels[high_pass+i] < -magnitude)
3677 pixels[high_pass+i]+=magnitude-softness*magnitude;
3679 if (pixels[high_pass+i] > magnitude)
3680 pixels[high_pass+i]-=magnitude-softness*magnitude;
3682 pixels[high_pass+i]*=softness;
3684 pixels[i]+=pixels[high_pass+i];
3692 for (y=0; y < (ssize_t) image->rows; y++)
3698 *magick_restrict noise_indexes;
3706 q=GetCacheViewAuthenticPixels(noise_view,0,y,noise_image->columns,1,
3713 noise_indexes=GetCacheViewAuthenticIndexQueue(noise_view);
3714 for (x=0; x < (ssize_t) image->columns; x++)
3719 pixel=pixels[i]+pixels[low_pass+i];
3722 case 0: SetPixelRed(q,ClampToQuantum(pixel));
break;
3723 case 1: SetPixelGreen(q,ClampToQuantum(pixel));
break;
3724 case 2: SetPixelBlue(q,ClampToQuantum(pixel));
break;
3725 case 3: SetPixelIndex(noise_indexes+x,ClampToQuantum(pixel));
break;
3731 sync=SyncCacheViewAuthenticPixels(noise_view,exception);
3732 if (sync == MagickFalse)
3735 if (image->progress_monitor != (MagickProgressMonitor) NULL)
3740 proceed=SetImageProgress(image,AddNoiseImageTag,(MagickOffsetType)
3741 channel,max_channels);
3742 if (proceed == MagickFalse)
3746 noise_view=DestroyCacheView(noise_view);
3747 image_view=DestroyCacheView(image_view);
3748 kernel=(
float *) RelinquishMagickMemory(kernel);
3749 pixels_info=RelinquishVirtualMemory(pixels_info);
3750 return(noise_image);