2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6 % EEEEE FFFFF FFFFF EEEEE CCCC TTTTT %
8 % EEE FFF FFF EEE C T %
10 % EEEEE F F EEEEE CCCC T %
13 % MagickCore Image Effects Methods %
20 % Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization %
21 % dedicated to making software imaging solutions freely available. %
23 % You may not use this file except in compliance with the License. You may %
24 % obtain a copy of the License at %
26 % http://www.imagemagick.org/script/license.php %
28 % Unless required by applicable law or agreed to in writing, software %
29 % distributed under the License is distributed on an "AS IS" BASIS, %
30 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
31 % See the License for the specific language governing permissions and %
32 % limitations under the License. %
34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
43 #include "MagickCore/studio.h"
44 #include "MagickCore/accelerate.h"
45 #include "MagickCore/blob.h"
46 #include "MagickCore/cache-view.h"
47 #include "MagickCore/color.h"
48 #include "MagickCore/color-private.h"
49 #include "MagickCore/colorspace.h"
50 #include "MagickCore/constitute.h"
51 #include "MagickCore/decorate.h"
52 #include "MagickCore/distort.h"
53 #include "MagickCore/draw.h"
54 #include "MagickCore/enhance.h"
55 #include "MagickCore/exception.h"
56 #include "MagickCore/exception-private.h"
57 #include "MagickCore/effect.h"
58 #include "MagickCore/fx.h"
59 #include "MagickCore/gem.h"
60 #include "MagickCore/gem-private.h"
61 #include "MagickCore/geometry.h"
62 #include "MagickCore/image-private.h"
63 #include "MagickCore/list.h"
64 #include "MagickCore/log.h"
65 #include "MagickCore/memory_.h"
66 #include "MagickCore/memory-private.h"
67 #include "MagickCore/monitor.h"
68 #include "MagickCore/monitor-private.h"
69 #include "MagickCore/montage.h"
70 #include "MagickCore/morphology.h"
71 #include "MagickCore/paint.h"
72 #include "MagickCore/pixel-accessor.h"
73 #include "MagickCore/pixel-private.h"
74 #include "MagickCore/property.h"
75 #include "MagickCore/quantize.h"
76 #include "MagickCore/quantum.h"
77 #include "MagickCore/quantum-private.h"
78 #include "MagickCore/random_.h"
79 #include "MagickCore/random-private.h"
80 #include "MagickCore/resample.h"
81 #include "MagickCore/resample-private.h"
82 #include "MagickCore/resize.h"
83 #include "MagickCore/resource_.h"
84 #include "MagickCore/segment.h"
85 #include "MagickCore/shear.h"
86 #include "MagickCore/signature-private.h"
87 #include "MagickCore/statistic.h"
88 #include "MagickCore/string_.h"
89 #include "MagickCore/thread-private.h"
90 #include "MagickCore/transform.h"
91 #include "MagickCore/threshold.h"
94 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
98 % A d a p t i v e B l u r I m a g e %
102 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
104 % AdaptiveBlurImage() adaptively blurs the image by blurring less
105 % intensely near image edges and more intensely far from edges. We blur the
106 % image with a Gaussian operator of the given radius and standard deviation
107 % (sigma). For reasonable results, radius should be larger than sigma. Use a
108 % radius of 0 and AdaptiveBlurImage() selects a suitable radius for you.
110 % The format of the AdaptiveBlurImage method is:
112 % Image *AdaptiveBlurImage(const Image *image,const double radius,
113 % const double sigma,ExceptionInfo *exception)
115 % A description of each parameter follows:
117 % o image: the image.
119 % o radius: the radius of the Gaussian, in pixels, not counting the center
122 % o sigma: the standard deviation of the Laplacian, in pixels.
124 % o exception: return any errors or warnings in this structure.
128 MagickExport MagickBooleanType AdaptiveLevelImage(Image *image,
129 const char *levels,ExceptionInfo *exception)
148 if (levels == (char *) NULL)
150 flags=ParseGeometry(levels,&geometry_info);
151 black_point=geometry_info.rho;
152 white_point=(double) QuantumRange;
153 if ((flags & SigmaValue) != 0)
154 white_point=geometry_info.sigma;
156 if ((flags & XiValue) != 0)
157 gamma=geometry_info.xi;
158 if ((flags & PercentValue) != 0)
160 black_point*=(double) image->columns*image->rows/100.0;
161 white_point*=(double) image->columns*image->rows/100.0;
163 if ((flags & SigmaValue) == 0)
164 white_point=(double) QuantumRange-black_point;
165 if ((flags & AspectValue ) == 0)
166 status=LevelImage(image,black_point,white_point,gamma,exception);
168 status=LevelizeImage(image,black_point,white_point,gamma,exception);
172 MagickExport Image *AdaptiveBlurImage(const Image *image,const double radius,
173 const double sigma,ExceptionInfo *exception)
175 #define AdaptiveBlurImageTag "Convolve/Image"
176 #define MagickSigma (fabs(sigma) < MagickEpsilon ? MagickEpsilon : sigma)
213 assert(image != (const Image *) NULL);
214 assert(image->signature == MagickSignature);
215 if (image->debug != MagickFalse)
216 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
217 assert(exception != (ExceptionInfo *) NULL);
218 assert(exception->signature == MagickSignature);
219 blur_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception);
220 if (blur_image == (Image *) NULL)
221 return((Image *) NULL);
222 if (fabs(sigma) < MagickEpsilon)
224 if (SetImageStorageClass(blur_image,DirectClass,exception) == MagickFalse)
226 blur_image=DestroyImage(blur_image);
227 return((Image *) NULL);
230 Edge detect the image brighness channel, level, blur, and level again.
232 edge_image=EdgeImage(image,radius,sigma,exception);
233 if (edge_image == (Image *) NULL)
235 blur_image=DestroyImage(blur_image);
236 return((Image *) NULL);
238 (void) AdaptiveLevelImage(edge_image,"20%,95%",exception);
239 gaussian_image=GaussianBlurImage(edge_image,radius,sigma,exception);
240 if (gaussian_image != (Image *) NULL)
242 edge_image=DestroyImage(edge_image);
243 edge_image=gaussian_image;
245 (void) AdaptiveLevelImage(edge_image,"10%,95%",exception);
247 Create a set of kernels from maximum (radius,sigma) to minimum.
249 width=GetOptimalKernelWidth2D(radius,sigma);
250 kernel=(MagickRealType **) MagickAssumeAligned(AcquireAlignedMemory((size_t)
251 width,sizeof(*kernel)));
252 if (kernel == (MagickRealType **) NULL)
254 edge_image=DestroyImage(edge_image);
255 blur_image=DestroyImage(blur_image);
256 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
258 (void) ResetMagickMemory(kernel,0,(size_t) width*sizeof(*kernel));
259 for (i=0; i < (ssize_t) width; i+=2)
261 kernel[i]=(MagickRealType *) MagickAssumeAligned(AcquireAlignedMemory(
262 (size_t) (width-i),(width-i)*sizeof(**kernel)));
263 if (kernel[i] == (MagickRealType *) NULL)
266 j=(ssize_t) (width-i)/2;
268 for (v=(-j); v <= j; v++)
270 for (u=(-j); u <= j; u++)
272 kernel[i][k]=(MagickRealType) (exp(-((double) u*u+v*v)/(2.0*MagickSigma*
273 MagickSigma))/(2.0*MagickPI*MagickSigma*MagickSigma));
274 normalize+=kernel[i][k];
278 if (fabs(normalize) < MagickEpsilon)
279 normalize=MagickEpsilon;
280 normalize=PerceptibleReciprocal(normalize);
281 for (k=0; k < (j*j); k++)
282 kernel[i][k]=normalize*kernel[i][k];
284 if (i < (ssize_t) width)
286 for (i-=2; i >= 0; i-=2)
287 kernel[i]=(MagickRealType *) RelinquishAlignedMemory(kernel[i]);
288 kernel=(MagickRealType **) RelinquishAlignedMemory(kernel);
289 edge_image=DestroyImage(edge_image);
290 blur_image=DestroyImage(blur_image);
291 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
294 Adaptively blur image.
298 image_view=AcquireVirtualCacheView(image,exception);
299 edge_view=AcquireVirtualCacheView(edge_image,exception);
300 blur_view=AcquireAuthenticCacheView(blur_image,exception);
301 #if defined(MAGICKCORE_OPENMP_SUPPORT)
302 #pragma omp parallel for schedule(static,4) shared(progress,status) \
303 magick_threads(image,blur_image,blur_image->rows,1)
305 for (y=0; y < (ssize_t) blur_image->rows; y++)
307 register const Quantum
316 if (status == MagickFalse)
318 r=GetCacheViewVirtualPixels(edge_view,0,y,edge_image->columns,1,exception);
319 q=QueueCacheViewAuthenticPixels(blur_view,0,y,blur_image->columns,1,
321 if ((r == (const Quantum *) NULL) || (q == (Quantum *) NULL))
326 for (x=0; x < (ssize_t) blur_image->columns; x++)
328 register const Quantum
338 j=(ssize_t) ceil((double) width*QuantumScale*
339 GetPixelIntensity(edge_image,r)-0.5);
343 if (j > (ssize_t) width)
347 p=GetCacheViewVirtualPixels(image_view,x-((ssize_t) (width-j)/2L),y-
348 (ssize_t) ((width-j)/2L),width-j,width-j,exception);
349 if (p == (const Quantum *) NULL)
351 center=(ssize_t) GetPixelChannels(image)*(width-j)*((width-j)/2L)+
352 GetPixelChannels(image)*((width-j)/2L);
353 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
367 register const MagickRealType
370 register const Quantum
379 channel=GetPixelChannelChannel(image,i);
380 traits=GetPixelChannelTraits(image,channel);
381 blur_traits=GetPixelChannelTraits(blur_image,channel);
382 if ((traits == UndefinedPixelTrait) ||
383 (blur_traits == UndefinedPixelTrait))
385 if (((blur_traits & CopyPixelTrait) != 0) ||
386 (GetPixelMask(image,p+center) == 0))
388 SetPixelChannel(blur_image,channel,p[center+i],q);
395 if ((blur_traits & BlendPixelTrait) == 0)
400 for (v=0; v < (ssize_t) (width-j); v++)
402 for (u=0; u < (ssize_t) (width-j); u++)
404 pixel+=(*k)*pixels[i];
407 pixels+=GetPixelChannels(image);
410 gamma=PerceptibleReciprocal(gamma);
411 SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
417 for (v=0; v < (ssize_t) (width-j); v++)
419 for (u=0; u < (ssize_t) (width-j); u++)
421 alpha=(double) (QuantumScale*GetPixelAlpha(image,pixels));
422 pixel+=(*k)*alpha*pixels[i];
425 pixels+=GetPixelChannels(image);
428 gamma=PerceptibleReciprocal(gamma);
429 SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
431 q+=GetPixelChannels(blur_image);
432 r+=GetPixelChannels(edge_image);
434 if (SyncCacheViewAuthenticPixels(blur_view,exception) == MagickFalse)
436 if (image->progress_monitor != (MagickProgressMonitor) NULL)
441 #if defined(MAGICKCORE_OPENMP_SUPPORT)
442 #pragma omp critical (MagickCore_AdaptiveBlurImage)
444 proceed=SetImageProgress(image,AdaptiveBlurImageTag,progress++,
446 if (proceed == MagickFalse)
450 blur_image->type=image->type;
451 blur_view=DestroyCacheView(blur_view);
452 edge_view=DestroyCacheView(edge_view);
453 image_view=DestroyCacheView(image_view);
454 edge_image=DestroyImage(edge_image);
455 for (i=0; i < (ssize_t) width; i+=2)
456 kernel[i]=(MagickRealType *) RelinquishAlignedMemory(kernel[i]);
457 kernel=(MagickRealType **) RelinquishAlignedMemory(kernel);
458 if (status == MagickFalse)
459 blur_image=DestroyImage(blur_image);
464 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
468 % A d a p t i v e S h a r p e n I m a g e %
472 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
474 % AdaptiveSharpenImage() adaptively sharpens the image by sharpening more
475 % intensely near image edges and less intensely far from edges. We sharpen the
476 % image with a Gaussian operator of the given radius and standard deviation
477 % (sigma). For reasonable results, radius should be larger than sigma. Use a
478 % radius of 0 and AdaptiveSharpenImage() selects a suitable radius for you.
480 % The format of the AdaptiveSharpenImage method is:
482 % Image *AdaptiveSharpenImage(const Image *image,const double radius,
483 % const double sigma,ExceptionInfo *exception)
485 % A description of each parameter follows:
487 % o image: the image.
489 % o radius: the radius of the Gaussian, in pixels, not counting the center
492 % o sigma: the standard deviation of the Laplacian, in pixels.
494 % o exception: return any errors or warnings in this structure.
497 MagickExport Image *AdaptiveSharpenImage(const Image *image,const double radius,
498 const double sigma,ExceptionInfo *exception)
500 #define AdaptiveSharpenImageTag "Convolve/Image"
501 #define MagickSigma (fabs(sigma) < MagickEpsilon ? MagickEpsilon : sigma)
538 assert(image != (const Image *) NULL);
539 assert(image->signature == MagickSignature);
540 if (image->debug != MagickFalse)
541 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
542 assert(exception != (ExceptionInfo *) NULL);
543 assert(exception->signature == MagickSignature);
544 sharp_image=CloneImage(image,0,0,MagickTrue,exception);
545 if (sharp_image == (Image *) NULL)
546 return((Image *) NULL);
547 if (fabs(sigma) < MagickEpsilon)
549 if (SetImageStorageClass(sharp_image,DirectClass,exception) == MagickFalse)
551 sharp_image=DestroyImage(sharp_image);
552 return((Image *) NULL);
555 Edge detect the image brighness channel, level, sharp, and level again.
557 edge_image=EdgeImage(image,radius,sigma,exception);
558 if (edge_image == (Image *) NULL)
560 sharp_image=DestroyImage(sharp_image);
561 return((Image *) NULL);
563 (void) AdaptiveLevelImage(edge_image,"20%,95%",exception);
564 gaussian_image=GaussianBlurImage(edge_image,radius,sigma,exception);
565 if (gaussian_image != (Image *) NULL)
567 edge_image=DestroyImage(edge_image);
568 edge_image=gaussian_image;
570 (void) AdaptiveLevelImage(edge_image,"10%,95%",exception);
572 Create a set of kernels from maximum (radius,sigma) to minimum.
574 width=GetOptimalKernelWidth2D(radius,sigma);
575 kernel=(MagickRealType **) MagickAssumeAligned(AcquireAlignedMemory((size_t)
576 width,sizeof(*kernel)));
577 if (kernel == (MagickRealType **) NULL)
579 edge_image=DestroyImage(edge_image);
580 sharp_image=DestroyImage(sharp_image);
581 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
583 (void) ResetMagickMemory(kernel,0,(size_t) width*sizeof(*kernel));
584 for (i=0; i < (ssize_t) width; i+=2)
586 kernel[i]=(MagickRealType *) MagickAssumeAligned(AcquireAlignedMemory(
587 (size_t) (width-i),(width-i)*sizeof(**kernel)));
588 if (kernel[i] == (MagickRealType *) NULL)
591 j=(ssize_t) (width-i)/2;
593 for (v=(-j); v <= j; v++)
595 for (u=(-j); u <= j; u++)
597 kernel[i][k]=(MagickRealType) (-exp(-((double) u*u+v*v)/(2.0*
598 MagickSigma*MagickSigma))/(2.0*MagickPI*MagickSigma*MagickSigma));
599 normalize+=kernel[i][k];
603 if (fabs(normalize) < MagickEpsilon)
604 normalize=MagickEpsilon;
605 normalize=PerceptibleReciprocal(normalize);
606 for (k=0; k < (j*j); k++)
607 kernel[i][k]=normalize*kernel[i][k];
609 if (i < (ssize_t) width)
611 for (i-=2; i >= 0; i-=2)
612 kernel[i]=(MagickRealType *) RelinquishAlignedMemory(kernel[i]);
613 kernel=(MagickRealType **) RelinquishAlignedMemory(kernel);
614 edge_image=DestroyImage(edge_image);
615 sharp_image=DestroyImage(sharp_image);
616 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
619 Adaptively sharpen image.
623 image_view=AcquireVirtualCacheView(image,exception);
624 edge_view=AcquireVirtualCacheView(edge_image,exception);
625 sharp_view=AcquireAuthenticCacheView(sharp_image,exception);
626 #if defined(MAGICKCORE_OPENMP_SUPPORT)
627 #pragma omp parallel for schedule(static,4) shared(progress,status) \
628 magick_threads(image,sharp_image,sharp_image->rows,1)
630 for (y=0; y < (ssize_t) sharp_image->rows; y++)
632 register const Quantum
641 if (status == MagickFalse)
643 r=GetCacheViewVirtualPixels(edge_view,0,y,edge_image->columns,1,exception);
644 q=QueueCacheViewAuthenticPixels(sharp_view,0,y,sharp_image->columns,1,
646 if ((r == (const Quantum *) NULL) || (q == (Quantum *) NULL))
651 for (x=0; x < (ssize_t) sharp_image->columns; x++)
653 register const Quantum
663 j=(ssize_t) ceil((double) width*QuantumScale*
664 GetPixelIntensity(edge_image,r)-0.5);
668 if (j > (ssize_t) width)
672 p=GetCacheViewVirtualPixels(image_view,x-((ssize_t) (width-j)/2L),y-
673 (ssize_t) ((width-j)/2L),width-j,width-j,exception);
674 if (p == (const Quantum *) NULL)
676 center=(ssize_t) GetPixelChannels(image)*(width-j)*((width-j)/2L)+
677 GetPixelChannels(image)*((width-j)/2);
678 for (i=0; i < (ssize_t) GetPixelChannels(sharp_image); i++)
692 register const MagickRealType
695 register const Quantum
704 channel=GetPixelChannelChannel(image,i);
705 traits=GetPixelChannelTraits(image,channel);
706 sharp_traits=GetPixelChannelTraits(sharp_image,channel);
707 if ((traits == UndefinedPixelTrait) ||
708 (sharp_traits == UndefinedPixelTrait))
710 if (((sharp_traits & CopyPixelTrait) != 0) ||
711 (GetPixelMask(image,p+center) == 0))
713 SetPixelChannel(sharp_image,channel,p[center+i],q);
720 if ((sharp_traits & BlendPixelTrait) == 0)
725 for (v=0; v < (ssize_t) (width-j); v++)
727 for (u=0; u < (ssize_t) (width-j); u++)
729 pixel+=(*k)*pixels[i];
732 pixels+=GetPixelChannels(image);
735 gamma=PerceptibleReciprocal(gamma);
736 SetPixelChannel(sharp_image,channel,ClampToQuantum(gamma*pixel),q);
742 for (v=0; v < (ssize_t) (width-j); v++)
744 for (u=0; u < (ssize_t) (width-j); u++)
746 alpha=(double) (QuantumScale*GetPixelAlpha(image,pixels));
747 pixel+=(*k)*alpha*pixels[i];
750 pixels+=GetPixelChannels(image);
753 gamma=PerceptibleReciprocal(gamma);
754 SetPixelChannel(sharp_image,channel,ClampToQuantum(gamma*pixel),q);
756 q+=GetPixelChannels(sharp_image);
757 r+=GetPixelChannels(edge_image);
759 if (SyncCacheViewAuthenticPixels(sharp_view,exception) == MagickFalse)
761 if (image->progress_monitor != (MagickProgressMonitor) NULL)
766 #if defined(MAGICKCORE_OPENMP_SUPPORT)
767 #pragma omp critical (MagickCore_AdaptiveSharpenImage)
769 proceed=SetImageProgress(image,AdaptiveSharpenImageTag,progress++,
771 if (proceed == MagickFalse)
775 sharp_image->type=image->type;
776 sharp_view=DestroyCacheView(sharp_view);
777 edge_view=DestroyCacheView(edge_view);
778 image_view=DestroyCacheView(image_view);
779 edge_image=DestroyImage(edge_image);
780 for (i=0; i < (ssize_t) width; i+=2)
781 kernel[i]=(MagickRealType *) RelinquishAlignedMemory(kernel[i]);
782 kernel=(MagickRealType **) RelinquishAlignedMemory(kernel);
783 if (status == MagickFalse)
784 sharp_image=DestroyImage(sharp_image);
789 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
793 % B l u r I m a g e %
797 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
799 % BlurImage() blurs an image. We convolve the image with a Gaussian operator
800 % of the given radius and standard deviation (sigma). For reasonable results,
801 % the radius should be larger than sigma. Use a radius of 0 and BlurImage()
802 % selects a suitable radius for you.
804 % The format of the BlurImage method is:
806 % Image *BlurImage(const Image *image,const double radius,
807 % const double sigma,ExceptionInfo *exception)
809 % A description of each parameter follows:
811 % o image: the image.
813 % o radius: the radius of the Gaussian, in pixels, not counting the center
816 % o sigma: the standard deviation of the Gaussian, in pixels.
818 % o exception: return any errors or warnings in this structure.
821 MagickExport Image *BlurImage(const Image *image,const double radius,
822 const double sigma,ExceptionInfo *exception)
844 assert(image != (const Image *) NULL);
845 assert(image->signature == MagickSignature);
846 if (image->debug != MagickFalse)
847 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
848 assert(exception != (ExceptionInfo *) NULL);
849 assert(exception->signature == MagickSignature);
850 width=GetOptimalKernelWidth2D(radius,sigma);
851 kernel_info=AcquireKernelInfo((const char *) NULL);
852 if (kernel_info == (KernelInfo *) NULL)
853 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
854 (void) ResetMagickMemory(kernel_info,0,sizeof(*kernel_info));
855 kernel_info->width=width;
856 kernel_info->height=width;
857 kernel_info->x=(ssize_t) width/2;
858 kernel_info->y=(ssize_t) width/2;
859 kernel_info->signature=MagickSignature;
860 kernel_info->values=(MagickRealType *) MagickAssumeAligned(
861 AcquireAlignedMemory(kernel_info->width,kernel_info->width*
862 sizeof(*kernel_info->values)));
863 if (kernel_info->values == (MagickRealType *) NULL)
865 kernel_info=DestroyKernelInfo(kernel_info);
866 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
869 j=(ssize_t) (kernel_info->width-1)/2;
871 for (v=(-j); v <= j; v++)
873 for (u=(-j); u <= j; u++)
875 kernel_info->values[i]=(MagickRealType) (exp(-((double) u*u+v*v)/(2.0*
876 MagickSigma*MagickSigma))/(2.0*MagickPI*MagickSigma*MagickSigma));
877 normalize+=kernel_info->values[i];
881 kernel_info->values[i/2]+=(1.0-normalize);
882 if (sigma < MagickEpsilon)
883 kernel_info->values[i/2]=1.0;
884 blur_image=ConvolveImage(image,kernel_info,exception);
885 kernel_info=DestroyKernelInfo(kernel_info);
890 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
894 % C o n v o l v e I m a g e %
898 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
900 % ConvolveImage() applies a custom convolution kernel to the image.
902 % The format of the ConvolveImage method is:
904 % Image *ConvolveImage(const Image *image,const KernelInfo *kernel,
905 % ExceptionInfo *exception)
907 % A description of each parameter follows:
909 % o image: the image.
911 % o kernel: the filtering kernel.
913 % o exception: return any errors or warnings in this structure.
916 MagickExport Image *ConvolveImage(const Image *image,
917 const KernelInfo *kernel_info,ExceptionInfo *exception)
919 return(MorphologyImage(image,CorrelateMorphology,1,kernel_info,exception));
923 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
927 % D e s p e c k l e I m a g e %
931 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
933 % DespeckleImage() reduces the speckle noise in an image while perserving the
934 % edges of the original image. A speckle removing filter uses a complementary % hulling technique (raising pixels that are darker than their surrounding
935 % neighbors, then complementarily lowering pixels that are brighter than their
936 % surrounding neighbors) to reduce the speckle index of that image (reference
937 % Crimmins speckle removal).
939 % The format of the DespeckleImage method is:
941 % Image *DespeckleImage(const Image *image,ExceptionInfo *exception)
943 % A description of each parameter follows:
945 % o image: the image.
947 % o exception: return any errors or warnings in this structure.
951 static void Hull(const Image *image,const ssize_t x_offset,
952 const ssize_t y_offset,const size_t columns,const size_t rows,
953 const int polarity,Quantum *restrict f,Quantum *restrict g)
964 assert(f != (Quantum *) NULL);
965 assert(g != (Quantum *) NULL);
968 r=p+(y_offset*(columns+2)+x_offset);
969 #if defined(MAGICKCORE_OPENMP_SUPPORT)
970 #pragma omp parallel for schedule(static,4) \
971 magick_threads(image,image,1,1)
973 for (y=0; y < (ssize_t) rows; y++)
984 for (x=0; x < (ssize_t) columns; x++)
986 v=(MagickRealType) p[i];
987 if ((MagickRealType) r[i] >= (v+ScaleCharToQuantum(2)))
988 v+=ScaleCharToQuantum(1);
993 for (x=0; x < (ssize_t) columns; x++)
995 v=(MagickRealType) p[i];
996 if ((MagickRealType) r[i] <= (v-ScaleCharToQuantum(2)))
997 v-=ScaleCharToQuantum(1);
1004 r=q+(y_offset*(columns+2)+x_offset);
1005 s=q-(y_offset*(columns+2)+x_offset);
1006 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1007 #pragma omp parallel for schedule(static,4) \
1008 magick_threads(image,image,1,1)
1010 for (y=0; y < (ssize_t) rows; y++)
1019 i=(2*y+1)+y*columns;
1021 for (x=0; x < (ssize_t) columns; x++)
1023 v=(MagickRealType) q[i];
1024 if (((MagickRealType) s[i] >= (v+ScaleCharToQuantum(2))) &&
1025 ((MagickRealType) r[i] > v))
1026 v+=ScaleCharToQuantum(1);
1031 for (x=0; x < (ssize_t) columns; x++)
1033 v=(MagickRealType) q[i];
1034 if (((MagickRealType) s[i] <= (v-ScaleCharToQuantum(2))) &&
1035 ((MagickRealType) r[i] < v))
1036 v-=ScaleCharToQuantum(1);
1043 MagickExport Image *DespeckleImage(const Image *image,ExceptionInfo *exception)
1045 #define DespeckleImageTag "Despeckle/Image"
1067 static const ssize_t
1068 X[4] = {0, 1, 1,-1},
1069 Y[4] = {1, 0, 1, 1};
1072 Allocate despeckled image.
1074 assert(image != (const Image *) NULL);
1075 assert(image->signature == MagickSignature);
1076 if (image->debug != MagickFalse)
1077 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1078 assert(exception != (ExceptionInfo *) NULL);
1079 assert(exception->signature == MagickSignature);
1080 despeckle_image=CloneImage(image,0,0,MagickTrue,exception);
1081 if (despeckle_image == (Image *) NULL)
1082 return((Image *) NULL);
1083 status=SetImageStorageClass(despeckle_image,DirectClass,exception);
1084 if (status == MagickFalse)
1086 despeckle_image=DestroyImage(despeckle_image);
1087 return((Image *) NULL);
1090 Allocate image buffer.
1092 length=(size_t) ((image->columns+2)*(image->rows+2));
1093 pixels=(Quantum *) AcquireQuantumMemory(length,sizeof(*pixels));
1094 buffer=(Quantum *) AcquireQuantumMemory(length,sizeof(*buffer));
1095 if ((pixels == (Quantum *) NULL) || (buffer == (Quantum *) NULL))
1097 if (buffer != (Quantum *) NULL)
1098 buffer=(Quantum *) RelinquishMagickMemory(buffer);
1099 if (pixels != (Quantum *) NULL)
1100 pixels=(Quantum *) RelinquishMagickMemory(pixels);
1101 despeckle_image=DestroyImage(despeckle_image);
1102 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
1105 Reduce speckle in the image.
1108 image_view=AcquireVirtualCacheView(image,exception);
1109 despeckle_view=AcquireAuthenticCacheView(despeckle_image,exception);
1110 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1127 if (status == MagickFalse)
1129 channel=GetPixelChannelChannel(image,i);
1130 traits=GetPixelChannelTraits(image,channel);
1131 despeckle_traits=GetPixelChannelTraits(despeckle_image,channel);
1132 if ((traits == UndefinedPixelTrait) ||
1133 (despeckle_traits == UndefinedPixelTrait))
1135 if ((despeckle_traits & CopyPixelTrait) != 0)
1137 (void) ResetMagickMemory(pixels,0,length*sizeof(*pixels));
1138 j=(ssize_t) image->columns+2;
1139 for (y=0; y < (ssize_t) image->rows; y++)
1141 register const Quantum
1144 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
1145 if (p == (const Quantum *) NULL)
1151 for (x=0; x < (ssize_t) image->columns; x++)
1154 p+=GetPixelChannels(image);
1158 (void) ResetMagickMemory(buffer,0,length*sizeof(*buffer));
1159 for (k=0; k < 4; k++)
1161 Hull(image,X[k],Y[k],image->columns,image->rows,1,pixels,buffer);
1162 Hull(image,-X[k],-Y[k],image->columns,image->rows,1,pixels,buffer);
1163 Hull(image,-X[k],-Y[k],image->columns,image->rows,-1,pixels,buffer);
1164 Hull(image,X[k],Y[k],image->columns,image->rows,-1,pixels,buffer);
1166 j=(ssize_t) image->columns+2;
1167 for (y=0; y < (ssize_t) image->rows; y++)
1175 q=GetCacheViewAuthenticPixels(despeckle_view,0,y,despeckle_image->columns,
1177 if (q == (Quantum *) NULL)
1183 for (x=0; x < (ssize_t) image->columns; x++)
1185 SetPixelChannel(despeckle_image,channel,pixels[j++],q);
1186 q+=GetPixelChannels(despeckle_image);
1188 sync=SyncCacheViewAuthenticPixels(despeckle_view,exception);
1189 if (sync == MagickFalse)
1193 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1198 proceed=SetImageProgress(image,DespeckleImageTag,(MagickOffsetType) i,
1199 GetPixelChannels(image));
1200 if (proceed == MagickFalse)
1204 despeckle_view=DestroyCacheView(despeckle_view);
1205 image_view=DestroyCacheView(image_view);
1206 buffer=(Quantum *) RelinquishMagickMemory(buffer);
1207 pixels=(Quantum *) RelinquishMagickMemory(pixels);
1208 despeckle_image->type=image->type;
1209 if (status == MagickFalse)
1210 despeckle_image=DestroyImage(despeckle_image);
1211 return(despeckle_image);
1215 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1219 % E d g e I m a g e %
1223 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1225 % EdgeImage() finds edges in an image. Radius defines the radius of the
1226 % convolution filter. Use a radius of 0 and EdgeImage() selects a suitable
1229 % The format of the EdgeImage method is:
1231 % Image *EdgeImage(const Image *image,const double radius,
1232 % const double sigma,ExceptionInfo *exception)
1234 % A description of each parameter follows:
1236 % o image: the image.
1238 % o radius: the radius of the pixel neighborhood.
1240 % o sigma: the standard deviation of the Gaussian, in pixels.
1242 % o exception: return any errors or warnings in this structure.
1245 MagickExport Image *EdgeImage(const Image *image,const double radius,
1246 const double sigma,ExceptionInfo *exception)
1265 assert(image != (const Image *) NULL);
1266 assert(image->signature == MagickSignature);
1267 if (image->debug != MagickFalse)
1268 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1269 assert(exception != (ExceptionInfo *) NULL);
1270 assert(exception->signature == MagickSignature);
1271 width=GetOptimalKernelWidth1D(radius,sigma);
1272 kernel_info=AcquireKernelInfo((const char *) NULL);
1273 if (kernel_info == (KernelInfo *) NULL)
1274 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
1275 kernel_info->width=width;
1276 kernel_info->height=width;
1277 kernel_info->x=(ssize_t) width/2;
1278 kernel_info->y=(ssize_t) width/2;
1279 kernel_info->values=(MagickRealType *) MagickAssumeAligned(
1280 AcquireAlignedMemory(kernel_info->width,kernel_info->width*
1281 sizeof(*kernel_info->values)));
1282 if (kernel_info->values == (MagickRealType *) NULL)
1284 kernel_info=DestroyKernelInfo(kernel_info);
1285 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
1287 j=(ssize_t) (kernel_info->width-1)/2;
1289 for (v=(-j); v <= j; v++)
1291 for (u=(-j); u <= j; u++)
1293 kernel_info->values[i]=(MagickRealType) (-1.0);
1297 kernel_info->values[i/2]=(MagickRealType) (width*width-1.0);
1298 edge_image=ConvolveImage(image,kernel_info,exception);
1299 kernel_info=DestroyKernelInfo(kernel_info);
1304 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1308 % E m b o s s I m a g e %
1312 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1314 % EmbossImage() returns a grayscale image with a three-dimensional effect.
1315 % We convolve the image with a Gaussian operator of the given radius and
1316 % standard deviation (sigma). For reasonable results, radius should be
1317 % larger than sigma. Use a radius of 0 and Emboss() selects a suitable
1320 % The format of the EmbossImage method is:
1322 % Image *EmbossImage(const Image *image,const double radius,
1323 % const double sigma,ExceptionInfo *exception)
1325 % A description of each parameter follows:
1327 % o image: the image.
1329 % o radius: the radius of the pixel neighborhood.
1331 % o sigma: the standard deviation of the Gaussian, in pixels.
1333 % o exception: return any errors or warnings in this structure.
1336 MagickExport Image *EmbossImage(const Image *image,const double radius,
1337 const double sigma,ExceptionInfo *exception)
1357 assert(image != (const Image *) NULL);
1358 assert(image->signature == MagickSignature);
1359 if (image->debug != MagickFalse)
1360 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1361 assert(exception != (ExceptionInfo *) NULL);
1362 assert(exception->signature == MagickSignature);
1363 width=GetOptimalKernelWidth1D(radius,sigma);
1364 kernel_info=AcquireKernelInfo((const char *) NULL);
1365 if (kernel_info == (KernelInfo *) NULL)
1366 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
1367 kernel_info->width=width;
1368 kernel_info->height=width;
1369 kernel_info->x=(ssize_t) width/2;
1370 kernel_info->y=(ssize_t) width/2;
1371 kernel_info->values=(MagickRealType *) MagickAssumeAligned(
1372 AcquireAlignedMemory(kernel_info->width,kernel_info->width*
1373 sizeof(*kernel_info->values)));
1374 if (kernel_info->values == (MagickRealType *) NULL)
1376 kernel_info=DestroyKernelInfo(kernel_info);
1377 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
1379 j=(ssize_t) (kernel_info->width-1)/2;
1382 for (v=(-j); v <= j; v++)
1384 for (u=(-j); u <= j; u++)
1386 kernel_info->values[i]=(MagickRealType) (((u < 0) || (v < 0) ? -8.0 :
1387 8.0)*exp(-((double) u*u+v*v)/(2.0*MagickSigma*MagickSigma))/
1388 (2.0*MagickPI*MagickSigma*MagickSigma));
1390 kernel_info->values[i]=0.0;
1395 emboss_image=ConvolveImage(image,kernel_info,exception);
1396 kernel_info=DestroyKernelInfo(kernel_info);
1397 if (emboss_image != (Image *) NULL)
1398 (void) EqualizeImage(emboss_image,exception);
1399 return(emboss_image);
1403 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1407 % G a u s s i a n B l u r I m a g e %
1411 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1413 % GaussianBlurImage() blurs an image. We convolve the image with a
1414 % Gaussian operator of the given radius and standard deviation (sigma).
1415 % For reasonable results, the radius should be larger than sigma. Use a
1416 % radius of 0 and GaussianBlurImage() selects a suitable radius for you
1418 % The format of the GaussianBlurImage method is:
1420 % Image *GaussianBlurImage(const Image *image,onst double radius,
1421 % const double sigma,ExceptionInfo *exception)
1423 % A description of each parameter follows:
1425 % o image: the image.
1427 % o radius: the radius of the Gaussian, in pixels, not counting the center
1430 % o sigma: the standard deviation of the Gaussian, in pixels.
1432 % o exception: return any errors or warnings in this structure.
1435 MagickExport Image *GaussianBlurImage(const Image *image,const double radius,
1436 const double sigma,ExceptionInfo *exception)
1455 assert(image != (const Image *) NULL);
1456 assert(image->signature == MagickSignature);
1457 if (image->debug != MagickFalse)
1458 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1459 assert(exception != (ExceptionInfo *) NULL);
1460 assert(exception->signature == MagickSignature);
1461 width=GetOptimalKernelWidth2D(radius,sigma);
1462 kernel_info=AcquireKernelInfo((const char *) NULL);
1463 if (kernel_info == (KernelInfo *) NULL)
1464 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
1465 (void) ResetMagickMemory(kernel_info,0,sizeof(*kernel_info));
1466 kernel_info->width=width;
1467 kernel_info->height=width;
1468 kernel_info->x=(ssize_t) width/2;
1469 kernel_info->y=(ssize_t) width/2;
1470 kernel_info->signature=MagickSignature;
1471 kernel_info->values=(MagickRealType *) MagickAssumeAligned(
1472 AcquireAlignedMemory(kernel_info->width,kernel_info->width*
1473 sizeof(*kernel_info->values)));
1474 if (kernel_info->values == (MagickRealType *) NULL)
1476 kernel_info=DestroyKernelInfo(kernel_info);
1477 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
1479 j=(ssize_t) (kernel_info->width-1)/2;
1481 for (v=(-j); v <= j; v++)
1483 for (u=(-j); u <= j; u++)
1485 kernel_info->values[i]=(MagickRealType) (exp(-((double) u*u+v*v)/(2.0*
1486 MagickSigma*MagickSigma))/(2.0*MagickPI*MagickSigma*MagickSigma));
1490 blur_image=ConvolveImage(image,kernel_info,exception);
1491 kernel_info=DestroyKernelInfo(kernel_info);
1496 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1500 % M o t i o n B l u r I m a g e %
1504 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1506 % MotionBlurImage() simulates motion blur. We convolve the image with a
1507 % Gaussian operator of the given radius and standard deviation (sigma).
1508 % For reasonable results, radius should be larger than sigma. Use a
1509 % radius of 0 and MotionBlurImage() selects a suitable radius for you.
1510 % Angle gives the angle of the blurring motion.
1512 % Andrew Protano contributed this effect.
1514 % The format of the MotionBlurImage method is:
1516 % Image *MotionBlurImage(const Image *image,const double radius,
1517 % const double sigma,const double angle,ExceptionInfo *exception)
1519 % A description of each parameter follows:
1521 % o image: the image.
1523 % o radius: the radius of the Gaussian, in pixels, not counting
1526 % o sigma: the standard deviation of the Gaussian, in pixels.
1528 % o angle: Apply the effect along this angle.
1530 % o exception: return any errors or warnings in this structure.
1534 static MagickRealType *GetMotionBlurKernel(const size_t width,
1545 Generate a 1-D convolution kernel.
1547 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1548 kernel=(MagickRealType *) MagickAssumeAligned(AcquireAlignedMemory((size_t)
1549 width,sizeof(*kernel)));
1550 if (kernel == (MagickRealType *) NULL)
1553 for (i=0; i < (ssize_t) width; i++)
1555 kernel[i]=(MagickRealType) (exp((-((double) i*i)/(double) (2.0*MagickSigma*
1556 MagickSigma)))/(MagickSQ2PI*MagickSigma));
1557 normalize+=kernel[i];
1559 for (i=0; i < (ssize_t) width; i++)
1560 kernel[i]/=normalize;
1564 MagickExport Image *MotionBlurImage(const Image *image,const double radius,
1565 const double sigma,const double angle,ExceptionInfo *exception)
1567 #define BlurImageTag "Blur/Image"
1601 assert(image != (Image *) NULL);
1602 assert(image->signature == MagickSignature);
1603 if (image->debug != MagickFalse)
1604 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1605 assert(exception != (ExceptionInfo *) NULL);
1606 width=GetOptimalKernelWidth1D(radius,sigma);
1607 kernel=GetMotionBlurKernel(width,sigma);
1608 if (kernel == (MagickRealType *) NULL)
1609 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
1610 offset=(OffsetInfo *) AcquireQuantumMemory(width,sizeof(*offset));
1611 if (offset == (OffsetInfo *) NULL)
1613 kernel=(MagickRealType *) RelinquishAlignedMemory(kernel);
1614 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
1616 blur_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception);
1617 if (blur_image == (Image *) NULL)
1619 kernel=(MagickRealType *) RelinquishAlignedMemory(kernel);
1620 offset=(OffsetInfo *) RelinquishMagickMemory(offset);
1621 return((Image *) NULL);
1623 if (SetImageStorageClass(blur_image,DirectClass,exception) == MagickFalse)
1625 kernel=(MagickRealType *) RelinquishAlignedMemory(kernel);
1626 offset=(OffsetInfo *) RelinquishMagickMemory(offset);
1627 blur_image=DestroyImage(blur_image);
1628 return((Image *) NULL);
1630 point.x=(double) width*sin(DegreesToRadians(angle));
1631 point.y=(double) width*cos(DegreesToRadians(angle));
1632 for (i=0; i < (ssize_t) width; i++)
1634 offset[i].x=(ssize_t) ceil((double) (i*point.y)/hypot(point.x,point.y)-0.5);
1635 offset[i].y=(ssize_t) ceil((double) (i*point.x)/hypot(point.x,point.y)-0.5);
1642 image_view=AcquireVirtualCacheView(image,exception);
1643 motion_view=AcquireVirtualCacheView(image,exception);
1644 blur_view=AcquireAuthenticCacheView(blur_image,exception);
1645 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1646 #pragma omp parallel for schedule(static,4) shared(progress,status) \
1647 magick_threads(image,blur_image,image->rows,1)
1649 for (y=0; y < (ssize_t) image->rows; y++)
1651 register const Quantum
1660 if (status == MagickFalse)
1662 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
1663 q=QueueCacheViewAuthenticPixels(blur_view,0,y,blur_image->columns,1,
1665 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
1670 for (x=0; x < (ssize_t) image->columns; x++)
1675 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1689 register const Quantum
1692 register MagickRealType
1698 channel=GetPixelChannelChannel(image,i);
1699 traits=GetPixelChannelTraits(image,channel);
1700 blur_traits=GetPixelChannelTraits(blur_image,channel);
1701 if ((traits == UndefinedPixelTrait) ||
1702 (blur_traits == UndefinedPixelTrait))
1704 if (((blur_traits & CopyPixelTrait) != 0) ||
1705 (GetPixelMask(image,p) == 0))
1707 SetPixelChannel(blur_image,channel,p[i],q);
1712 if ((blur_traits & BlendPixelTrait) == 0)
1714 for (j=0; j < (ssize_t) width; j++)
1716 r=GetCacheViewVirtualPixels(motion_view,x+offset[j].x,y+
1717 offset[j].y,1,1,exception);
1718 if (r == (const Quantum *) NULL)
1726 SetPixelChannel(blur_image,channel,ClampToQuantum(pixel),q);
1731 for (j=0; j < (ssize_t) width; j++)
1733 r=GetCacheViewVirtualPixels(motion_view,x+offset[j].x,y+offset[j].y,1,
1735 if (r == (const Quantum *) NULL)
1740 alpha=(double) (QuantumScale*GetPixelAlpha(image,r));
1741 pixel+=(*k)*alpha*r[i];
1745 gamma=PerceptibleReciprocal(gamma);
1746 SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
1748 p+=GetPixelChannels(image);
1749 q+=GetPixelChannels(blur_image);
1751 if (SyncCacheViewAuthenticPixels(blur_view,exception) == MagickFalse)
1753 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1758 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1759 #pragma omp critical (MagickCore_MotionBlurImage)
1761 proceed=SetImageProgress(image,BlurImageTag,progress++,image->rows);
1762 if (proceed == MagickFalse)
1766 blur_view=DestroyCacheView(blur_view);
1767 motion_view=DestroyCacheView(motion_view);
1768 image_view=DestroyCacheView(image_view);
1769 kernel=(MagickRealType *) RelinquishAlignedMemory(kernel);
1770 offset=(OffsetInfo *) RelinquishMagickMemory(offset);
1771 if (status == MagickFalse)
1772 blur_image=DestroyImage(blur_image);
1777 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1781 % P r e v i e w I m a g e %
1785 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1787 % PreviewImage() tiles 9 thumbnails of the specified image with an image
1788 % processing operation applied with varying parameters. This may be helpful
1789 % pin-pointing an appropriate parameter for a particular image processing
1792 % The format of the PreviewImages method is:
1794 % Image *PreviewImages(const Image *image,const PreviewType preview,
1795 % ExceptionInfo *exception)
1797 % A description of each parameter follows:
1799 % o image: the image.
1801 % o preview: the image processing operation.
1803 % o exception: return any errors or warnings in this structure.
1806 MagickExport Image *PreviewImage(const Image *image,const PreviewType preview,
1807 ExceptionInfo *exception)
1809 #define NumberTiles 9
1810 #define PreviewImageTag "Preview/Image"
1811 #define DefaultPreviewGeometry "204x204+10+10"
1814 factor[MaxTextExtent],
1815 label[MaxTextExtent];
1860 Open output image file.
1862 assert(image != (Image *) NULL);
1863 assert(image->signature == MagickSignature);
1864 if (image->debug != MagickFalse)
1865 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1869 preview_info=AcquireImageInfo();
1870 SetGeometry(image,&geometry);
1871 (void) ParseMetaGeometry(DefaultPreviewGeometry,&geometry.x,&geometry.y,
1872 &geometry.width,&geometry.height);
1873 images=NewImageList();
1875 GetQuantizeInfo(&quantize_info);
1881 for (i=0; i < NumberTiles; i++)
1883 thumbnail=ThumbnailImage(image,geometry.width,geometry.height,exception);
1884 if (thumbnail == (Image *) NULL)
1886 (void) SetImageProgressMonitor(thumbnail,(MagickProgressMonitor) NULL,
1888 (void) SetImageProperty(thumbnail,"label",DefaultTileLabel,exception);
1889 if (i == (NumberTiles/2))
1891 (void) QueryColorCompliance("#dfdfdf",AllCompliance,
1892 &thumbnail->matte_color,exception);
1893 AppendImageToList(&images,thumbnail);
1901 preview_image=RotateImage(thumbnail,degrees,exception);
1902 (void) FormatLocaleString(label,MaxTextExtent,"rotate %g",degrees);
1908 preview_image=ShearImage(thumbnail,degrees,degrees,exception);
1909 (void) FormatLocaleString(label,MaxTextExtent,"shear %gx%g",degrees,
1915 x=(ssize_t) ((i+1)*thumbnail->columns)/NumberTiles;
1916 y=(ssize_t) ((i+1)*thumbnail->rows)/NumberTiles;
1917 preview_image=RollImage(thumbnail,x,y,exception);
1918 (void) FormatLocaleString(label,MaxTextExtent,"roll %+.20gx%+.20g",
1919 (double) x,(double) y);
1924 preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
1925 if (preview_image == (Image *) NULL)
1927 (void) FormatLocaleString(factor,MaxTextExtent,"100,100,%g",2.0*
1929 (void) ModulateImage(preview_image,factor,exception);
1930 (void) FormatLocaleString(label,MaxTextExtent,"modulate %s",factor);
1933 case SaturationPreview:
1935 preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
1936 if (preview_image == (Image *) NULL)
1938 (void) FormatLocaleString(factor,MaxTextExtent,"100,%g",2.0*percentage);
1939 (void) ModulateImage(preview_image,factor,exception);
1940 (void) FormatLocaleString(label,MaxTextExtent,"modulate %s",factor);
1943 case BrightnessPreview:
1945 preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
1946 if (preview_image == (Image *) NULL)
1948 (void) FormatLocaleString(factor,MaxTextExtent,"%g",2.0*percentage);
1949 (void) ModulateImage(preview_image,factor,exception);
1950 (void) FormatLocaleString(label,MaxTextExtent,"modulate %s",factor);
1956 preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
1957 if (preview_image == (Image *) NULL)
1960 (void) GammaImage(preview_image,gamma,exception);
1961 (void) FormatLocaleString(label,MaxTextExtent,"gamma %g",gamma);
1966 preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
1967 if (preview_image != (Image *) NULL)
1968 for (x=0; x < i; x++)
1969 (void) ContrastImage(preview_image,MagickTrue,exception);
1970 (void) FormatLocaleString(label,MaxTextExtent,"contrast (%.20g)",
1976 preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
1977 if (preview_image == (Image *) NULL)
1979 for (x=0; x < i; x++)
1980 (void) ContrastImage(preview_image,MagickFalse,exception);
1981 (void) FormatLocaleString(label,MaxTextExtent,"+contrast (%.20g)",
1985 case GrayscalePreview:
1987 preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
1988 if (preview_image == (Image *) NULL)
1991 quantize_info.number_colors=colors;
1992 quantize_info.colorspace=GRAYColorspace;
1993 (void) QuantizeImage(&quantize_info,preview_image,exception);
1994 (void) FormatLocaleString(label,MaxTextExtent,
1995 "-colorspace gray -colors %.20g",(double) colors);
1998 case QuantizePreview:
2000 preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
2001 if (preview_image == (Image *) NULL)
2004 quantize_info.number_colors=colors;
2005 (void) QuantizeImage(&quantize_info,preview_image,exception);
2006 (void) FormatLocaleString(label,MaxTextExtent,"colors %.20g",(double)
2010 case DespecklePreview:
2012 for (x=0; x < (i-1); x++)
2014 preview_image=DespeckleImage(thumbnail,exception);
2015 if (preview_image == (Image *) NULL)
2017 thumbnail=DestroyImage(thumbnail);
2018 thumbnail=preview_image;
2020 preview_image=DespeckleImage(thumbnail,exception);
2021 if (preview_image == (Image *) NULL)
2023 (void) FormatLocaleString(label,MaxTextExtent,"despeckle (%.20g)",
2027 case ReduceNoisePreview:
2029 preview_image=StatisticImage(thumbnail,NonpeakStatistic,(size_t) radius,
2030 (size_t) radius,exception);
2031 (void) FormatLocaleString(label,MaxTextExtent,"noise %g",radius);
2034 case AddNoisePreview:
2040 (void) CopyMagickString(factor,"uniform",MaxTextExtent);
2045 (void) CopyMagickString(factor,"gaussian",MaxTextExtent);
2050 (void) CopyMagickString(factor,"multiplicative",MaxTextExtent);
2055 (void) CopyMagickString(factor,"impulse",MaxTextExtent);
2060 (void) CopyMagickString(factor,"laplacian",MaxTextExtent);
2065 (void) CopyMagickString(factor,"Poisson",MaxTextExtent);
2070 (void) CopyMagickString(thumbnail->magick,"NULL",MaxTextExtent);
2074 preview_image=StatisticImage(thumbnail,NonpeakStatistic,(size_t) i,
2075 (size_t) i,exception);
2076 (void) FormatLocaleString(label,MaxTextExtent,"+noise %s",factor);
2079 case SharpenPreview:
2081 preview_image=SharpenImage(thumbnail,radius,sigma,exception);
2082 (void) FormatLocaleString(label,MaxTextExtent,"sharpen %gx%g",radius,
2088 preview_image=BlurImage(thumbnail,radius,sigma,exception);
2089 (void) FormatLocaleString(label,MaxTextExtent,"blur %gx%g",radius,
2093 case ThresholdPreview:
2095 preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
2096 if (preview_image == (Image *) NULL)
2098 (void) BilevelImage(thumbnail,(double) (percentage*((double)
2099 QuantumRange+1.0))/100.0,exception);
2100 (void) FormatLocaleString(label,MaxTextExtent,"threshold %g",(double)
2101 (percentage*((double) QuantumRange+1.0))/100.0);
2104 case EdgeDetectPreview:
2106 preview_image=EdgeImage(thumbnail,radius,sigma,exception);
2107 (void) FormatLocaleString(label,MaxTextExtent,"edge %g",radius);
2112 preview_image=SpreadImage(thumbnail,radius,thumbnail->interpolate,
2114 (void) FormatLocaleString(label,MaxTextExtent,"spread %g",radius+0.5);
2117 case SolarizePreview:
2119 preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
2120 if (preview_image == (Image *) NULL)
2122 (void) SolarizeImage(preview_image,(double) QuantumRange*percentage/
2124 (void) FormatLocaleString(label,MaxTextExtent,"solarize %g",
2125 (QuantumRange*percentage)/100.0);
2131 preview_image=ShadeImage(thumbnail,MagickTrue,degrees,degrees,
2133 (void) FormatLocaleString(label,MaxTextExtent,"shade %gx%g",degrees,
2139 preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
2140 if (preview_image == (Image *) NULL)
2142 geometry.width=(size_t) (2*i+2);
2143 geometry.height=(size_t) (2*i+2);
2146 (void) RaiseImage(preview_image,&geometry,MagickTrue,exception);
2147 (void) FormatLocaleString(label,MaxTextExtent,
2148 "raise %.20gx%.20g%+.20g%+.20g",(double) geometry.width,(double)
2149 geometry.height,(double) geometry.x,(double) geometry.y);
2152 case SegmentPreview:
2154 preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
2155 if (preview_image == (Image *) NULL)
2158 (void) SegmentImage(preview_image,sRGBColorspace,MagickFalse,threshold,
2159 threshold,exception);
2160 (void) FormatLocaleString(label,MaxTextExtent,"segment %gx%g",
2161 threshold,threshold);
2166 preview_image=SwirlImage(thumbnail,degrees,image->interpolate,
2168 (void) FormatLocaleString(label,MaxTextExtent,"swirl %g",degrees);
2172 case ImplodePreview:
2175 preview_image=ImplodeImage(thumbnail,degrees,image->interpolate,
2177 (void) FormatLocaleString(label,MaxTextExtent,"implode %g",degrees);
2183 preview_image=WaveImage(thumbnail,0.5*degrees,2.0*degrees,
2184 image->interpolate,exception);
2185 (void) FormatLocaleString(label,MaxTextExtent,"wave %gx%g",0.5*degrees,
2189 case OilPaintPreview:
2191 preview_image=OilPaintImage(thumbnail,(double) radius,(double) sigma,
2193 (void) FormatLocaleString(label,MaxTextExtent,"charcoal %gx%g",radius,
2197 case CharcoalDrawingPreview:
2199 preview_image=CharcoalImage(thumbnail,(double) radius,(double) sigma,
2201 (void) FormatLocaleString(label,MaxTextExtent,"charcoal %gx%g",radius,
2208 filename[MaxTextExtent];
2216 preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
2217 if (preview_image == (Image *) NULL)
2219 preview_info->quality=(size_t) percentage;
2220 (void) FormatLocaleString(factor,MaxTextExtent,"%.20g",(double)
2221 preview_info->quality);
2222 file=AcquireUniqueFileResource(filename);
2225 (void) FormatLocaleString(preview_image->filename,MaxTextExtent,
2226 "jpeg:%s",filename);
2227 status=WriteImage(preview_info,preview_image,exception);
2228 if (status != MagickFalse)
2233 (void) CopyMagickString(preview_info->filename,
2234 preview_image->filename,MaxTextExtent);
2235 quality_image=ReadImage(preview_info,exception);
2236 if (quality_image != (Image *) NULL)
2238 preview_image=DestroyImage(preview_image);
2239 preview_image=quality_image;
2242 (void) RelinquishUniqueFileResource(preview_image->filename);
2243 if ((GetBlobSize(preview_image)/1024) >= 1024)
2244 (void) FormatLocaleString(label,MaxTextExtent,"quality %s\n%gmb ",
2245 factor,(double) ((MagickOffsetType) GetBlobSize(preview_image))/
2248 if (GetBlobSize(preview_image) >= 1024)
2249 (void) FormatLocaleString(label,MaxTextExtent,
2250 "quality %s\n%gkb ",factor,(double) ((MagickOffsetType)
2251 GetBlobSize(preview_image))/1024.0);
2253 (void) FormatLocaleString(label,MaxTextExtent,"quality %s\n%.20gb ",
2254 factor,(double) ((MagickOffsetType) GetBlobSize(thumbnail)));
2258 thumbnail=DestroyImage(thumbnail);
2262 if (preview_image == (Image *) NULL)
2264 (void) DeleteImageProperty(preview_image,"label");
2265 (void) SetImageProperty(preview_image,"label",label,exception);
2266 AppendImageToList(&images,preview_image);
2267 proceed=SetImageProgress(image,PreviewImageTag,(MagickOffsetType) i,
2269 if (proceed == MagickFalse)
2272 if (images == (Image *) NULL)
2274 preview_info=DestroyImageInfo(preview_info);
2275 return((Image *) NULL);
2280 montage_info=CloneMontageInfo(preview_info,(MontageInfo *) NULL);
2281 (void) CopyMagickString(montage_info->filename,image->filename,MaxTextExtent);
2282 montage_info->shadow=MagickTrue;
2283 (void) CloneString(&montage_info->tile,"3x3");
2284 (void) CloneString(&montage_info->geometry,DefaultPreviewGeometry);
2285 (void) CloneString(&montage_info->frame,DefaultTileFrame);
2286 montage_image=MontageImages(images,montage_info,exception);
2287 montage_info=DestroyMontageInfo(montage_info);
2288 images=DestroyImageList(images);
2289 if (montage_image == (Image *) NULL)
2290 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
2291 if (montage_image->montage != (char *) NULL)
2294 Free image directory.
2296 montage_image->montage=(char *) RelinquishMagickMemory(
2297 montage_image->montage);
2298 if (image->directory != (char *) NULL)
2299 montage_image->directory=(char *) RelinquishMagickMemory(
2300 montage_image->directory);
2302 preview_info=DestroyImageInfo(preview_info);
2303 return(montage_image);
2307 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2311 % R a d i a l B l u r I m a g e %
2315 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2317 % RadialBlurImage() applies a radial blur to the image.
2319 % Andrew Protano contributed this effect.
2321 % The format of the RadialBlurImage method is:
2323 % Image *RadialBlurImage(const Image *image,const double angle,
2324 % ExceptionInfo *exception)
2326 % A description of each parameter follows:
2328 % o image: the image.
2330 % o angle: the angle of the radial blur.
2334 % o exception: return any errors or warnings in this structure.
2337 MagickExport Image *RadialBlurImage(const Image *image,const double angle,
2338 ExceptionInfo *exception)
2374 Allocate blur image.
2376 assert(image != (Image *) NULL);
2377 assert(image->signature == MagickSignature);
2378 if (image->debug != MagickFalse)
2379 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2380 assert(exception != (ExceptionInfo *) NULL);
2381 assert(exception->signature == MagickSignature);
2382 blur_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception);
2383 if (blur_image == (Image *) NULL)
2384 return((Image *) NULL);
2385 if (SetImageStorageClass(blur_image,DirectClass,exception) == MagickFalse)
2387 blur_image=DestroyImage(blur_image);
2388 return((Image *) NULL);
2390 blur_center.x=(double) image->columns/2.0;
2391 blur_center.y=(double) image->rows/2.0;
2392 blur_radius=hypot(blur_center.x,blur_center.y);
2393 n=(size_t) fabs(4.0*DegreesToRadians(angle)*sqrt((double) blur_radius)+2UL);
2394 theta=DegreesToRadians(angle)/(double) (n-1);
2395 cos_theta=(double *) AcquireQuantumMemory((size_t) n,
2396 sizeof(*cos_theta));
2397 sin_theta=(double *) AcquireQuantumMemory((size_t) n,
2398 sizeof(*sin_theta));
2399 if ((cos_theta == (double *) NULL) ||
2400 (sin_theta == (double *) NULL))
2402 blur_image=DestroyImage(blur_image);
2403 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
2405 offset=theta*(double) (n-1)/2.0;
2406 for (i=0; i < (ssize_t) n; i++)
2408 cos_theta[i]=cos((double) (theta*i-offset));
2409 sin_theta[i]=sin((double) (theta*i-offset));
2416 image_view=AcquireVirtualCacheView(image,exception);
2417 radial_view=AcquireVirtualCacheView(image,exception);
2418 blur_view=AcquireAuthenticCacheView(blur_image,exception);
2419 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2420 #pragma omp parallel for schedule(static,4) shared(progress,status) \
2421 magick_threads(image,blur_image,image->rows,1)
2423 for (y=0; y < (ssize_t) image->rows; y++)
2425 register const Quantum
2434 if (status == MagickFalse)
2436 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
2437 q=QueueCacheViewAuthenticPixels(blur_view,0,y,blur_image->columns,1,
2439 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
2444 for (x=0; x < (ssize_t) image->columns; x++)
2458 center.x=(double) x-blur_center.x;
2459 center.y=(double) y-blur_center.y;
2460 radius=hypot((double) center.x,center.y);
2465 step=(size_t) (blur_radius/radius);
2472 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
2485 register const Quantum
2491 channel=GetPixelChannelChannel(image,i);
2492 traits=GetPixelChannelTraits(image,channel);
2493 blur_traits=GetPixelChannelTraits(blur_image,channel);
2494 if ((traits == UndefinedPixelTrait) ||
2495 (blur_traits == UndefinedPixelTrait))
2497 if (((blur_traits & CopyPixelTrait) != 0) ||
2498 (GetPixelMask(image,p) == 0))
2500 SetPixelChannel(blur_image,channel,p[i],q);
2505 if ((blur_traits & BlendPixelTrait) == 0)
2507 for (j=0; j < (ssize_t) n; j+=(ssize_t) step)
2509 r=GetCacheViewVirtualPixels(radial_view, (ssize_t) (blur_center.x+
2510 center.x*cos_theta[j]-center.y*sin_theta[j]+0.5),(ssize_t)
2511 (blur_center.y+center.x*sin_theta[j]+center.y*cos_theta[j]+0.5),
2513 if (r == (const Quantum *) NULL)
2521 gamma=PerceptibleReciprocal(gamma);
2522 SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
2525 for (j=0; j < (ssize_t) n; j+=(ssize_t) step)
2527 r=GetCacheViewVirtualPixels(radial_view, (ssize_t) (blur_center.x+
2528 center.x*cos_theta[j]-center.y*sin_theta[j]+0.5),(ssize_t)
2529 (blur_center.y+center.x*sin_theta[j]+center.y*cos_theta[j]+0.5),
2531 if (r == (const Quantum *) NULL)
2536 pixel+=GetPixelAlpha(image,r)*r[i];
2537 gamma+=GetPixelAlpha(image,r);
2539 gamma=PerceptibleReciprocal(gamma);
2540 SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
2542 p+=GetPixelChannels(image);
2543 q+=GetPixelChannels(blur_image);
2545 if (SyncCacheViewAuthenticPixels(blur_view,exception) == MagickFalse)
2547 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2552 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2553 #pragma omp critical (MagickCore_RadialBlurImage)
2555 proceed=SetImageProgress(image,BlurImageTag,progress++,image->rows);
2556 if (proceed == MagickFalse)
2560 blur_view=DestroyCacheView(blur_view);
2561 radial_view=DestroyCacheView(radial_view);
2562 image_view=DestroyCacheView(image_view);
2563 cos_theta=(double *) RelinquishMagickMemory(cos_theta);
2564 sin_theta=(double *) RelinquishMagickMemory(sin_theta);
2565 if (status == MagickFalse)
2566 blur_image=DestroyImage(blur_image);
2571 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2575 % S e l e c t i v e B l u r I m a g e %
2579 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2581 % SelectiveBlurImage() selectively blur pixels within a contrast threshold.
2582 % It is similar to the unsharpen mask that sharpens everything with contrast
2583 % above a certain threshold.
2585 % The format of the SelectiveBlurImage method is:
2587 % Image *SelectiveBlurImage(const Image *image,const double radius,
2588 % const double sigma,const double threshold,ExceptionInfo *exception)
2590 % A description of each parameter follows:
2592 % o image: the image.
2594 % o radius: the radius of the Gaussian, in pixels, not counting the center
2597 % o sigma: the standard deviation of the Gaussian, in pixels.
2599 % o threshold: only pixels within this contrast threshold are included
2600 % in the blur operation.
2602 % o exception: return any errors or warnings in this structure.
2605 MagickExport Image *SelectiveBlurImage(const Image *image,const double radius,
2606 const double sigma,const double threshold,ExceptionInfo *exception)
2608 #define SelectiveBlurImageTag "SelectiveBlur/Image"
2642 Initialize blur image attributes.
2644 assert(image != (Image *) NULL);
2645 assert(image->signature == MagickSignature);
2646 if (image->debug != MagickFalse)
2647 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2648 assert(exception != (ExceptionInfo *) NULL);
2649 assert(exception->signature == MagickSignature);
2650 width=GetOptimalKernelWidth1D(radius,sigma);
2651 kernel=(MagickRealType *) MagickAssumeAligned(AcquireAlignedMemory((size_t)
2652 width,width*sizeof(*kernel)));
2653 if (kernel == (MagickRealType *) NULL)
2654 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
2655 j=(ssize_t) width/2;
2657 for (v=(-j); v <= j; v++)
2659 for (u=(-j); u <= j; u++)
2660 kernel[i++]=(MagickRealType) (exp(-((double) u*u+v*v)/(2.0*MagickSigma*
2661 MagickSigma))/(2.0*MagickPI*MagickSigma*MagickSigma));
2663 if (image->debug != MagickFalse)
2666 format[MaxTextExtent],
2669 register const MagickRealType
2676 (void) LogMagickEvent(TransformEvent,GetMagickModule(),
2677 " SelectiveBlurImage with %.20gx%.20g kernel:",(double) width,(double)
2679 message=AcquireString("");
2681 for (v=0; v < (ssize_t) width; v++)
2684 (void) FormatLocaleString(format,MaxTextExtent,"%.20g: ",(double) v);
2685 (void) ConcatenateString(&message,format);
2686 for (u=0; u < (ssize_t) width; u++)
2688 (void) FormatLocaleString(format,MaxTextExtent,"%+f ",(double) *k++);
2689 (void) ConcatenateString(&message,format);
2691 (void) LogMagickEvent(TransformEvent,GetMagickModule(),"%s",message);
2693 message=DestroyString(message);
2695 blur_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception);
2696 if (blur_image == (Image *) NULL)
2697 return((Image *) NULL);
2698 if (SetImageStorageClass(blur_image,DirectClass,exception) == MagickFalse)
2700 blur_image=DestroyImage(blur_image);
2701 kernel=(MagickRealType *) RelinquishAlignedMemory(kernel);
2702 return((Image *) NULL);
2704 luminance_image=CloneImage(image,0,0,MagickTrue,exception);
2705 if (luminance_image == (Image *) NULL)
2707 blur_image=DestroyImage(blur_image);
2708 kernel=(MagickRealType *) RelinquishAlignedMemory(kernel);
2709 return((Image *) NULL);
2711 status=TransformImageColorspace(luminance_image,GRAYColorspace,exception);
2712 if (status == MagickFalse)
2714 luminance_image=DestroyImage(luminance_image);
2715 blur_image=DestroyImage(blur_image);
2716 kernel=(MagickRealType *) RelinquishAlignedMemory(kernel);
2717 return((Image *) NULL);
2720 Threshold blur image.
2724 center=(ssize_t) (GetPixelChannels(image)*(image->columns+width)*(width/2L)+
2725 GetPixelChannels(image)*(width/2L));
2726 image_view=AcquireVirtualCacheView(image,exception);
2727 luminance_view=AcquireVirtualCacheView(luminance_image,exception);
2728 blur_view=AcquireAuthenticCacheView(blur_image,exception);
2729 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2730 #pragma omp parallel for schedule(static,4) shared(progress,status) \
2731 magick_threads(image,blur_image,image->rows,1)
2733 for (y=0; y < (ssize_t) image->rows; y++)
2741 register const Quantum
2751 if (status == MagickFalse)
2753 p=GetCacheViewVirtualPixels(image_view,-((ssize_t) width/2L),y-(ssize_t)
2754 (width/2L),image->columns+width,width,exception);
2755 l=GetCacheViewVirtualPixels(luminance_view,-((ssize_t) width/2L),y-(ssize_t)
2756 (width/2L),luminance_image->columns+width,width,exception);
2757 q=QueueCacheViewAuthenticPixels(blur_view,0,y,blur_image->columns,1,
2759 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
2764 for (x=0; x < (ssize_t) image->columns; x++)
2772 intensity=GetPixelIntensity(image,p+center);
2773 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
2787 register const MagickRealType
2790 register const Quantum
2791 *restrict luminance_pixels,
2800 channel=GetPixelChannelChannel(image,i);
2801 traits=GetPixelChannelTraits(image,channel);
2802 blur_traits=GetPixelChannelTraits(blur_image,channel);
2803 if ((traits == UndefinedPixelTrait) ||
2804 (blur_traits == UndefinedPixelTrait))
2806 if (((blur_traits & CopyPixelTrait) != 0) ||
2807 (GetPixelMask(image,p+center) == 0))
2809 SetPixelChannel(blur_image,channel,p[center+i],q);
2817 if ((blur_traits & BlendPixelTrait) == 0)
2819 for (v=0; v < (ssize_t) width; v++)
2821 for (u=0; u < (ssize_t) width; u++)
2823 contrast=GetPixelIntensity(luminance_image,luminance_pixels)-
2825 if (fabs(contrast) < threshold)
2827 pixel+=(*k)*pixels[i];
2831 pixels+=GetPixelChannels(image);
2832 luminance_pixels+=GetPixelChannels(luminance_image);
2834 pixels+=(image->columns-1)*GetPixelChannels(image);
2835 luminance_pixels+=luminance_image->columns*
2836 GetPixelChannels(luminance_image);
2838 if (fabs((double) gamma) < MagickEpsilon)
2840 SetPixelChannel(blur_image,channel,p[center+i],q);
2843 gamma=PerceptibleReciprocal(gamma);
2844 SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
2847 for (v=0; v < (ssize_t) width; v++)
2849 for (u=0; u < (ssize_t) width; u++)
2851 contrast=GetPixelIntensity(image,pixels)-intensity;
2852 if (fabs(contrast) < threshold)
2854 alpha=(double) (QuantumScale*GetPixelAlpha(image,pixels));
2855 pixel+=(*k)*alpha*pixels[i];
2859 pixels+=GetPixelChannels(image);
2860 luminance_pixels+=GetPixelChannels(luminance_image);
2862 pixels+=(image->columns-1)*GetPixelChannels(image);
2863 luminance_pixels+=luminance_image->columns*
2864 GetPixelChannels(luminance_image);
2866 if (fabs((double) gamma) < MagickEpsilon)
2868 SetPixelChannel(blur_image,channel,p[center+i],q);
2871 gamma=PerceptibleReciprocal(gamma);
2872 SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
2874 p+=GetPixelChannels(image);
2875 l+=GetPixelChannels(luminance_image);
2876 q+=GetPixelChannels(blur_image);
2878 sync=SyncCacheViewAuthenticPixels(blur_view,exception);
2879 if (sync == MagickFalse)
2881 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2886 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2887 #pragma omp critical (MagickCore_SelectiveBlurImage)
2889 proceed=SetImageProgress(image,SelectiveBlurImageTag,progress++,
2891 if (proceed == MagickFalse)
2895 blur_image->type=image->type;
2896 blur_view=DestroyCacheView(blur_view);
2897 image_view=DestroyCacheView(image_view);
2898 luminance_image=DestroyImage(luminance_image);
2899 kernel=(MagickRealType *) RelinquishAlignedMemory(kernel);
2900 if (status == MagickFalse)
2901 blur_image=DestroyImage(blur_image);
2906 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2910 % S h a d e I m a g e %
2914 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2916 % ShadeImage() shines a distant light on an image to create a
2917 % three-dimensional effect. You control the positioning of the light with
2918 % azimuth and elevation; azimuth is measured in degrees off the x axis
2919 % and elevation is measured in pixels above the Z axis.
2921 % The format of the ShadeImage method is:
2923 % Image *ShadeImage(const Image *image,const MagickBooleanType gray,
2924 % const double azimuth,const double elevation,ExceptionInfo *exception)
2926 % A description of each parameter follows:
2928 % o image: the image.
2930 % o gray: A value other than zero shades the intensity of each pixel.
2932 % o azimuth, elevation: Define the light source direction.
2934 % o exception: return any errors or warnings in this structure.
2937 MagickExport Image *ShadeImage(const Image *image,const MagickBooleanType gray,
2938 const double azimuth,const double elevation,ExceptionInfo *exception)
2940 #define ShadeImageTag "Shade/Image"
2963 Initialize shaded image attributes.
2965 assert(image != (const Image *) NULL);
2966 assert(image->signature == MagickSignature);
2967 if (image->debug != MagickFalse)
2968 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2969 assert(exception != (ExceptionInfo *) NULL);
2970 assert(exception->signature == MagickSignature);
2971 linear_image=CloneImage(image,0,0,MagickTrue,exception);
2972 shade_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception);
2973 if ((linear_image == (Image *) NULL) || (shade_image == (Image *) NULL))
2975 if (linear_image != (Image *) NULL)
2976 linear_image=DestroyImage(linear_image);
2977 if (shade_image != (Image *) NULL)
2978 shade_image=DestroyImage(shade_image);
2979 return((Image *) NULL);
2981 if (SetImageStorageClass(shade_image,DirectClass,exception) == MagickFalse)
2983 linear_image=DestroyImage(linear_image);
2984 shade_image=DestroyImage(shade_image);
2985 return((Image *) NULL);
2988 Compute the light vector.
2990 light.x=(double) QuantumRange*cos(DegreesToRadians(azimuth))*
2991 cos(DegreesToRadians(elevation));
2992 light.y=(double) QuantumRange*sin(DegreesToRadians(azimuth))*
2993 cos(DegreesToRadians(elevation));
2994 light.z=(double) QuantumRange*sin(DegreesToRadians(elevation));
3000 image_view=AcquireVirtualCacheView(linear_image,exception);
3001 shade_view=AcquireAuthenticCacheView(shade_image,exception);
3002 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3003 #pragma omp parallel for schedule(static,4) shared(progress,status) \
3004 magick_threads(linear_image,shade_image,linear_image->rows,1)
3006 for (y=0; y < (ssize_t) linear_image->rows; y++)
3016 register const Quantum
3028 if (status == MagickFalse)
3030 p=GetCacheViewVirtualPixels(image_view,-1,y-1,linear_image->columns+2,3,
3032 q=QueueCacheViewAuthenticPixels(shade_view,0,y,shade_image->columns,1,
3034 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
3040 Shade this row of pixels.
3042 normal.z=2.0*(double) QuantumRange; /* constant Z of surface normal */
3043 pre=p+GetPixelChannels(linear_image);
3044 center=pre+(linear_image->columns+2)*GetPixelChannels(linear_image);
3045 post=center+(linear_image->columns+2)*GetPixelChannels(linear_image);
3046 for (x=0; x < (ssize_t) linear_image->columns; x++)
3052 Determine the surface normal and compute shading.
3055 GetPixelIntensity(linear_image,pre-GetPixelChannels(linear_image))+
3056 GetPixelIntensity(linear_image,center-GetPixelChannels(linear_image))+
3057 GetPixelIntensity(linear_image,post-GetPixelChannels(linear_image))-
3058 GetPixelIntensity(linear_image,pre+GetPixelChannels(linear_image))-
3059 GetPixelIntensity(linear_image,center+GetPixelChannels(linear_image))-
3060 GetPixelIntensity(linear_image,post+GetPixelChannels(linear_image)));
3062 GetPixelIntensity(linear_image,post-GetPixelChannels(linear_image))+
3063 GetPixelIntensity(linear_image,post)+
3064 GetPixelIntensity(linear_image,post+GetPixelChannels(linear_image))-
3065 GetPixelIntensity(linear_image,pre-GetPixelChannels(linear_image))-
3066 GetPixelIntensity(linear_image,pre)-
3067 GetPixelIntensity(linear_image,pre+GetPixelChannels(linear_image)));
3068 if ((normal.x == 0.0) && (normal.y == 0.0))
3073 distance=normal.x*light.x+normal.y*light.y+normal.z*light.z;
3074 if (distance > MagickEpsilon)
3076 normal_distance=normal.x*normal.x+normal.y*normal.y+
3078 if (normal_distance > (MagickEpsilon*MagickEpsilon))
3079 shade=distance/sqrt((double) normal_distance);
3082 for (i=0; i < (ssize_t) GetPixelChannels(linear_image); i++)
3091 channel=GetPixelChannelChannel(linear_image,i);
3092 traits=GetPixelChannelTraits(linear_image,channel);
3093 shade_traits=GetPixelChannelTraits(shade_image,channel);
3094 if ((traits == UndefinedPixelTrait) ||
3095 (shade_traits == UndefinedPixelTrait))
3097 if (((shade_traits & CopyPixelTrait) != 0) ||
3098 (GetPixelMask(linear_image,center) == 0))
3100 SetPixelChannel(shade_image,channel,center[i],q);
3103 if (gray != MagickFalse)
3105 SetPixelChannel(shade_image,channel,ClampToQuantum(shade),q);
3108 SetPixelChannel(shade_image,channel,ClampToQuantum(QuantumScale*shade*
3111 pre+=GetPixelChannels(linear_image);
3112 center+=GetPixelChannels(linear_image);
3113 post+=GetPixelChannels(linear_image);
3114 q+=GetPixelChannels(shade_image);
3116 if (SyncCacheViewAuthenticPixels(shade_view,exception) == MagickFalse)
3118 if (image->progress_monitor != (MagickProgressMonitor) NULL)
3123 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3124 #pragma omp critical (MagickCore_ShadeImage)
3126 proceed=SetImageProgress(image,ShadeImageTag,progress++,image->rows);
3127 if (proceed == MagickFalse)
3131 shade_view=DestroyCacheView(shade_view);
3132 image_view=DestroyCacheView(image_view);
3133 linear_image=DestroyImage(linear_image);
3134 if (status == MagickFalse)
3135 shade_image=DestroyImage(shade_image);
3136 return(shade_image);
3140 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3144 % S h a r p e n I m a g e %
3148 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3150 % SharpenImage() sharpens the image. We convolve the image with a Gaussian
3151 % operator of the given radius and standard deviation (sigma). For
3152 % reasonable results, radius should be larger than sigma. Use a radius of 0
3153 % and SharpenImage() selects a suitable radius for you.
3155 % Using a separable kernel would be faster, but the negative weights cancel
3156 % out on the corners of the kernel producing often undesirable ringing in the
3157 % filtered result; this can be avoided by using a 2D gaussian shaped image
3158 % sharpening kernel instead.
3160 % The format of the SharpenImage method is:
3162 % Image *SharpenImage(const Image *image,const double radius,
3163 % const double sigma,ExceptionInfo *exception)
3165 % A description of each parameter follows:
3167 % o image: the image.
3169 % o radius: the radius of the Gaussian, in pixels, not counting the center
3172 % o sigma: the standard deviation of the Laplacian, in pixels.
3174 % o exception: return any errors or warnings in this structure.
3177 MagickExport Image *SharpenImage(const Image *image,const double radius,
3178 const double sigma,ExceptionInfo *exception)
3200 assert(image != (const Image *) NULL);
3201 assert(image->signature == MagickSignature);
3202 if (image->debug != MagickFalse)
3203 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3204 assert(exception != (ExceptionInfo *) NULL);
3205 assert(exception->signature == MagickSignature);
3206 width=GetOptimalKernelWidth2D(radius,sigma);
3207 kernel_info=AcquireKernelInfo((const char *) NULL);
3208 if (kernel_info == (KernelInfo *) NULL)
3209 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
3210 (void) ResetMagickMemory(kernel_info,0,sizeof(*kernel_info));
3211 kernel_info->width=width;
3212 kernel_info->height=width;
3213 kernel_info->x=(ssize_t) width/2;
3214 kernel_info->y=(ssize_t) width/2;
3215 kernel_info->signature=MagickSignature;
3216 kernel_info->values=(MagickRealType *) MagickAssumeAligned(
3217 AcquireAlignedMemory(kernel_info->width,kernel_info->width*
3218 sizeof(*kernel_info->values)));
3219 if (kernel_info->values == (MagickRealType *) NULL)
3221 kernel_info=DestroyKernelInfo(kernel_info);
3222 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
3225 j=(ssize_t) (kernel_info->width-1)/2;
3227 for (v=(-j); v <= j; v++)
3229 for (u=(-j); u <= j; u++)
3231 kernel_info->values[i]=(MagickRealType) (-exp(-((double) u*u+v*v)/(2.0*
3232 MagickSigma*MagickSigma))/(2.0*MagickPI*MagickSigma*MagickSigma));
3233 normalize+=kernel_info->values[i];
3237 kernel_info->values[i/2]=(double) ((-2.0)*normalize);
3238 if (sigma < MagickEpsilon)
3239 kernel_info->values[i/2]=1.0;
3240 sharp_image=ConvolveImage(image,kernel_info,exception);
3241 kernel_info=DestroyKernelInfo(kernel_info);
3242 return(sharp_image);
3246 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3250 % S p r e a d I m a g e %
3254 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3256 % SpreadImage() is a special effects method that randomly displaces each
3257 % pixel in a block defined by the radius parameter.
3259 % The format of the SpreadImage method is:
3261 % Image *SpreadImage(const Image *image,const double radius,
3262 % const PixelInterpolateMethod method,ExceptionInfo *exception)
3264 % A description of each parameter follows:
3266 % o image: the image.
3268 % o radius: choose a random pixel in a neighborhood of this extent.
3270 % o method: the pixel interpolation method.
3272 % o exception: return any errors or warnings in this structure.
3275 MagickExport Image *SpreadImage(const Image *image,const double radius,
3276 const PixelInterpolateMethod method,ExceptionInfo *exception)
3278 #define SpreadImageTag "Spread/Image"
3294 **restrict random_info;
3302 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3308 Initialize spread image attributes.
3310 assert(image != (Image *) NULL);
3311 assert(image->signature == MagickSignature);
3312 if (image->debug != MagickFalse)
3313 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3314 assert(exception != (ExceptionInfo *) NULL);
3315 assert(exception->signature == MagickSignature);
3316 spread_image=CloneImage(image,image->columns,image->rows,MagickTrue,
3318 if (spread_image == (Image *) NULL)
3319 return((Image *) NULL);
3320 if (SetImageStorageClass(spread_image,DirectClass,exception) == MagickFalse)
3322 spread_image=DestroyImage(spread_image);
3323 return((Image *) NULL);
3330 width=GetOptimalKernelWidth1D(radius,0.5);
3331 random_info=AcquireRandomInfoThreadSet();
3332 image_view=AcquireVirtualCacheView(image,exception);
3333 spread_view=AcquireAuthenticCacheView(spread_image,exception);
3334 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3335 key=GetRandomSecretKey(random_info[0]);
3336 #pragma omp parallel for schedule(static,4) shared(progress,status) \
3337 magick_threads(image,spread_image,image->rows,key == ~0UL)
3339 for (y=0; y < (ssize_t) image->rows; y++)
3342 id = GetOpenMPThreadId();
3344 register const Quantum
3353 if (status == MagickFalse)
3355 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
3356 q=QueueCacheViewAuthenticPixels(spread_view,0,y,spread_image->columns,1,
3358 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
3363 for (x=0; x < (ssize_t) image->columns; x++)
3368 point.x=GetPseudoRandomValue(random_info[id]);
3369 point.y=GetPseudoRandomValue(random_info[id]);
3370 status=InterpolatePixelChannels(image,image_view,spread_image,method,
3371 (double) x+width*point.x-0.5,(double) y+width*point.y-0.5,q,exception);
3372 q+=GetPixelChannels(spread_image);
3374 if (SyncCacheViewAuthenticPixels(spread_view,exception) == MagickFalse)
3376 if (image->progress_monitor != (MagickProgressMonitor) NULL)
3381 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3382 #pragma omp critical (MagickCore_SpreadImage)
3384 proceed=SetImageProgress(image,SpreadImageTag,progress++,image->rows);
3385 if (proceed == MagickFalse)
3389 spread_view=DestroyCacheView(spread_view);
3390 image_view=DestroyCacheView(image_view);
3391 random_info=DestroyRandomInfoThreadSet(random_info);
3392 if (status == MagickFalse)
3393 spread_image=DestroyImage(spread_image);
3394 return(spread_image);
3398 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3402 % U n s h a r p M a s k I m a g e %
3406 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3408 % UnsharpMaskImage() sharpens one or more image channels. We convolve the
3409 % image with a Gaussian operator of the given radius and standard deviation
3410 % (sigma). For reasonable results, radius should be larger than sigma. Use a
3411 % radius of 0 and UnsharpMaskImage() selects a suitable radius for you.
3413 % The format of the UnsharpMaskImage method is:
3415 % Image *UnsharpMaskImage(const Image *image,const double radius,
3416 % const double sigma,const double amount,const double threshold,
3417 % ExceptionInfo *exception)
3419 % A description of each parameter follows:
3421 % o image: the image.
3423 % o radius: the radius of the Gaussian, in pixels, not counting the center
3426 % o sigma: the standard deviation of the Gaussian, in pixels.
3428 % o amount: the percentage of the difference between the original and the
3429 % blur image that is added back into the original.
3431 % o threshold: the threshold in pixels needed to apply the diffence amount.
3433 % o exception: return any errors or warnings in this structure.
3436 MagickExport Image *UnsharpMaskImage(const Image *image,const double radius,
3437 const double sigma,const double amount,const double threshold,
3438 ExceptionInfo *exception)
3440 #define SharpenImageTag "Sharpen/Image"
3461 assert(image != (const Image *) NULL);
3462 assert(image->signature == MagickSignature);
3463 if (image->debug != MagickFalse)
3464 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3465 assert(exception != (ExceptionInfo *) NULL);
3466 unsharp_image=BlurImage(image,radius,sigma,exception);
3467 if (unsharp_image == (Image *) NULL)
3468 return((Image *) NULL);
3469 quantum_threshold=(double) QuantumRange*threshold;
3475 image_view=AcquireVirtualCacheView(image,exception);
3476 unsharp_view=AcquireAuthenticCacheView(unsharp_image,exception);
3477 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3478 #pragma omp parallel for schedule(static,4) shared(progress,status) \
3479 magick_threads(image,unsharp_image,image->rows,1)
3481 for (y=0; y < (ssize_t) image->rows; y++)
3483 register const Quantum
3492 if (status == MagickFalse)
3494 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
3495 q=QueueCacheViewAuthenticPixels(unsharp_view,0,y,unsharp_image->columns,1,
3497 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
3502 for (x=0; x < (ssize_t) image->columns; x++)
3507 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
3519 channel=GetPixelChannelChannel(image,i);
3520 traits=GetPixelChannelTraits(image,channel);
3521 unsharp_traits=GetPixelChannelTraits(unsharp_image,channel);
3522 if ((traits == UndefinedPixelTrait) ||
3523 (unsharp_traits == UndefinedPixelTrait))
3525 if (((unsharp_traits & CopyPixelTrait) != 0) ||
3526 (GetPixelMask(image,p) == 0))
3528 SetPixelChannel(unsharp_image,channel,p[i],q);
3531 pixel=p[i]-(double) GetPixelChannel(unsharp_image,channel,q);
3532 if (fabs(2.0*pixel) < quantum_threshold)
3533 pixel=(double) p[i];
3535 pixel=(double) p[i]+amount*pixel;
3536 SetPixelChannel(unsharp_image,channel,ClampToQuantum(pixel),q);
3538 p+=GetPixelChannels(image);
3539 q+=GetPixelChannels(unsharp_image);
3541 if (SyncCacheViewAuthenticPixels(unsharp_view,exception) == MagickFalse)
3543 if (image->progress_monitor != (MagickProgressMonitor) NULL)
3548 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3549 #pragma omp critical (MagickCore_UnsharpMaskImage)
3551 proceed=SetImageProgress(image,SharpenImageTag,progress++,image->rows);
3552 if (proceed == MagickFalse)
3556 unsharp_image->type=image->type;
3557 unsharp_view=DestroyCacheView(unsharp_view);
3558 image_view=DestroyCacheView(image_view);
3559 if (status == MagickFalse)
3560 unsharp_image=DestroyImage(unsharp_image);
3561 return(unsharp_image);