granicus.if.org Git - imagemagick/blob - MagickCore/paint.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                      PPPP    AAA   IIIII  N   N  TTTTT                      %
   7 %                      P   P  A   A    I    NN  N    T                        %
   8 %                      PPPP   AAAAA    I    N N N    T                        %
   9 %                      P      A   A    I    N  NN    T                        %
  10 %                      P      A   A  IIIII  N   N    T                        %
  11 %                                                                             %
  12 %                                                                             %
  13 %                        Methods to Paint on an Image                         %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                John Cristy                                  %
  17 %                                 July 1998                                   %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2012 ImageMagick Studio LLC, a non-profit organization      %
  21 %  dedicated to making software imaging solutions freely available.           %
  22 %                                                                             %
  23 %  You may not use this file except in compliance with the License.  You may  %
  24 %  obtain a copy of the License at                                            %
  25 %                                                                             %
  26 %    http://www.imagemagick.org/script/license.php                            %
  27 %                                                                             %
  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.                                             %
  33 %                                                                             %
  34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  35 %
  36 %
  37 */
  38 \f
  39 /*
  40  Include declarations.
  41 */
  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"
  62 \f
  63 /*
  64 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  65 %                                                                             %
  66 %                                                                             %
  67 %                                                                             %
  68 %   F l o o d f i l l P a i n t I m a g e                                     %
  69 %                                                                             %
  70 %                                                                             %
  71 %                                                                             %
  72 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  73 %
  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.
  78 %
  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.
  85 %
  86 %  The format of the FloodfillPaintImage method is:
  87 %
  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)
  92 %
  93 %  A description of each parameter follows:
  94 %
  95 %    o image: the image.
  96 %
  97 %    o draw_info: the draw info.
  98 %
  99 %    o target: the RGB value of the target color.
 100 %
 101 %    o x_offset,y_offset: the starting location of the operation.
 102 %
 103 %    o invert: paint any pixel that does not match the target color.
 104 %
 105 %    o exception: return any errors or warnings in this structure.
 106 %
 107 */
 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)
 112 {
 113 #define MaxStacksize  (1UL << 15)
 114 #define PushSegmentStack(up,left,right,delta) \
 115 { \
 116   if (s >= (segment_stack+MaxStacksize)) \
 117     ThrowBinaryException(DrawError,"SegmentStackOverflow",image->filename) \
 118   else \
 119     { \
 120       if ((((up)+(delta)) >= 0) && (((up)+(delta)) < (ssize_t) image->rows)) \
 121         { \
 122           s->x1=(double) (left); \
 123           s->y1=(double) (up); \
 124           s->x2=(double) (right); \
 125           s->y2=(double) (delta); \
 126           s++; \
 127         } \
 128     } \
 129 }
 130
 131   CacheView
 132     *floodplane_view,
 133     *image_view;
 134
 135   Image
 136     *floodplane_image;
 137
 138   MagickBooleanType
 139     skip,
 140     status;
 141
 142   PixelInfo
 143     fill_color,
 144     pixel;
 145
 146   register SegmentInfo
 147     *s;
 148
 149   SegmentInfo
 150     *segment_stack;
 151
 152   ssize_t
 153     offset,
 154     start,
 155     x,
 156     x1,
 157     x2,
 158     y;
 159
 160   /*
 161     Check boundary conditions.
 162   */
 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))
 170     return(MagickFalse);
 171   if ((y_offset < 0) || (y_offset >= (ssize_t) image->rows))
 172     return(MagickFalse);
 173   if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
 174     return(MagickFalse);
 175   if (IsGrayColorspace(image->colorspace) != MagickFalse)
 176     (void) TransformImageColorspace(image,RGBColorspace,exception);
 177   if ((image->matte == MagickFalse) && (draw_info->fill.matte != MagickFalse))
 178     (void) SetImageAlpha(image,OpaqueAlpha,exception);
 179   /*
 180     Set floodfill state.
 181   */
 182   floodplane_image=CloneImage(image,image->columns,image->rows,MagickTrue,
 183     exception);
 184   if (floodplane_image == (Image *) NULL)
 185     return(MagickFalse);
 186   floodplane_image->matte=MagickFalse;
 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)
 194     {
 195       floodplane_image=DestroyImage(floodplane_image);
 196       ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
 197         image->filename);
 198     }
 199   /*
 200     Push initial segment on stack.
 201   */
 202   status=MagickTrue;
 203   x=x_offset;
 204   y=y_offset;
 205   start=0;
 206   s=segment_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)
 213   {
 214     register const Quantum
 215       *restrict p;
 216
 217     register Quantum
 218       *restrict q;
 219
 220     register ssize_t
 221       x;
 222
 223     /*
 224       Pop segment off stack.
 225     */
 226     s--;
 227     x1=(ssize_t) s->x1;
 228     x2=(ssize_t) s->x2;
 229     offset=(ssize_t) s->y2;
 230     y=(ssize_t) s->y1+offset;
 231     /*
 232       Recolor neighboring pixels.
 233     */
 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,
 236       exception);
 237     if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
 238       break;
 239     p+=x1*GetPixelChannels(image);
 240     q+=x1*GetPixelChannels(floodplane_image);
 241     for (x=x1; x >= 0; x--)
 242     {
 243       if (GetPixelGray(floodplane_image,q) != 0)
 244         break;
 245       GetPixelInfoPixel(image,p,&pixel);
 246       if (IsFuzzyEquivalencePixelInfo(&pixel,target) == invert)
 247         break;
 248       SetPixelGray(floodplane_image,QuantumRange,q);
 249       p-=GetPixelChannels(image);
 250       q-=GetPixelChannels(floodplane_image);
 251     }
 252     if (SyncCacheViewAuthenticPixels(floodplane_view,exception) == MagickFalse)
 253       break;
 254     skip=x >= x1 ? MagickTrue : MagickFalse;
 255     if (skip == MagickFalse)
 256       {
 257         start=x+1;
 258         if (start < x1)
 259           PushSegmentStack(y,start,x1-1,-offset);
 260         x=x1+1;
 261       }
 262     do
 263     {
 264       if (skip == MagickFalse)
 265         {
 266           if (x < (ssize_t) image->columns)
 267             {
 268               p=GetCacheViewVirtualPixels(image_view,x,y,image->columns-x,1,
 269                 exception);
 270               q=GetCacheViewAuthenticPixels(floodplane_view,x,y,image->columns-
 271                 x,1,exception);
 272               if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
 273                 break;
 274               for ( ; x < (ssize_t) image->columns; x++)
 275               {
 276                 if (GetPixelGray(floodplane_image,q) != 0)
 277                   break;
 278                 GetPixelInfoPixel(image,p,&pixel);
 279                 if (IsFuzzyEquivalencePixelInfo(&pixel,target) == invert)
 280                   break;
 281                 SetPixelGray(floodplane_image,QuantumRange,q);
 282                 p+=GetPixelChannels(image);
 283                 q+=GetPixelChannels(floodplane_image);
 284               }
 285               status=SyncCacheViewAuthenticPixels(floodplane_view,exception);
 286               if (status == MagickFalse)
 287                 break;
 288             }
 289           PushSegmentStack(y,start,x-1,offset);
 290           if (x > (x2+1))
 291             PushSegmentStack(y,x2+1,x-1,-offset);
 292         }
 293       skip=MagickFalse;
 294       x++;
 295       if (x <= x2)
 296         {
 297           p=GetCacheViewVirtualPixels(image_view,x,y,(size_t) (x2-x+1),1,
 298             exception);
 299           q=GetCacheViewAuthenticPixels(floodplane_view,x,y,(size_t) (x2-x+1),1,
 300             exception);
 301           if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
 302             break;
 303           for ( ; x <= x2; x++)
 304           {
 305             if (GetPixelGray(floodplane_image,q) != 0)
 306               break;
 307             GetPixelInfoPixel(image,p,&pixel);
 308             if (IsFuzzyEquivalencePixelInfo(&pixel,target) != invert)
 309               break;
 310             p+=GetPixelChannels(image);
 311             q+=GetPixelChannels(floodplane_image);
 312           }
 313         }
 314       start=x;
 315     } while (x <= x2);
 316   }
 317   for (y=0; y < (ssize_t) image->rows; y++)
 318   {
 319     register const Quantum
 320       *restrict p;
 321
 322     register Quantum
 323       *restrict q;
 324
 325     register ssize_t
 326       x;
 327
 328     /*
 329       Tile fill color onto floodplane.
 330     */
 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))
 334       break;
 335     for (x=0; x < (ssize_t) image->columns; x++)
 336     {
 337       if (GetPixelGray(floodplane_image,p) != 0)
 338         {
 339           (void) GetFillColor(draw_info,x,y,&fill_color,exception);
 340           SetPixelInfoPixel(image,&fill_color,q);
 341         }
 342       p+=GetPixelChannels(floodplane_image);
 343       q+=GetPixelChannels(image);
 344     }
 345     if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
 346       break;
 347   }
 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);
 353 }
 354 \f
 355 /*
 356 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 357 %                                                                             %
 358 %                                                                             %
 359 %                                                                             %
 360 +     G r a d i e n t I m a g e                                               %
 361 %                                                                             %
 362 %                                                                             %
 363 %                                                                             %
 364 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 365 %
 366 %  GradientImage() applies a continuously smooth color transitions along a
 367 %  vector from one color to another.
 368 %
 369 %  Note, the interface of this method will change in the future to support
 370 %  more than one transistion.
 371 %
 372 %  The format of the GradientImage method is:
 373 %
 374 %      MagickBooleanType GradientImage(Image *image,const GradientType type,
 375 %        const SpreadMethod method,const PixelInfo *start_color,
 376 %        const PixelInfo *stop_color,ExceptionInfo *exception)
 377 %
 378 %  A description of each parameter follows:
 379 %
 380 %    o image: the image.
 381 %
 382 %    o type: the gradient type: linear or radial.
 383 %
 384 %    o spread: the gradient spread meathod: pad, reflect, or repeat.
 385 %
 386 %    o start_color: the start color.
 387 %
 388 %    o stop_color: the stop color.
 389 %
 390 %    o exception: return any errors or warnings in this structure.
 391 %
 392 */
 393
 394 static inline double MagickMax(const double x,const double y)
 395 {
 396   return(x > y ? x : y);
 397 }
 398
 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)
 403 {
 404   DrawInfo
 405     *draw_info;
 406
 407   GradientInfo
 408     *gradient;
 409
 410   MagickBooleanType
 411     status;
 412
 413   register ssize_t
 414     i;
 415
 416   /*
 417     Set gradient start-stop end points.
 418   */
 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);
 427   gradient->type=type;
 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;
 438   /*
 439     Define the gradient to fill between the stops.
 440   */
 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",
 446       image->filename);
 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;
 455   /*
 456     Draw a gradient on the image.
 457   */
 458   (void) SetImageColorspace(image,start_color->colorspace,exception);
 459   status=DrawGradientImage(image,draw_info,exception);
 460   draw_info=DestroyDrawInfo(draw_info);
 461   return(status);
 462 }
 463 \f
 464 /*
 465 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 466 %                                                                             %
 467 %                                                                             %
 468 %                                                                             %
 469 %     O i l P a i n t I m a g e                                               %
 470 %                                                                             %
 471 %                                                                             %
 472 %                                                                             %
 473 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 474 %
 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.
 478 %
 479 %  The format of the OilPaintImage method is:
 480 %
 481 %      Image *OilPaintImage(const Image *image,const double radius,
 482 %        const double sigma,ExceptionInfo *exception)
 483 %
 484 %  A description of each parameter follows:
 485 %
 486 %    o image: the image.
 487 %
 488 %    o radius: the radius of the circular neighborhood.
 489 %
 490 %    o sigma: the standard deviation of the Gaussian, in pixels.
 491 %
 492 %    o exception: return any errors or warnings in this structure.
 493 %
 494 */
 495
 496 static size_t **DestroyHistogramThreadSet(size_t **histogram)
 497 {
 498   register ssize_t
 499     i;
 500
 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);
 506   return(histogram);
 507 }
 508
 509 static size_t **AcquireHistogramThreadSet(const size_t count)
 510 {
 511   register ssize_t
 512     i;
 513
 514   size_t
 515     **histogram,
 516     number_threads;
 517
 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++)
 524   {
 525     histogram[i]=(size_t *) AcquireQuantumMemory(count,sizeof(**histogram));
 526     if (histogram[i] == (size_t *) NULL)
 527       return(DestroyHistogramThreadSet(histogram));
 528   }
 529   return(histogram);
 530 }
 531
 532 MagickExport Image *OilPaintImage(const Image *image,const double radius,
 533   const double sigma,ExceptionInfo *exception)
 534 {
 535 #define NumberPaintBins  256
 536 #define OilPaintImageTag  "OilPaint/Image"
 537
 538   CacheView
 539     *image_view,
 540     *paint_view;
 541
 542   Image
 543     *paint_image;
 544
 545   MagickBooleanType
 546     status;
 547
 548   MagickOffsetType
 549     progress;
 550
 551   size_t
 552     **histograms,
 553     width;
 554
 555   ssize_t
 556     center,
 557     y;
 558
 559   /*
 560     Initialize painted image attributes.
 561   */
 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)
 573     {
 574       paint_image=DestroyImage(paint_image);
 575       return((Image *) NULL);
 576     }
 577   histograms=AcquireHistogramThreadSet(NumberPaintBins);
 578   if (histograms == (size_t **) NULL)
 579     {
 580       paint_image=DestroyImage(paint_image);
 581       ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
 582     }
 583   /*
 584     Oil paint image.
 585   */
 586   status=MagickTrue;
 587   progress=0;
 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)
 595 #endif
 596   for (y=0; y < (ssize_t) image->rows; y++)
 597   {
 598     register const Quantum
 599       *restrict p;
 600
 601     register Quantum
 602       *restrict q;
 603
 604     register size_t
 605       *histogram;
 606
 607     register ssize_t
 608       x;
 609
 610     if (status == MagickFalse)
 611       continue;
 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,
 615       exception);
 616     if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
 617       {
 618         status=MagickFalse;
 619         continue;
 620       }
 621     histogram=histograms[GetOpenMPThreadId()];
 622     for (x=0; x < (ssize_t) image->columns; x++)
 623     {
 624       register ssize_t
 625         i,
 626         u;
 627
 628       size_t
 629         count;
 630
 631       ssize_t
 632         j,
 633         k,
 634         n,
 635         v;
 636
 637       /*
 638         Assign most frequent color.
 639       */
 640       k=0;
 641       j=0;
 642       count=0;
 643       (void) ResetMagickMemory(histogram,0,NumberPaintBins* sizeof(*histogram));
 644       for (v=0; v < (ssize_t) width; v++)
 645       {
 646         for (u=0; u < (ssize_t) width; u++)
 647         {
 648           n=(ssize_t) ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,
 649             p+GetPixelChannels(image)*(u+k))));
 650           histogram[n]++;
 651           if (histogram[n] > count)
 652             {
 653               j=k+u;
 654               count=histogram[n];
 655             }
 656         }
 657         k+=(ssize_t) (image->columns+width);
 658       }
 659       for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
 660       {
 661         PixelChannel
 662           channel;
 663
 664         PixelTrait
 665           paint_traits,
 666           traits;
 667
 668         channel=GetPixelChannelMapChannel(image,i);
 669         traits=GetPixelChannelMapTraits(image,channel);
 670         paint_traits=GetPixelChannelMapTraits(paint_image,channel);
 671         if ((traits == UndefinedPixelTrait) ||
 672             (paint_traits == UndefinedPixelTrait))
 673           continue;
 674         if (((paint_traits & CopyPixelTrait) != 0) ||
 675             (GetPixelMask(image,p) != 0))
 676           {
 677             SetPixelChannel(paint_image,channel,p[center+i],q);
 678             continue;
 679           }
 680         SetPixelChannel(paint_image,channel,p[j*GetPixelChannels(image)+i],q);
 681       }
 682       p+=GetPixelChannels(image);
 683       q+=GetPixelChannels(paint_image);
 684     }
 685     if (SyncCacheViewAuthenticPixels(paint_view,exception) == MagickFalse)
 686       status=MagickFalse;
 687     if (image->progress_monitor != (MagickProgressMonitor) NULL)
 688       {
 689         MagickBooleanType
 690           proceed;
 691
 692 #if defined(MAGICKCORE_OPENMP_SUPPORT)
 693         #pragma omp critical (MagickCore_OilPaintImage)
 694 #endif
 695         proceed=SetImageProgress(image,OilPaintImageTag,progress++,image->rows);
 696         if (proceed == MagickFalse)
 697           status=MagickFalse;
 698       }
 699   }
 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);
 705   return(paint_image);
 706 }
 707 \f
 708 /*
 709 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 710 %                                                                             %
 711 %                                                                             %
 712 %                                                                             %
 713 %     O p a q u e P a i n t I m a g e                                         %
 714 %                                                                             %
 715 %                                                                             %
 716 %                                                                             %
 717 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 718 %
 719 %  OpaquePaintImage() changes any pixel that matches color with the color
 720 %  defined by fill.
 721 %
 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.
 727 %
 728 %  The format of the OpaquePaintImage method is:
 729 %
 730 %      MagickBooleanType OpaquePaintImage(Image *image,
 731 %        const PixelInfo *target,const PixelInfo *fill,
 732 %        const MagickBooleanType invert,ExceptionInfo *exception)
 733 %
 734 %  A description of each parameter follows:
 735 %
 736 %    o image: the image.
 737 %
 738 %    o target: the RGB value of the target color.
 739 %
 740 %    o fill: the replacement color.
 741 %
 742 %    o invert: paint any pixel that does not match the target color.
 743 %
 744 %    o exception: return any errors or warnings in this structure.
 745 %
 746 */
 747 MagickExport MagickBooleanType OpaquePaintImage(Image *image,
 748   const PixelInfo *target,const PixelInfo *fill,const MagickBooleanType invert,
 749   ExceptionInfo *exception)
 750 {
 751 #define OpaquePaintImageTag  "Opaque/Image"
 752
 753   CacheView
 754     *image_view;
 755
 756   MagickBooleanType
 757     status;
 758
 759   MagickOffsetType
 760     progress;
 761
 762   PixelInfo
 763     zero;
 764
 765   ssize_t
 766     y;
 767
 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)
 775     return(MagickFalse);
 776   if ((IsGrayColorspace(image->colorspace) != MagickFalse) &&
 777       (IsPixelInfoGray(fill) == MagickFalse))
 778     (void) TransformImageColorspace(image,RGBColorspace,exception);
 779   if ((fill->matte != MagickFalse) && (image->matte == MagickFalse))
 780     (void) SetImageAlpha(image,OpaqueAlpha,exception);
 781   /*
 782     Make image color opaque.
 783   */
 784   status=MagickTrue;
 785   progress=0;
 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)
 791 #endif
 792   for (y=0; y < (ssize_t) image->rows; y++)
 793   {
 794     PixelInfo
 795       pixel;
 796
 797     register Quantum
 798       *restrict q;
 799
 800     register ssize_t
 801       x;
 802
 803     if (status == MagickFalse)
 804       continue;
 805     q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
 806     if (q == (Quantum *) NULL)
 807       {
 808         status=MagickFalse;
 809         continue;
 810       }
 811     pixel=zero;
 812     for (x=0; x < (ssize_t) image->columns; x++)
 813     {
 814       GetPixelInfoPixel(image,q,&pixel);
 815       if (IsFuzzyEquivalencePixelInfo(&pixel,target) != invert)
 816         SetPixelInfoPixel(image,fill,q);
 817       q+=GetPixelChannels(image);
 818     }
 819     if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
 820       status=MagickFalse;
 821     if (image->progress_monitor != (MagickProgressMonitor) NULL)
 822       {
 823         MagickBooleanType
 824           proceed;
 825
 826 #if defined(MAGICKCORE_OPENMP_SUPPORT)
 827         #pragma omp critical (MagickCore_OpaquePaintImage)
 828 #endif
 829         proceed=SetImageProgress(image,OpaquePaintImageTag,progress++,
 830           image->rows);
 831         if (proceed == MagickFalse)
 832           status=MagickFalse;
 833       }
 834   }
 835   image_view=DestroyCacheView(image_view);
 836   return(status);
 837 }
 838 \f
 839 /*
 840 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 841 %                                                                             %
 842 %                                                                             %
 843 %                                                                             %
 844 %     T r a n s p a r e n t P a i n t I m a g e                               %
 845 %                                                                             %
 846 %                                                                             %
 847 %                                                                             %
 848 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 849 %
 850 %  TransparentPaintImage() changes the opacity value associated with any pixel
 851 %  that matches color to the value defined by opacity.
 852 %
 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.
 858 %
 859 %  The format of the TransparentPaintImage method is:
 860 %
 861 %      MagickBooleanType TransparentPaintImage(Image *image,
 862 %        const PixelInfo *target,const Quantum opacity,
 863 %        const MagickBooleanType invert,ExceptionInfo *exception)
 864 %
 865 %  A description of each parameter follows:
 866 %
 867 %    o image: the image.
 868 %
 869 %    o target: the target color.
 870 %
 871 %    o opacity: the replacement opacity value.
 872 %
 873 %    o invert: paint any pixel that does not match the target color.
 874 %
 875 %    o exception: return any errors or warnings in this structure.
 876 %
 877 */
 878 MagickExport MagickBooleanType TransparentPaintImage(Image *image,
 879   const PixelInfo *target,const Quantum opacity,const MagickBooleanType invert,
 880   ExceptionInfo *exception)
 881 {
 882 #define TransparentPaintImageTag  "Transparent/Image"
 883
 884   CacheView
 885     *image_view;
 886
 887   MagickBooleanType
 888     status;
 889
 890   MagickOffsetType
 891     progress;
 892
 893   PixelInfo
 894     zero;
 895
 896   ssize_t
 897     y;
 898
 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)
 905     return(MagickFalse);
 906   if (image->matte == MagickFalse)
 907     (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
 908   /*
 909     Make image color transparent.
 910   */
 911   status=MagickTrue;
 912   progress=0;
 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)
 918 #endif
 919   for (y=0; y < (ssize_t) image->rows; y++)
 920   {
 921     PixelInfo
 922       pixel;
 923
 924     register ssize_t
 925       x;
 926
 927     register Quantum
 928       *restrict q;
 929
 930     if (status == MagickFalse)
 931       continue;
 932     q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
 933     if (q == (Quantum *) NULL)
 934       {
 935         status=MagickFalse;
 936         continue;
 937       }
 938     pixel=zero;
 939     for (x=0; x < (ssize_t) image->columns; x++)
 940     {
 941       GetPixelInfoPixel(image,q,&pixel);
 942       if (IsFuzzyEquivalencePixelInfo(&pixel,target) != invert)
 943         SetPixelAlpha(image,opacity,q);
 944       q+=GetPixelChannels(image);
 945     }
 946     if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
 947       status=MagickFalse;
 948     if (image->progress_monitor != (MagickProgressMonitor) NULL)
 949       {
 950         MagickBooleanType
 951           proceed;
 952
 953 #if defined(MAGICKCORE_OPENMP_SUPPORT)
 954         #pragma omp critical (MagickCore_TransparentPaintImage)
 955 #endif
 956         proceed=SetImageProgress(image,TransparentPaintImageTag,progress++,
 957           image->rows);
 958         if (proceed == MagickFalse)
 959           status=MagickFalse;
 960       }
 961   }
 962   image_view=DestroyCacheView(image_view);
 963   return(status);
 964 }
 965 \f
 966 /*
 967 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 968 %                                                                             %
 969 %                                                                             %
 970 %                                                                             %
 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                   %
 972 %                                                                             %
 973 %                                                                             %
 974 %                                                                             %
 975 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 976 %
 977 %  TransparentPaintImageChroma() changes the opacity value associated with any
 978 %  pixel that matches color to the value defined by opacity.
 979 %
 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
 985 %  transparent.
 986 %
 987 %  The format of the TransparentPaintImageChroma method is:
 988 %
 989 %      MagickBooleanType TransparentPaintImageChroma(Image *image,
 990 %        const PixelInfo *low,const PixelInfo *high,const Quantum opacity,
 991 %        const MagickBooleanType invert,ExceptionInfo *exception)
 992 %
 993 %  A description of each parameter follows:
 994 %
 995 %    o image: the image.
 996 %
 997 %    o low: the low target color.
 998 %
 999 %    o high: the high target color.
1000 %
1001 %    o opacity: the replacement opacity value.
1002 %
1003 %    o invert: paint any pixel that does not match the target color.
1004 %
1005 %    o exception: return any errors or warnings in this structure.
1006 %
1007 */
1008 MagickExport MagickBooleanType TransparentPaintImageChroma(Image *image,
1009   const PixelInfo *low,const PixelInfo *high,const Quantum opacity,
1010   const MagickBooleanType invert,ExceptionInfo *exception)
1011 {
1012 #define TransparentPaintImageTag  "Transparent/Image"
1013
1014   CacheView
1015     *image_view;
1016
1017   MagickBooleanType
1018     status;
1019
1020   MagickOffsetType
1021     progress;
1022
1023   ssize_t
1024     y;
1025
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->matte == MagickFalse)
1035     (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
1036   /*
1037     Make image color transparent.
1038   */
1039   status=MagickTrue;
1040   progress=0;
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)
1045 #endif
1046   for (y=0; y < (ssize_t) image->rows; y++)
1047   {
1048     MagickBooleanType
1049       match;
1050
1051     PixelInfo
1052       pixel;
1053
1054     register Quantum
1055       *restrict q;
1056
1057     register ssize_t
1058       x;
1059
1060     if (status == MagickFalse)
1061       continue;
1062     q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
1063     if (q == (Quantum *) NULL)
1064       {
1065         status=MagickFalse;
1066         continue;
1067       }
1068     GetPixelInfo(image,&pixel);
1069     for (x=0; x < (ssize_t) image->columns; x++)
1070     {
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 :
1075         MagickFalse;
1076       if (match != invert)
1077         SetPixelAlpha(image,opacity,q);
1078       q+=GetPixelChannels(image);
1079     }
1080     if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
1081       status=MagickFalse;
1082     if (image->progress_monitor != (MagickProgressMonitor) NULL)
1083       {
1084         MagickBooleanType
1085           proceed;
1086
1087 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1088         #pragma omp critical (MagickCore_TransparentPaintImageChroma)
1089 #endif
1090         proceed=SetImageProgress(image,TransparentPaintImageTag,progress++,
1091           image->rows);
1092         if (proceed == MagickFalse)
1093           status=MagickFalse;
1094       }
1095   }
1096   image_view=DestroyCacheView(image_view);
1097   return(status);
1098 }