2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6 % DDDD EEEEE CCCC OOO RRRR AAA TTTTT EEEEE %
7 % D D E C O O R R A A T E %
8 % D D EEE C O O RRRR AAAAA T EEE %
9 % D D E C O O R R A A T E %
10 % DDDD EEEEE CCCC OOO R R A A T EEEEE %
13 % MagickCore Image Decoration Methods %
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 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
43 #include "MagickCore/studio.h"
44 #include "MagickCore/cache-view.h"
45 #include "MagickCore/color-private.h"
46 #include "MagickCore/colorspace-private.h"
47 #include "MagickCore/composite.h"
48 #include "MagickCore/decorate.h"
49 #include "MagickCore/exception.h"
50 #include "MagickCore/exception-private.h"
51 #include "MagickCore/image.h"
52 #include "MagickCore/memory_.h"
53 #include "MagickCore/monitor.h"
54 #include "MagickCore/monitor-private.h"
55 #include "MagickCore/pixel-accessor.h"
56 #include "MagickCore/quantum.h"
57 #include "MagickCore/quantum-private.h"
58 #include "MagickCore/thread-private.h"
59 #include "MagickCore/transform.h"
64 #define AccentuateModulate ScaleCharToQuantum(80)
65 #define HighlightModulate ScaleCharToQuantum(125)
66 #define ShadowModulate ScaleCharToQuantum(135)
67 #define DepthModulate ScaleCharToQuantum(185)
68 #define TroughModulate ScaleCharToQuantum(110)
71 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
75 % B o r d e r I m a g e %
79 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
81 % BorderImage() surrounds the image with a border of the color defined by
82 % the bordercolor member of the image structure. The width and height
83 % of the border are defined by the corresponding members of the border_info
86 % The format of the BorderImage method is:
88 % Image *BorderImage(const Image *image,const RectangleInfo *border_info,
89 % const CompositeOperator compose,ExceptionInfo *exception)
91 % A description of each parameter follows:
95 % o border_info: define the width and height of the border.
97 % o compose: the composite operator.
99 % o exception: return any errors or warnings in this structure.
102 MagickExport Image *BorderImage(const Image *image,
103 const RectangleInfo *border_info,const CompositeOperator compose,
104 ExceptionInfo *exception)
113 assert(image != (const Image *) NULL);
114 assert(image->signature == MagickSignature);
115 if (image->debug != MagickFalse)
116 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
117 assert(border_info != (RectangleInfo *) NULL);
118 frame_info.width=image->columns+(border_info->width << 1);
119 frame_info.height=image->rows+(border_info->height << 1);
120 frame_info.x=(ssize_t) border_info->width;
121 frame_info.y=(ssize_t) border_info->height;
122 frame_info.inner_bevel=0;
123 frame_info.outer_bevel=0;
124 clone_image=CloneImage(image,0,0,MagickTrue,exception);
125 if (clone_image == (Image *) NULL)
126 return((Image *) NULL);
127 clone_image->matte_color=image->border_color;
128 border_image=FrameImage(clone_image,&frame_info,compose,exception);
129 clone_image=DestroyImage(clone_image);
130 if (border_image != (Image *) NULL)
131 border_image->matte_color=image->matte_color;
132 return(border_image);
136 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
140 % F r a m e I m a g e %
144 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
146 % FrameImage() adds a simulated three-dimensional border around the image.
147 % The color of the border is defined by the matte_color member of image.
148 % Members width and height of frame_info specify the border width of the
149 % vertical and horizontal sides of the frame. Members inner and outer
150 % indicate the width of the inner and outer shadows of the frame.
152 % The format of the FrameImage method is:
154 % Image *FrameImage(const Image *image,const FrameInfo *frame_info,
155 % const CompositeOperator compose,ExceptionInfo *exception)
157 % A description of each parameter follows:
159 % o image: the image.
161 % o frame_info: Define the width and height of the frame and its bevels.
163 % o compose: the composite operator.
165 % o exception: return any errors or warnings in this structure.
168 MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
169 const CompositeOperator compose,ExceptionInfo *exception)
171 #define FrameImageTag "Frame/Image"
206 Check frame geometry.
208 assert(image != (Image *) NULL);
209 assert(image->signature == MagickSignature);
210 if (image->debug != MagickFalse)
211 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
212 assert(frame_info != (FrameInfo *) NULL);
213 if ((frame_info->outer_bevel < 0) || (frame_info->inner_bevel < 0))
214 ThrowImageException(OptionError,"FrameIsLessThanImageSize");
215 bevel_width=(size_t) (frame_info->outer_bevel+frame_info->inner_bevel);
216 width=frame_info->width-frame_info->x-bevel_width;
217 height=frame_info->height-frame_info->y-bevel_width;
218 if ((width < image->columns) || (height < image->rows))
219 ThrowImageException(OptionError,"FrameIsLessThanImageSize");
221 Initialize framed image attributes.
223 frame_image=CloneImage(image,frame_info->width,frame_info->height,MagickTrue,
225 if (frame_image == (Image *) NULL)
226 return((Image *) NULL);
227 if (SetImageStorageClass(frame_image,DirectClass,exception) == MagickFalse)
229 frame_image=DestroyImage(frame_image);
230 return((Image *) NULL);
232 if (frame_image->matte_color.alpha != OpaqueAlpha)
233 frame_image->matte=MagickTrue;
234 frame_image->page=image->page;
235 if ((image->page.width != 0) && (image->page.height != 0))
237 frame_image->page.width+=frame_image->columns-image->columns;
238 frame_image->page.height+=frame_image->rows-image->rows;
241 Initialize 3D effects color.
243 interior=image->border_color;
244 matte=image->matte_color;
246 accentuate.red=(MagickRealType) (QuantumScale*((QuantumRange-
247 AccentuateModulate)*matte.red+(QuantumRange*AccentuateModulate)));
248 accentuate.green=(MagickRealType) (QuantumScale*((QuantumRange-
249 AccentuateModulate)*matte.green+(QuantumRange*AccentuateModulate)));
250 accentuate.blue=(MagickRealType) (QuantumScale*((QuantumRange-
251 AccentuateModulate)*matte.blue+(QuantumRange*AccentuateModulate)));
252 accentuate.black=(MagickRealType) (QuantumScale*((QuantumRange-
253 AccentuateModulate)*matte.black+(QuantumRange*AccentuateModulate)));
254 accentuate.alpha=matte.alpha;
256 highlight.red=(MagickRealType) (QuantumScale*((QuantumRange-
257 HighlightModulate)*matte.red+(QuantumRange*HighlightModulate)));
258 highlight.green=(MagickRealType) (QuantumScale*((QuantumRange-
259 HighlightModulate)*matte.green+(QuantumRange*HighlightModulate)));
260 highlight.blue=(MagickRealType) (QuantumScale*((QuantumRange-
261 HighlightModulate)*matte.blue+(QuantumRange*HighlightModulate)));
262 highlight.black=(MagickRealType) (QuantumScale*((QuantumRange-
263 HighlightModulate)*matte.black+(QuantumRange*HighlightModulate)));
264 highlight.alpha=matte.alpha;
266 shadow.red=QuantumScale*matte.red*ShadowModulate;
267 shadow.green=QuantumScale*matte.green*ShadowModulate;
268 shadow.blue=QuantumScale*matte.blue*ShadowModulate;
269 shadow.black=QuantumScale*matte.black*ShadowModulate;
270 shadow.alpha=matte.alpha;
272 trough.red=QuantumScale*matte.red*TroughModulate;
273 trough.green=QuantumScale*matte.green*TroughModulate;
274 trough.blue=QuantumScale*matte.blue*TroughModulate;
275 trough.black=QuantumScale*matte.black*TroughModulate;
276 trough.alpha=matte.alpha;
279 image_view=AcquireCacheView(image);
280 frame_view=AcquireCacheView(frame_image);
281 height=(size_t) (frame_info->outer_bevel+(frame_info->y-bevel_width)+
282 frame_info->inner_bevel);
292 Draw top of ornamental border.
294 q=QueueCacheViewAuthenticPixels(frame_view,0,0,frame_image->columns,
296 if (q != (Quantum *) NULL)
299 Draw top of ornamental border.
301 for (y=0; y < (ssize_t) frame_info->outer_bevel; y++)
303 for (x=0; x < (ssize_t) (frame_image->columns-y); x++)
306 SetPixelInfoPixel(frame_image,&highlight,q);
308 SetPixelInfoPixel(frame_image,&accentuate,q);
309 q+=GetPixelChannels(frame_image);
311 for ( ; x < (ssize_t) frame_image->columns; x++)
313 SetPixelInfoPixel(frame_image,&shadow,q);
314 q+=GetPixelChannels(frame_image);
317 for (y=0; y < (ssize_t) (frame_info->y-bevel_width); y++)
319 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
321 SetPixelInfoPixel(frame_image,&highlight,q);
322 q+=GetPixelChannels(frame_image);
324 width=frame_image->columns-2*frame_info->outer_bevel;
325 for (x=0; x < (ssize_t) width; x++)
327 SetPixelInfoPixel(frame_image,&matte,q);
328 q+=GetPixelChannels(frame_image);
330 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
332 SetPixelInfoPixel(frame_image,&shadow,q);
333 q+=GetPixelChannels(frame_image);
336 for (y=0; y < (ssize_t) frame_info->inner_bevel; y++)
338 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
340 SetPixelInfoPixel(frame_image,&highlight,q);
341 q+=GetPixelChannels(frame_image);
343 for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
345 SetPixelInfoPixel(frame_image,&matte,q);
346 q+=GetPixelChannels(frame_image);
348 width=image->columns+((size_t) frame_info->inner_bevel << 1)-
350 for (x=0; x < (ssize_t) width; x++)
353 SetPixelInfoPixel(frame_image,&shadow,q);
355 SetPixelInfoPixel(frame_image,&trough,q);
356 q+=GetPixelChannels(frame_image);
358 for ( ; x < (ssize_t) (image->columns+2*frame_info->inner_bevel); x++)
360 SetPixelInfoPixel(frame_image,&highlight,q);
361 q+=GetPixelChannels(frame_image);
363 width=frame_info->width-frame_info->x-image->columns-bevel_width;
364 for (x=0; x < (ssize_t) width; x++)
366 SetPixelInfoPixel(frame_image,&matte,q);
367 q+=GetPixelChannels(frame_image);
369 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
371 SetPixelInfoPixel(frame_image,&shadow,q);
372 q+=GetPixelChannels(frame_image);
375 (void) SyncCacheViewAuthenticPixels(frame_view,exception);
379 Draw sides of ornamental border.
381 #if defined(MAGICKCORE_OPENMP_SUPPORT)
382 #pragma omp parallel for schedule(static) shared(progress,status)
384 for (y=0; y < (ssize_t) image->rows; y++)
396 Initialize scanline with matte color.
398 if (status == MagickFalse)
400 q=QueueCacheViewAuthenticPixels(frame_view,0,frame_info->y+y,
401 frame_image->columns,1,exception);
402 if (q == (Quantum *) NULL)
407 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
409 SetPixelInfoPixel(frame_image,&highlight,q);
410 q+=GetPixelChannels(frame_image);
412 for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
414 SetPixelInfoPixel(frame_image,&matte,q);
415 q+=GetPixelChannels(frame_image);
417 for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)
419 SetPixelInfoPixel(frame_image,&shadow,q);
420 q+=GetPixelChannels(frame_image);
423 Set frame interior to interior color.
425 if ((compose != CopyCompositeOp) && ((compose != OverCompositeOp) ||
426 (image->matte != MagickFalse)))
427 for (x=0; x < (ssize_t) image->columns; x++)
429 SetPixelInfoPixel(frame_image,&interior,q);
430 q+=GetPixelChannels(frame_image);
434 register const Quantum
437 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
438 if (p == (const Quantum *) NULL)
443 for (x=0; x < (ssize_t) image->columns; x++)
445 if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
446 SetPixelRed(frame_image,GetPixelRed(image,p),q);
447 if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
448 SetPixelGreen(frame_image,GetPixelGreen(image,p),q);
449 if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
450 SetPixelBlue(frame_image,GetPixelBlue(image,p),q);
451 if ((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0)
452 SetPixelBlack(frame_image,GetPixelBlack(image,p),q);
453 if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)
454 SetPixelAlpha(frame_image,GetPixelAlpha(image,p),q);
455 p+=GetPixelChannels(image);
456 q+=GetPixelChannels(frame_image);
459 for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)
461 SetPixelInfoPixel(frame_image,&highlight,q);
462 q+=GetPixelChannels(frame_image);
464 width=frame_info->width-frame_info->x-image->columns-bevel_width;
465 for (x=0; x < (ssize_t) width; x++)
467 SetPixelInfoPixel(frame_image,&matte,q);
468 q+=GetPixelChannels(frame_image);
470 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
472 SetPixelInfoPixel(frame_image,&shadow,q);
473 q+=GetPixelChannels(frame_image);
475 if (SyncCacheViewAuthenticPixels(frame_view,exception) == MagickFalse)
477 if (image->progress_monitor != (MagickProgressMonitor) NULL)
482 #if defined(MAGICKCORE_OPENMP_SUPPORT)
483 #pragma omp critical (MagickCore_FrameImage)
485 proceed=SetImageProgress(image,FrameImageTag,progress++,image->rows);
486 if (proceed == MagickFalse)
490 height=(size_t) (frame_info->inner_bevel+frame_info->height-
491 frame_info->y-image->rows-bevel_width+frame_info->outer_bevel);
501 Draw bottom of ornamental border.
503 q=QueueCacheViewAuthenticPixels(frame_view,0,(ssize_t) (frame_image->rows-
504 height),frame_image->columns,height,exception);
505 if (q != (Quantum *) NULL)
508 Draw bottom of ornamental border.
510 for (y=frame_info->inner_bevel-1; y >= 0; y--)
512 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
514 SetPixelInfoPixel(frame_image,&highlight,q);
515 q+=GetPixelChannels(frame_image);
517 for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
519 SetPixelInfoPixel(frame_image,&matte,q);
520 q+=GetPixelChannels(frame_image);
522 for (x=0; x < y; x++)
524 SetPixelInfoPixel(frame_image,&shadow,q);
525 q+=GetPixelChannels(frame_image);
527 for ( ; x < (ssize_t) (image->columns+2*frame_info->inner_bevel); x++)
529 if (x >= (ssize_t) (image->columns+2*frame_info->inner_bevel-y))
530 SetPixelInfoPixel(frame_image,&highlight,q);
532 SetPixelInfoPixel(frame_image,&accentuate,q);
533 q+=GetPixelChannels(frame_image);
535 width=frame_info->width-frame_info->x-image->columns-bevel_width;
536 for (x=0; x < (ssize_t) width; x++)
538 SetPixelInfoPixel(frame_image,&matte,q);
539 q+=GetPixelChannels(frame_image);
541 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
543 SetPixelInfoPixel(frame_image,&shadow,q);
544 q+=GetPixelChannels(frame_image);
547 height=frame_info->height-frame_info->y-image->rows-bevel_width;
548 for (y=0; y < (ssize_t) height; y++)
550 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
552 SetPixelInfoPixel(frame_image,&highlight,q);
553 q+=GetPixelChannels(frame_image);
555 width=frame_image->columns-2*frame_info->outer_bevel;
556 for (x=0; x < (ssize_t) width; x++)
558 SetPixelInfoPixel(frame_image,&matte,q);
559 q+=GetPixelChannels(frame_image);
561 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
563 SetPixelInfoPixel(frame_image,&shadow,q);
564 q+=GetPixelChannels(frame_image);
567 for (y=frame_info->outer_bevel-1; y >= 0; y--)
569 for (x=0; x < y; x++)
571 SetPixelInfoPixel(frame_image,&highlight,q);
572 q+=GetPixelChannels(frame_image);
574 for ( ; x < (ssize_t) frame_image->columns; x++)
576 if (x >= (ssize_t) (frame_image->columns-y))
577 SetPixelInfoPixel(frame_image,&shadow,q);
579 SetPixelInfoPixel(frame_image,&trough,q);
580 q+=GetPixelChannels(frame_image);
583 (void) SyncCacheViewAuthenticPixels(frame_view,exception);
586 frame_view=DestroyCacheView(frame_view);
587 image_view=DestroyCacheView(image_view);
588 if ((compose != CopyCompositeOp) && ((compose != OverCompositeOp) ||
589 (image->matte != MagickFalse)))
591 x=(ssize_t) (frame_info->outer_bevel+(frame_info->x-bevel_width)+
592 frame_info->inner_bevel);
593 y=(ssize_t) (frame_info->outer_bevel+(frame_info->y-bevel_width)+
594 frame_info->inner_bevel);
595 (void) CompositeImage(frame_image,compose,image,x,y,exception);
601 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
605 % R a i s e I m a g e %
609 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
611 % RaiseImage() creates a simulated three-dimensional button-like effect
612 % by lightening and darkening the edges of the image. Members width and
613 % height of raise_info define the width of the vertical and horizontal
614 % edge of the effect.
616 % The format of the RaiseImage method is:
618 % MagickBooleanType RaiseImage(const Image *image,
619 % const RectangleInfo *raise_info,const MagickBooleanType raise,
620 % ExceptionInfo *exception)
622 % A description of each parameter follows:
624 % o image: the image.
626 % o raise_info: Define the width and height of the raise area.
628 % o raise: A value other than zero creates a 3-D raise effect,
629 % otherwise it has a lowered effect.
631 % o exception: return any errors or warnings in this structure.
634 MagickExport MagickBooleanType RaiseImage(Image *image,
635 const RectangleInfo *raise_info,const MagickBooleanType raise,
636 ExceptionInfo *exception)
638 #define AccentuateFactor ScaleCharToQuantum(135)
639 #define HighlightFactor ScaleCharToQuantum(190)
640 #define ShadowFactor ScaleCharToQuantum(190)
641 #define RaiseImageTag "Raise/Image"
642 #define TroughFactor ScaleCharToQuantum(135)
660 assert(image != (Image *) NULL);
661 assert(image->signature == MagickSignature);
662 if (image->debug != MagickFalse)
663 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
664 assert(raise_info != (RectangleInfo *) NULL);
665 if ((image->columns <= (raise_info->width << 1)) ||
666 (image->rows <= (raise_info->height << 1)))
667 ThrowBinaryException(OptionError,"ImageSizeMustExceedBevelWidth",
669 foreground=(Quantum) QuantumRange;
670 background=(Quantum) 0;
671 if (raise == MagickFalse)
673 foreground=(Quantum) 0;
674 background=(Quantum) QuantumRange;
676 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
683 image_view=AcquireCacheView(image);
684 #if defined(MAGICKCORE_OPENMP_SUPPORT)
685 #pragma omp parallel for schedule(static) shared(progress,status)
687 for (y=0; y < (ssize_t) raise_info->height; y++)
696 if (status == MagickFalse)
698 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
699 if (q == (Quantum *) NULL)
704 for (x=0; x < y; x++)
706 if (GetPixelMask(image,q) != 0)
708 q+=GetPixelChannels(image);
711 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
719 channel=GetPixelChannelMapChannel(image,i);
720 traits=GetPixelChannelMapTraits(image,channel);
721 if ((traits & UpdatePixelTrait) == 0)
723 q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*HighlightFactor+
724 (MagickRealType) foreground*(QuantumRange-HighlightFactor)));
726 q+=GetPixelChannels(image);
728 for ( ; x < (ssize_t) (image->columns-y); x++)
730 if (GetPixelMask(image,q) != 0)
732 q+=GetPixelChannels(image);
735 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
743 channel=GetPixelChannelMapChannel(image,i);
744 traits=GetPixelChannelMapTraits(image,channel);
745 if ((traits & UpdatePixelTrait) == 0)
747 q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
748 AccentuateFactor+(MagickRealType) foreground*(QuantumRange-
751 q+=GetPixelChannels(image);
753 for ( ; x < (ssize_t) image->columns; x++)
755 if (GetPixelMask(image,q) != 0)
757 q+=GetPixelChannels(image);
760 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
768 channel=GetPixelChannelMapChannel(image,i);
769 traits=GetPixelChannelMapTraits(image,channel);
770 if ((traits & UpdatePixelTrait) == 0)
772 q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*ShadowFactor+
773 (MagickRealType) background*(QuantumRange-ShadowFactor)));
775 q+=GetPixelChannels(image);
777 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
779 if (image->progress_monitor != (MagickProgressMonitor) NULL)
784 proceed=SetImageProgress(image,RaiseImageTag,progress++,image->rows);
785 if (proceed == MagickFalse)
789 #if defined(MAGICKCORE_OPENMP_SUPPORT)
790 #pragma omp parallel for schedule(static) shared(progress,status)
792 for (y=(ssize_t) raise_info->height; y < (ssize_t) (image->rows-raise_info->height); y++)
801 if (status == MagickFalse)
803 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
804 if (q == (Quantum *) NULL)
809 for (x=0; x < (ssize_t) raise_info->width; x++)
811 if (GetPixelMask(image,q) != 0)
813 q+=GetPixelChannels(image);
816 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
824 channel=GetPixelChannelMapChannel(image,i);
825 traits=GetPixelChannelMapTraits(image,channel);
826 if ((traits & UpdatePixelTrait) == 0)
828 q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*HighlightFactor+
829 (MagickRealType) foreground*(QuantumRange-HighlightFactor)));
831 q+=GetPixelChannels(image);
833 for ( ; x < (ssize_t) (image->columns-raise_info->width); x++)
834 q+=GetPixelChannels(image);
835 for ( ; x < (ssize_t) image->columns; x++)
837 if (GetPixelMask(image,q) != 0)
839 q+=GetPixelChannels(image);
842 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
850 channel=GetPixelChannelMapChannel(image,i);
851 traits=GetPixelChannelMapTraits(image,channel);
852 if ((traits & UpdatePixelTrait) == 0)
854 q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*ShadowFactor+
855 (MagickRealType) background*(QuantumRange-ShadowFactor)));
857 q+=GetPixelChannels(image);
859 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
861 if (image->progress_monitor != (MagickProgressMonitor) NULL)
866 proceed=SetImageProgress(image,RaiseImageTag,progress++,image->rows);
867 if (proceed == MagickFalse)
871 #if defined(MAGICKCORE_OPENMP_SUPPORT)
872 #pragma omp parallel for schedule(static) shared(progress,status)
874 for (y=(ssize_t) (image->rows-raise_info->height); y < (ssize_t) image->rows; y++)
883 if (status == MagickFalse)
885 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
886 if (q == (Quantum *) NULL)
891 for (x=0; x < (ssize_t) (image->rows-y); x++)
893 if (GetPixelMask(image,q) != 0)
895 q+=GetPixelChannels(image);
898 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
906 channel=GetPixelChannelMapChannel(image,i);
907 traits=GetPixelChannelMapTraits(image,channel);
908 if ((traits & UpdatePixelTrait) == 0)
910 q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*HighlightFactor+
911 (MagickRealType) foreground*(QuantumRange-HighlightFactor)));
913 q+=GetPixelChannels(image);
915 for ( ; x < (ssize_t) (image->columns-(image->rows-y)); x++)
917 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
925 channel=GetPixelChannelMapChannel(image,i);
926 traits=GetPixelChannelMapTraits(image,channel);
927 if ((traits & UpdatePixelTrait) == 0)
929 q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*TroughFactor+
930 (MagickRealType) background*(QuantumRange-TroughFactor)));
932 q+=GetPixelChannels(image);
934 for ( ; x < (ssize_t) image->columns; x++)
936 if (GetPixelMask(image,q) != 0)
938 q+=GetPixelChannels(image);
941 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
949 channel=GetPixelChannelMapChannel(image,i);
950 traits=GetPixelChannelMapTraits(image,channel);
951 if ((traits & UpdatePixelTrait) == 0)
953 q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*ShadowFactor+
954 (MagickRealType) background*(QuantumRange-ShadowFactor)));
956 q+=GetPixelChannels(image);
958 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
960 if (image->progress_monitor != (MagickProgressMonitor) NULL)
965 #if defined(MAGICKCORE_OPENMP_SUPPORT)
966 #pragma omp critical (MagickCore_RaiseImage)
968 proceed=SetImageProgress(image,RaiseImageTag,progress++,image->rows);
969 if (proceed == MagickFalse)
973 image_view=DestroyCacheView(image_view);