2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6 % PPPP AAA IIIII N N TTTTT %
8 % PPPP AAAAA I N N N T %
13 % Methods to Paint on an Image %
20 % Copyright 1999-2012 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 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
42 #include "MagickCore/studio.h"
43 #include "MagickCore/color.h"
44 #include "MagickCore/color-private.h"
45 #include "MagickCore/colorspace-private.h"
46 #include "MagickCore/composite.h"
47 #include "MagickCore/composite-private.h"
48 #include "MagickCore/draw.h"
49 #include "MagickCore/draw-private.h"
50 #include "MagickCore/exception.h"
51 #include "MagickCore/exception-private.h"
52 #include "MagickCore/gem.h"
53 #include "MagickCore/gem-private.h"
54 #include "MagickCore/monitor.h"
55 #include "MagickCore/monitor-private.h"
56 #include "MagickCore/paint.h"
57 #include "MagickCore/pixel-accessor.h"
58 #include "MagickCore/resource_.h"
59 #include "MagickCore/statistic.h"
60 #include "MagickCore/string_.h"
61 #include "MagickCore/thread-private.h"
64 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
68 % F l o o d f i l l P a i n t I m a g e %
72 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
74 % FloodfillPaintImage() changes the color value of any pixel that matches
75 % target and is an immediate neighbor. If the method FillToBorderMethod is
76 % specified, the color value is changed for any neighbor pixel that does not
77 % match the bordercolor member of image.
79 % By default target must match a particular pixel color exactly. However,
80 % in many cases two colors may differ by a small amount. The fuzz member of
81 % image defines how much tolerance is acceptable to consider two colors as
82 % the same. For example, set fuzz to 10 and the color red at intensities of
83 % 100 and 102 respectively are now interpreted as the same color for the
84 % purposes of the floodfill.
86 % The format of the FloodfillPaintImage method is:
88 % MagickBooleanType FloodfillPaintImage(Image *image,
89 % const DrawInfo *draw_info,const PixelInfo target,
90 % const ssize_t x_offset,const ssize_t y_offset,
91 % const MagickBooleanType invert,ExceptionInfo *exception)
93 % A description of each parameter follows:
97 % o draw_info: the draw info.
99 % o target: the RGB value of the target color.
101 % o x_offset,y_offset: the starting location of the operation.
103 % o invert: paint any pixel that does not match the target color.
105 % o exception: return any errors or warnings in this structure.
108 MagickExport MagickBooleanType FloodfillPaintImage(Image *image,
109 const DrawInfo *draw_info,const PixelInfo *target,const ssize_t x_offset,
110 const ssize_t y_offset,const MagickBooleanType invert,
111 ExceptionInfo *exception)
113 #define MaxStacksize (1UL << 15)
114 #define PushSegmentStack(up,left,right,delta) \
116 if (s >= (segment_stack+MaxStacksize)) \
117 ThrowBinaryException(DrawError,"SegmentStackOverflow",image->filename) \
120 if ((((up)+(delta)) >= 0) && (((up)+(delta)) < (ssize_t) image->rows)) \
122 s->x1=(double) (left); \
123 s->y1=(double) (up); \
124 s->x2=(double) (right); \
125 s->y2=(double) (delta); \
161 Check boundary conditions.
163 assert(image != (Image *) NULL);
164 assert(image->signature == MagickSignature);
165 if (image->debug != MagickFalse)
166 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
167 assert(draw_info != (DrawInfo *) NULL);
168 assert(draw_info->signature == MagickSignature);
169 if ((x_offset < 0) || (x_offset >= (ssize_t) image->columns))
171 if ((y_offset < 0) || (y_offset >= (ssize_t) image->rows))
173 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
175 if (IsGrayColorspace(image->colorspace) != MagickFalse)
176 (void) TransformImageColorspace(image,RGBColorspace,exception);
177 if ((image->alpha_trait != BlendPixelTrait) && (draw_info->fill.alpha_trait == BlendPixelTrait))
178 (void) SetImageAlpha(image,OpaqueAlpha,exception);
182 floodplane_image=CloneImage(image,image->columns,image->rows,MagickTrue,
184 if (floodplane_image == (Image *) NULL)
186 floodplane_image->alpha_trait=UndefinedPixelTrait;
187 floodplane_image->colorspace=GRAYColorspace;
188 (void) QueryColorCompliance("#000",AllCompliance,
189 &floodplane_image->background_color,exception);
190 (void) SetImageBackgroundColor(floodplane_image,exception);
191 segment_stack=(SegmentInfo *) AcquireQuantumMemory(MaxStacksize,
192 sizeof(*segment_stack));
193 if (segment_stack == (SegmentInfo *) NULL)
195 floodplane_image=DestroyImage(floodplane_image);
196 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
200 Push initial segment on stack.
207 PushSegmentStack(y,x,x,1);
208 PushSegmentStack(y+1,x,x,-1);
209 GetPixelInfo(image,&pixel);
210 image_view=AcquireVirtualCacheView(image,exception);
211 floodplane_view=AcquireAuthenticCacheView(floodplane_image,exception);
212 while (s > segment_stack)
214 register const Quantum
224 Pop segment off stack.
229 offset=(ssize_t) s->y2;
230 y=(ssize_t) s->y1+offset;
232 Recolor neighboring pixels.
234 p=GetCacheViewVirtualPixels(image_view,0,y,(size_t) (x1+1),1,exception);
235 q=GetCacheViewAuthenticPixels(floodplane_view,0,y,(size_t) (x1+1),1,
237 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
239 p+=x1*GetPixelChannels(image);
240 q+=x1*GetPixelChannels(floodplane_image);
241 for (x=x1; x >= 0; x--)
243 if (GetPixelGray(floodplane_image,q) != 0)
245 GetPixelInfoPixel(image,p,&pixel);
246 if (IsFuzzyEquivalencePixelInfo(&pixel,target) == invert)
248 SetPixelGray(floodplane_image,QuantumRange,q);
249 p-=GetPixelChannels(image);
250 q-=GetPixelChannels(floodplane_image);
252 if (SyncCacheViewAuthenticPixels(floodplane_view,exception) == MagickFalse)
254 skip=x >= x1 ? MagickTrue : MagickFalse;
255 if (skip == MagickFalse)
259 PushSegmentStack(y,start,x1-1,-offset);
264 if (skip == MagickFalse)
266 if (x < (ssize_t) image->columns)
268 p=GetCacheViewVirtualPixels(image_view,x,y,image->columns-x,1,
270 q=GetCacheViewAuthenticPixels(floodplane_view,x,y,image->columns-
272 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
274 for ( ; x < (ssize_t) image->columns; x++)
276 if (GetPixelGray(floodplane_image,q) != 0)
278 GetPixelInfoPixel(image,p,&pixel);
279 if (IsFuzzyEquivalencePixelInfo(&pixel,target) == invert)
281 SetPixelGray(floodplane_image,QuantumRange,q);
282 p+=GetPixelChannels(image);
283 q+=GetPixelChannels(floodplane_image);
285 status=SyncCacheViewAuthenticPixels(floodplane_view,exception);
286 if (status == MagickFalse)
289 PushSegmentStack(y,start,x-1,offset);
291 PushSegmentStack(y,x2+1,x-1,-offset);
297 p=GetCacheViewVirtualPixels(image_view,x,y,(size_t) (x2-x+1),1,
299 q=GetCacheViewAuthenticPixels(floodplane_view,x,y,(size_t) (x2-x+1),1,
301 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
303 for ( ; x <= x2; x++)
305 if (GetPixelGray(floodplane_image,q) != 0)
307 GetPixelInfoPixel(image,p,&pixel);
308 if (IsFuzzyEquivalencePixelInfo(&pixel,target) != invert)
310 p+=GetPixelChannels(image);
311 q+=GetPixelChannels(floodplane_image);
317 for (y=0; y < (ssize_t) image->rows; y++)
319 register const Quantum
329 Tile fill color onto floodplane.
331 p=GetCacheViewVirtualPixels(floodplane_view,0,y,image->columns,1,exception);
332 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
333 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
335 for (x=0; x < (ssize_t) image->columns; x++)
337 if (GetPixelGray(floodplane_image,p) != 0)
339 (void) GetFillColor(draw_info,x,y,&fill_color,exception);
340 SetPixelInfoPixel(image,&fill_color,q);
342 p+=GetPixelChannels(floodplane_image);
343 q+=GetPixelChannels(image);
345 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
348 floodplane_view=DestroyCacheView(floodplane_view);
349 image_view=DestroyCacheView(image_view);
350 segment_stack=(SegmentInfo *) RelinquishMagickMemory(segment_stack);
351 floodplane_image=DestroyImage(floodplane_image);
352 return(y == (ssize_t) image->rows ? MagickTrue : MagickFalse);
356 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
360 + G r a d i e n t I m a g e %
364 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
366 % GradientImage() applies a continuously smooth color transitions along a
367 % vector from one color to another.
369 % Note, the interface of this method will change in the future to support
370 % more than one transistion.
372 % The format of the GradientImage method is:
374 % MagickBooleanType GradientImage(Image *image,const GradientType type,
375 % const SpreadMethod method,const PixelInfo *start_color,
376 % const PixelInfo *stop_color,ExceptionInfo *exception)
378 % A description of each parameter follows:
380 % o image: the image.
382 % o type: the gradient type: linear or radial.
384 % o spread: the gradient spread meathod: pad, reflect, or repeat.
386 % o start_color: the start color.
388 % o stop_color: the stop color.
390 % o exception: return any errors or warnings in this structure.
394 static inline double MagickMax(const double x,const double y)
396 return(x > y ? x : y);
399 MagickExport MagickBooleanType GradientImage(Image *image,
400 const GradientType type,const SpreadMethod method,
401 const PixelInfo *start_color,const PixelInfo *stop_color,
402 ExceptionInfo *exception)
417 Set gradient start-stop end points.
419 assert(image != (const Image *) NULL);
420 assert(image->signature == MagickSignature);
421 if (image->debug != MagickFalse)
422 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
423 assert(start_color != (const PixelInfo *) NULL);
424 assert(stop_color != (const PixelInfo *) NULL);
425 draw_info=AcquireDrawInfo();
426 gradient=(&draw_info->gradient);
428 gradient->bounding_box.width=image->columns;
429 gradient->bounding_box.height=image->rows;
430 gradient->gradient_vector.x2=(double) image->columns-1.0;
431 gradient->gradient_vector.y2=(double) image->rows-1.0;
432 if ((type == LinearGradient) && (gradient->gradient_vector.y2 != 0.0))
433 gradient->gradient_vector.x2=0.0;
434 gradient->center.x=(double) gradient->gradient_vector.x2/2.0;
435 gradient->center.y=(double) gradient->gradient_vector.y2/2.0;
436 gradient->radius=MagickMax(gradient->center.x,gradient->center.y);
437 gradient->spread=method;
439 Define the gradient to fill between the stops.
441 gradient->number_stops=2;
442 gradient->stops=(StopInfo *) AcquireQuantumMemory(gradient->number_stops,
443 sizeof(*gradient->stops));
444 if (gradient->stops == (StopInfo *) NULL)
445 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
447 (void) ResetMagickMemory(gradient->stops,0,gradient->number_stops*
448 sizeof(*gradient->stops));
449 for (i=0; i < (ssize_t) gradient->number_stops; i++)
450 GetPixelInfo(image,&gradient->stops[i].color);
451 gradient->stops[0].color=(*start_color);
452 gradient->stops[0].offset=0.0;
453 gradient->stops[1].color=(*stop_color);
454 gradient->stops[1].offset=1.0;
456 Draw a gradient on the image.
458 (void) SetImageColorspace(image,start_color->colorspace,exception);
459 status=DrawGradientImage(image,draw_info,exception);
460 draw_info=DestroyDrawInfo(draw_info);
465 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
469 % O i l P a i n t I m a g e %
473 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
475 % OilPaintImage() applies a special effect filter that simulates an oil
476 % painting. Each pixel is replaced by the most frequent color occurring
477 % in a circular region defined by radius.
479 % The format of the OilPaintImage method is:
481 % Image *OilPaintImage(const Image *image,const double radius,
482 % const double sigma,ExceptionInfo *exception)
484 % A description of each parameter follows:
486 % o image: the image.
488 % o radius: the radius of the circular neighborhood.
490 % o sigma: the standard deviation of the Gaussian, in pixels.
492 % o exception: return any errors or warnings in this structure.
496 static size_t **DestroyHistogramThreadSet(size_t **histogram)
501 assert(histogram != (size_t **) NULL);
502 for (i=0; i < (ssize_t) GetMagickResourceLimit(ThreadResource); i++)
503 if (histogram[i] != (size_t *) NULL)
504 histogram[i]=(size_t *) RelinquishMagickMemory(histogram[i]);
505 histogram=(size_t **) RelinquishMagickMemory(histogram);
509 static size_t **AcquireHistogramThreadSet(const size_t count)
518 number_threads=(size_t) GetMagickResourceLimit(ThreadResource);
519 histogram=(size_t **) AcquireQuantumMemory(number_threads,sizeof(*histogram));
520 if (histogram == (size_t **) NULL)
521 return((size_t **) NULL);
522 (void) ResetMagickMemory(histogram,0,number_threads*sizeof(*histogram));
523 for (i=0; i < (ssize_t) number_threads; i++)
525 histogram[i]=(size_t *) AcquireQuantumMemory(count,sizeof(**histogram));
526 if (histogram[i] == (size_t *) NULL)
527 return(DestroyHistogramThreadSet(histogram));
532 MagickExport Image *OilPaintImage(const Image *image,const double radius,
533 const double sigma,ExceptionInfo *exception)
535 #define NumberPaintBins 256
536 #define OilPaintImageTag "OilPaint/Image"
560 Initialize painted image attributes.
562 assert(image != (const Image *) NULL);
563 assert(image->signature == MagickSignature);
564 if (image->debug != MagickFalse)
565 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
566 assert(exception != (ExceptionInfo *) NULL);
567 assert(exception->signature == MagickSignature);
568 width=GetOptimalKernelWidth2D(radius,sigma);
569 paint_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception);
570 if (paint_image == (Image *) NULL)
571 return((Image *) NULL);
572 if (SetImageStorageClass(paint_image,DirectClass,exception) == MagickFalse)
574 paint_image=DestroyImage(paint_image);
575 return((Image *) NULL);
577 histograms=AcquireHistogramThreadSet(NumberPaintBins);
578 if (histograms == (size_t **) NULL)
580 paint_image=DestroyImage(paint_image);
581 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
588 center=(ssize_t) GetPixelChannels(image)*(image->columns+width)*(width/2L)+
589 GetPixelChannels(image)*(width/2L);
590 image_view=AcquireVirtualCacheView(image,exception);
591 paint_view=AcquireAuthenticCacheView(paint_image,exception);
592 #if defined(MAGICKCORE_OPENMP_SUPPORT)
593 #pragma omp parallel for schedule(static,4) shared(progress,status) \
594 dynamic_number_threads(image,image->columns,image->rows,1)
596 for (y=0; y < (ssize_t) image->rows; y++)
598 register const Quantum
610 if (status == MagickFalse)
612 p=GetCacheViewVirtualPixels(image_view,-((ssize_t) width/2L),y-(ssize_t)
613 (width/2L),image->columns+width,width,exception);
614 q=QueueCacheViewAuthenticPixels(paint_view,0,y,paint_image->columns,1,
616 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
621 histogram=histograms[GetOpenMPThreadId()];
622 for (x=0; x < (ssize_t) image->columns; x++)
638 Assign most frequent color.
643 (void) ResetMagickMemory(histogram,0,NumberPaintBins* sizeof(*histogram));
644 for (v=0; v < (ssize_t) width; v++)
646 for (u=0; u < (ssize_t) width; u++)
648 n=(ssize_t) ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,
649 p+GetPixelChannels(image)*(u+k))));
651 if (histogram[n] > count)
657 k+=(ssize_t) (image->columns+width);
659 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
668 channel=GetPixelChannelChannel(image,i);
669 traits=GetPixelChannelTraits(image,channel);
670 paint_traits=GetPixelChannelTraits(paint_image,channel);
671 if ((traits == UndefinedPixelTrait) ||
672 (paint_traits == UndefinedPixelTrait))
674 if (((paint_traits & CopyPixelTrait) != 0) ||
675 (GetPixelMask(image,p) != 0))
677 SetPixelChannel(paint_image,channel,p[center+i],q);
680 SetPixelChannel(paint_image,channel,p[j*GetPixelChannels(image)+i],q);
682 p+=GetPixelChannels(image);
683 q+=GetPixelChannels(paint_image);
685 if (SyncCacheViewAuthenticPixels(paint_view,exception) == MagickFalse)
687 if (image->progress_monitor != (MagickProgressMonitor) NULL)
692 #if defined(MAGICKCORE_OPENMP_SUPPORT)
693 #pragma omp critical (MagickCore_OilPaintImage)
695 proceed=SetImageProgress(image,OilPaintImageTag,progress++,image->rows);
696 if (proceed == MagickFalse)
700 paint_view=DestroyCacheView(paint_view);
701 image_view=DestroyCacheView(image_view);
702 histograms=DestroyHistogramThreadSet(histograms);
703 if (status == MagickFalse)
704 paint_image=DestroyImage(paint_image);
709 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
713 % O p a q u e P a i n t I m a g e %
717 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
719 % OpaquePaintImage() changes any pixel that matches color with the color
722 % By default color must match a particular pixel color exactly. However, in
723 % many cases two colors may differ by a small amount. Fuzz defines how much
724 % tolerance is acceptable to consider two colors as the same. For example,
725 % set fuzz to 10 and the color red at intensities of 100 and 102 respectively
726 % are now interpreted as the same color.
728 % The format of the OpaquePaintImage method is:
730 % MagickBooleanType OpaquePaintImage(Image *image,
731 % const PixelInfo *target,const PixelInfo *fill,
732 % const MagickBooleanType invert,ExceptionInfo *exception)
734 % A description of each parameter follows:
736 % o image: the image.
738 % o target: the RGB value of the target color.
740 % o fill: the replacement color.
742 % o invert: paint any pixel that does not match the target color.
744 % o exception: return any errors or warnings in this structure.
747 MagickExport MagickBooleanType OpaquePaintImage(Image *image,
748 const PixelInfo *target,const PixelInfo *fill,const MagickBooleanType invert,
749 ExceptionInfo *exception)
751 #define OpaquePaintImageTag "Opaque/Image"
768 assert(image != (Image *) NULL);
769 assert(image->signature == MagickSignature);
770 assert(target != (PixelInfo *) NULL);
771 assert(fill != (PixelInfo *) NULL);
772 if (image->debug != MagickFalse)
773 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
774 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
776 if ((IsGrayColorspace(image->colorspace) != MagickFalse) &&
777 (IsPixelInfoGray(fill) == MagickFalse))
778 (void) TransformImageColorspace(image,RGBColorspace,exception);
779 if ((fill->alpha_trait == BlendPixelTrait) && (image->alpha_trait != BlendPixelTrait))
780 (void) SetImageAlpha(image,OpaqueAlpha,exception);
782 Make image color opaque.
786 GetPixelInfo(image,&zero);
787 image_view=AcquireAuthenticCacheView(image,exception);
788 #if defined(MAGICKCORE_OPENMP_SUPPORT)
789 #pragma omp parallel for schedule(static,4) shared(progress,status) \
790 dynamic_number_threads(image,image->columns,image->rows,1)
792 for (y=0; y < (ssize_t) image->rows; y++)
803 if (status == MagickFalse)
805 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
806 if (q == (Quantum *) NULL)
812 for (x=0; x < (ssize_t) image->columns; x++)
814 GetPixelInfoPixel(image,q,&pixel);
815 if (IsFuzzyEquivalencePixelInfo(&pixel,target) != invert)
816 SetPixelInfoPixel(image,fill,q);
817 q+=GetPixelChannels(image);
819 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
821 if (image->progress_monitor != (MagickProgressMonitor) NULL)
826 #if defined(MAGICKCORE_OPENMP_SUPPORT)
827 #pragma omp critical (MagickCore_OpaquePaintImage)
829 proceed=SetImageProgress(image,OpaquePaintImageTag,progress++,
831 if (proceed == MagickFalse)
835 image_view=DestroyCacheView(image_view);
840 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
844 % T r a n s p a r e n t P a i n t I m a g e %
848 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
850 % TransparentPaintImage() changes the opacity value associated with any pixel
851 % that matches color to the value defined by opacity.
853 % By default color must match a particular pixel color exactly. However, in
854 % many cases two colors may differ by a small amount. Fuzz defines how much
855 % tolerance is acceptable to consider two colors as the same. For example,
856 % set fuzz to 10 and the color red at intensities of 100 and 102 respectively
857 % are now interpreted as the same color.
859 % The format of the TransparentPaintImage method is:
861 % MagickBooleanType TransparentPaintImage(Image *image,
862 % const PixelInfo *target,const Quantum opacity,
863 % const MagickBooleanType invert,ExceptionInfo *exception)
865 % A description of each parameter follows:
867 % o image: the image.
869 % o target: the target color.
871 % o opacity: the replacement opacity value.
873 % o invert: paint any pixel that does not match the target color.
875 % o exception: return any errors or warnings in this structure.
878 MagickExport MagickBooleanType TransparentPaintImage(Image *image,
879 const PixelInfo *target,const Quantum opacity,const MagickBooleanType invert,
880 ExceptionInfo *exception)
882 #define TransparentPaintImageTag "Transparent/Image"
899 assert(image != (Image *) NULL);
900 assert(image->signature == MagickSignature);
901 assert(target != (PixelInfo *) NULL);
902 if (image->debug != MagickFalse)
903 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
904 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
906 if (image->alpha_trait != BlendPixelTrait)
907 (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
909 Make image color transparent.
913 GetPixelInfo(image,&zero);
914 image_view=AcquireAuthenticCacheView(image,exception);
915 #if defined(MAGICKCORE_OPENMP_SUPPORT)
916 #pragma omp parallel for schedule(static,4) shared(progress,status) \
917 dynamic_number_threads(image,image->columns,image->rows,1)
919 for (y=0; y < (ssize_t) image->rows; y++)
930 if (status == MagickFalse)
932 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
933 if (q == (Quantum *) NULL)
939 for (x=0; x < (ssize_t) image->columns; x++)
941 GetPixelInfoPixel(image,q,&pixel);
942 if (IsFuzzyEquivalencePixelInfo(&pixel,target) != invert)
943 SetPixelAlpha(image,opacity,q);
944 q+=GetPixelChannels(image);
946 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
948 if (image->progress_monitor != (MagickProgressMonitor) NULL)
953 #if defined(MAGICKCORE_OPENMP_SUPPORT)
954 #pragma omp critical (MagickCore_TransparentPaintImage)
956 proceed=SetImageProgress(image,TransparentPaintImageTag,progress++,
958 if (proceed == MagickFalse)
962 image_view=DestroyCacheView(image_view);
967 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
971 % T r a n s p a r e n t P a i n t I m a g e C h r o m a %
975 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
977 % TransparentPaintImageChroma() changes the opacity value associated with any
978 % pixel that matches color to the value defined by opacity.
980 % As there is one fuzz value for the all the channels, TransparentPaintImage()
981 % is not suitable for the operations like chroma, where the tolerance for
982 % similarity of two color component (RGB) can be different. Thus we define
983 % this method to take two target pixels (one low and one high) and all the
984 % pixels of an image which are lying between these two pixels are made
987 % The format of the TransparentPaintImageChroma method is:
989 % MagickBooleanType TransparentPaintImageChroma(Image *image,
990 % const PixelInfo *low,const PixelInfo *high,const Quantum opacity,
991 % const MagickBooleanType invert,ExceptionInfo *exception)
993 % A description of each parameter follows:
995 % o image: the image.
997 % o low: the low target color.
999 % o high: the high target color.
1001 % o opacity: the replacement opacity value.
1003 % o invert: paint any pixel that does not match the target color.
1005 % o exception: return any errors or warnings in this structure.
1008 MagickExport MagickBooleanType TransparentPaintImageChroma(Image *image,
1009 const PixelInfo *low,const PixelInfo *high,const Quantum opacity,
1010 const MagickBooleanType invert,ExceptionInfo *exception)
1012 #define TransparentPaintImageTag "Transparent/Image"
1026 assert(image != (Image *) NULL);
1027 assert(image->signature == MagickSignature);
1028 assert(high != (PixelInfo *) NULL);
1029 assert(low != (PixelInfo *) NULL);
1030 if (image->debug != MagickFalse)
1031 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1032 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
1033 return(MagickFalse);
1034 if (image->alpha_trait != BlendPixelTrait)
1035 (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
1037 Make image color transparent.
1041 image_view=AcquireAuthenticCacheView(image,exception);
1042 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1043 #pragma omp parallel for schedule(static,4) shared(progress,status) \
1044 dynamic_number_threads(image,image->columns,image->rows,1)
1046 for (y=0; y < (ssize_t) image->rows; y++)
1060 if (status == MagickFalse)
1062 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
1063 if (q == (Quantum *) NULL)
1068 GetPixelInfo(image,&pixel);
1069 for (x=0; x < (ssize_t) image->columns; x++)
1071 GetPixelInfoPixel(image,q,&pixel);
1072 match=((pixel.red >= low->red) && (pixel.red <= high->red) &&
1073 (pixel.green >= low->green) && (pixel.green <= high->green) &&
1074 (pixel.blue >= low->blue) && (pixel.blue <= high->blue)) ? MagickTrue :
1076 if (match != invert)
1077 SetPixelAlpha(image,opacity,q);
1078 q+=GetPixelChannels(image);
1080 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
1082 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1087 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1088 #pragma omp critical (MagickCore_TransparentPaintImageChroma)
1090 proceed=SetImageProgress(image,TransparentPaintImageTag,progress++,
1092 if (proceed == MagickFalse)
1096 image_view=DestroyCacheView(image_view);