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-2011 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 % ExceptionInfo *exception)
91 % A description of each parameter follows:
95 % o border_info: Define the width and height of the border.
97 % o exception: return any errors or warnings in this structure.
100 MagickExport Image *BorderImage(const Image *image,
101 const RectangleInfo *border_info,ExceptionInfo *exception)
110 assert(image != (const Image *) NULL);
111 assert(image->signature == MagickSignature);
112 if (image->debug != MagickFalse)
113 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
114 assert(border_info != (RectangleInfo *) NULL);
115 frame_info.width=image->columns+(border_info->width << 1);
116 frame_info.height=image->rows+(border_info->height << 1);
117 frame_info.x=(ssize_t) border_info->width;
118 frame_info.y=(ssize_t) border_info->height;
119 frame_info.inner_bevel=0;
120 frame_info.outer_bevel=0;
121 clone_image=CloneImage(image,0,0,MagickTrue,exception);
122 if (clone_image == (Image *) NULL)
123 return((Image *) NULL);
124 clone_image->matte_color=image->border_color;
125 border_image=FrameImage(clone_image,&frame_info,exception);
126 clone_image=DestroyImage(clone_image);
127 if (border_image != (Image *) NULL)
128 border_image->matte_color=image->matte_color;
129 return(border_image);
133 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
137 % F r a m e I m a g e %
141 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
143 % FrameImage() adds a simulated three-dimensional border around the image.
144 % The color of the border is defined by the matte_color member of image.
145 % Members width and height of frame_info specify the border width of the
146 % vertical and horizontal sides of the frame. Members inner and outer
147 % indicate the width of the inner and outer shadows of the frame.
149 % The format of the FrameImage method is:
151 % Image *FrameImage(const Image *image,const FrameInfo *frame_info,
152 % ExceptionInfo *exception)
154 % A description of each parameter follows:
156 % o image: the image.
158 % o frame_info: Define the width and height of the frame and its bevels.
160 % o exception: return any errors or warnings in this structure.
163 MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
164 ExceptionInfo *exception)
166 #define FrameImageTag "Frame/Image"
202 Check frame geometry.
204 assert(image != (Image *) NULL);
205 assert(image->signature == MagickSignature);
206 if (image->debug != MagickFalse)
207 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
208 assert(frame_info != (FrameInfo *) NULL);
209 if ((frame_info->outer_bevel < 0) || (frame_info->inner_bevel < 0))
210 ThrowImageException(OptionError,"FrameIsLessThanImageSize");
211 bevel_width=(size_t) (frame_info->outer_bevel+frame_info->inner_bevel);
212 width=frame_info->width-frame_info->x-bevel_width;
213 height=frame_info->height-frame_info->y-bevel_width;
214 if ((width < image->columns) || (height < image->rows))
215 ThrowImageException(OptionError,"FrameIsLessThanImageSize");
217 Initialize framed image attributes.
219 frame_image=CloneImage(image,frame_info->width,frame_info->height,MagickTrue,
221 if (frame_image == (Image *) NULL)
222 return((Image *) NULL);
223 if (SetImageStorageClass(frame_image,DirectClass,exception) == MagickFalse)
225 frame_image=DestroyImage(frame_image);
226 return((Image *) NULL);
228 if (frame_image->matte_color.alpha != OpaqueAlpha)
229 frame_image->matte=MagickTrue;
230 frame_image->page=image->page;
231 if ((image->page.width != 0) && (image->page.height != 0))
233 frame_image->page.width+=frame_image->columns-image->columns;
234 frame_image->page.height+=frame_image->rows-image->rows;
237 Initialize 3D effects color.
239 GetPixelInfo(frame_image,&interior);
240 SetPixelInfoPacket(frame_image,&image->border_color,&interior);
241 GetPixelInfo(frame_image,&matte);
242 matte.colorspace=RGBColorspace;
243 SetPixelInfoPacket(frame_image,&image->matte_color,&matte);
244 GetPixelInfo(frame_image,&border);
245 border.colorspace=RGBColorspace;
246 SetPixelInfoPacket(frame_image,&image->border_color,&border);
247 GetPixelInfo(frame_image,&accentuate);
248 accentuate.red=(MagickRealType) (QuantumScale*((QuantumRange-
249 AccentuateModulate)*matte.red+(QuantumRange*AccentuateModulate)));
250 accentuate.green=(MagickRealType) (QuantumScale*((QuantumRange-
251 AccentuateModulate)*matte.green+(QuantumRange*AccentuateModulate)));
252 accentuate.blue=(MagickRealType) (QuantumScale*((QuantumRange-
253 AccentuateModulate)*matte.blue+(QuantumRange*AccentuateModulate)));
254 accentuate.alpha=matte.alpha;
255 GetPixelInfo(frame_image,&highlight);
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.alpha=matte.alpha;
263 GetPixelInfo(frame_image,&shadow);
264 shadow.red=QuantumScale*matte.red*ShadowModulate;
265 shadow.green=QuantumScale*matte.green*ShadowModulate;
266 shadow.blue=QuantumScale*matte.blue*ShadowModulate;
267 shadow.alpha=matte.alpha;
268 GetPixelInfo(frame_image,&trough);
269 trough.red=QuantumScale*matte.red*TroughModulate;
270 trough.green=QuantumScale*matte.green*TroughModulate;
271 trough.blue=QuantumScale*matte.blue*TroughModulate;
272 trough.alpha=matte.alpha;
273 if (image->colorspace == CMYKColorspace)
275 ConvertRGBToCMYK(&interior);
276 ConvertRGBToCMYK(&matte);
277 ConvertRGBToCMYK(&border);
278 ConvertRGBToCMYK(&accentuate);
279 ConvertRGBToCMYK(&highlight);
280 ConvertRGBToCMYK(&shadow);
281 ConvertRGBToCMYK(&trough);
285 image_view=AcquireCacheView(image);
286 frame_view=AcquireCacheView(frame_image);
287 height=(size_t) (frame_info->outer_bevel+(frame_info->y-bevel_width)+
288 frame_info->inner_bevel);
298 Draw top of ornamental border.
300 q=QueueCacheViewAuthenticPixels(frame_view,0,0,frame_image->columns,
302 if (q != (Quantum *) NULL)
305 Draw top of ornamental border.
307 for (y=0; y < (ssize_t) frame_info->outer_bevel; y++)
309 for (x=0; x < (ssize_t) (frame_image->columns-y); x++)
312 SetPixelPixelInfo(frame_image,&highlight,q);
314 SetPixelPixelInfo(frame_image,&accentuate,q);
315 q+=GetPixelChannels(frame_image);
317 for ( ; x < (ssize_t) frame_image->columns; x++)
319 SetPixelPixelInfo(frame_image,&shadow,q);
320 q+=GetPixelChannels(frame_image);
323 for (y=0; y < (ssize_t) (frame_info->y-bevel_width); y++)
325 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
327 SetPixelPixelInfo(frame_image,&highlight,q);
328 q+=GetPixelChannels(frame_image);
330 width=frame_image->columns-2*frame_info->outer_bevel;
331 for (x=0; x < (ssize_t) width; x++)
333 SetPixelPixelInfo(frame_image,&matte,q);
334 q+=GetPixelChannels(frame_image);
336 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
338 SetPixelPixelInfo(frame_image,&shadow,q);
339 q+=GetPixelChannels(frame_image);
342 for (y=0; y < (ssize_t) frame_info->inner_bevel; y++)
344 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
346 SetPixelPixelInfo(frame_image,&highlight,q);
347 q+=GetPixelChannels(frame_image);
349 for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
351 SetPixelPixelInfo(frame_image,&matte,q);
352 q+=GetPixelChannels(frame_image);
354 width=image->columns+((size_t) frame_info->inner_bevel << 1)-
356 for (x=0; x < (ssize_t) width; x++)
359 SetPixelPixelInfo(frame_image,&shadow,q);
361 SetPixelPixelInfo(frame_image,&trough,q);
362 q+=GetPixelChannels(frame_image);
364 for ( ; x < (ssize_t) (image->columns+2*frame_info->inner_bevel); x++)
366 SetPixelPixelInfo(frame_image,&highlight,q);
367 q+=GetPixelChannels(frame_image);
369 width=frame_info->width-frame_info->x-image->columns-bevel_width;
370 for (x=0; x < (ssize_t) width; x++)
372 SetPixelPixelInfo(frame_image,&matte,q);
373 q+=GetPixelChannels(frame_image);
375 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
377 SetPixelPixelInfo(frame_image,&shadow,q);
378 q+=GetPixelChannels(frame_image);
381 (void) SyncCacheViewAuthenticPixels(frame_view,exception);
385 Draw sides of ornamental border.
387 #if defined(MAGICKCORE_OPENMP_SUPPORT)
388 #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
390 for (y=0; y < (ssize_t) image->rows; y++)
399 Initialize scanline with matte color.
401 if (status == MagickFalse)
403 q=QueueCacheViewAuthenticPixels(frame_view,0,frame_info->y+y,
404 frame_image->columns,1,exception);
405 if (q == (Quantum *) NULL)
410 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
412 SetPixelPixelInfo(frame_image,&highlight,q);
413 q+=GetPixelChannels(frame_image);
415 for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
417 SetPixelPixelInfo(frame_image,&matte,q);
418 q+=GetPixelChannels(frame_image);
420 for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)
422 SetPixelPixelInfo(frame_image,&shadow,q);
423 q+=GetPixelChannels(frame_image);
426 Set frame interior to interior color.
428 if ((image->compose != CopyCompositeOp) &&
429 ((image->compose != OverCompositeOp) || (image->matte != MagickFalse)))
430 for (x=0; x < (ssize_t) image->columns; x++)
432 SetPixelPixelInfo(frame_image,&interior,q);
433 q+=GetPixelChannels(frame_image);
437 register const Quantum
440 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
441 if (p == (const Quantum *) NULL)
446 for (x=0; x < (ssize_t) image->columns; x++)
448 SetPixelRed(frame_image,GetPixelRed(image,p),q);
449 SetPixelGreen(frame_image,GetPixelGreen(image,p),q);
450 SetPixelBlue(frame_image,GetPixelBlue(image,p),q);
451 if (image->colorspace == CMYKColorspace)
452 SetPixelBlack(frame_image,GetPixelBlack(image,p),q);
453 SetPixelAlpha(frame_image,GetPixelAlpha(image,p),q);
454 p+=GetPixelChannels(image);
455 q+=GetPixelChannels(frame_image);
458 for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)
460 SetPixelPixelInfo(frame_image,&highlight,q);
461 q+=GetPixelChannels(frame_image);
463 width=frame_info->width-frame_info->x-image->columns-bevel_width;
464 for (x=0; x < (ssize_t) width; x++)
466 SetPixelPixelInfo(frame_image,&matte,q);
467 q+=GetPixelChannels(frame_image);
469 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
471 SetPixelPixelInfo(frame_image,&shadow,q);
472 q+=GetPixelChannels(frame_image);
474 if (SyncCacheViewAuthenticPixels(frame_view,exception) == MagickFalse)
476 if (image->progress_monitor != (MagickProgressMonitor) NULL)
481 #if defined(MAGICKCORE_OPENMP_SUPPORT)
482 #pragma omp critical (MagickCore_FrameImage)
484 proceed=SetImageProgress(image,FrameImageTag,progress++,image->rows);
485 if (proceed == MagickFalse)
489 height=(size_t) (frame_info->inner_bevel+frame_info->height-
490 frame_info->y-image->rows-bevel_width+frame_info->outer_bevel);
500 Draw bottom of ornamental border.
502 q=QueueCacheViewAuthenticPixels(frame_view,0,(ssize_t) (frame_image->rows-
503 height),frame_image->columns,height,exception);
504 if (q != (Quantum *) NULL)
507 Draw bottom of ornamental border.
509 for (y=frame_info->inner_bevel-1; y >= 0; y--)
511 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
513 SetPixelPixelInfo(frame_image,&highlight,q);
514 q+=GetPixelChannels(frame_image);
516 for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
518 SetPixelPixelInfo(frame_image,&matte,q);
519 q+=GetPixelChannels(frame_image);
521 for (x=0; x < y; x++)
523 SetPixelPixelInfo(frame_image,&shadow,q);
524 q+=GetPixelChannels(frame_image);
526 for ( ; x < (ssize_t) (image->columns+2*frame_info->inner_bevel); x++)
528 if (x >= (ssize_t) (image->columns+2*frame_info->inner_bevel-y))
529 SetPixelPixelInfo(frame_image,&highlight,q);
531 SetPixelPixelInfo(frame_image,&accentuate,q);
532 q+=GetPixelChannels(frame_image);
534 width=frame_info->width-frame_info->x-image->columns-bevel_width;
535 for (x=0; x < (ssize_t) width; x++)
537 SetPixelPixelInfo(frame_image,&matte,q);
538 q+=GetPixelChannels(frame_image);
540 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
542 SetPixelPixelInfo(frame_image,&shadow,q);
543 q+=GetPixelChannels(frame_image);
546 height=frame_info->height-frame_info->y-image->rows-bevel_width;
547 for (y=0; y < (ssize_t) height; y++)
549 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
551 SetPixelPixelInfo(frame_image,&highlight,q);
552 q+=GetPixelChannels(frame_image);
554 width=frame_image->columns-2*frame_info->outer_bevel;
555 for (x=0; x < (ssize_t) width; x++)
557 SetPixelPixelInfo(frame_image,&matte,q);
558 q+=GetPixelChannels(frame_image);
560 for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
562 SetPixelPixelInfo(frame_image,&shadow,q);
563 q+=GetPixelChannels(frame_image);
566 for (y=frame_info->outer_bevel-1; y >= 0; y--)
568 for (x=0; x < y; x++)
570 SetPixelPixelInfo(frame_image,&highlight,q);
571 q+=GetPixelChannels(frame_image);
573 for ( ; x < (ssize_t) frame_image->columns; x++)
575 if (x >= (ssize_t) (frame_image->columns-y))
576 SetPixelPixelInfo(frame_image,&shadow,q);
578 SetPixelPixelInfo(frame_image,&trough,q);
579 q+=GetPixelChannels(frame_image);
582 (void) SyncCacheViewAuthenticPixels(frame_view,exception);
585 frame_view=DestroyCacheView(frame_view);
586 image_view=DestroyCacheView(image_view);
587 if ((image->compose != CopyCompositeOp) &&
588 ((image->compose != OverCompositeOp) || (image->matte != MagickFalse)))
590 x=(ssize_t) (frame_info->outer_bevel+(frame_info->x-bevel_width)+
591 frame_info->inner_bevel);
592 y=(ssize_t) (frame_info->outer_bevel+(frame_info->y-bevel_width)+
593 frame_info->inner_bevel);
594 (void) CompositeImage(frame_image,image->compose,image,x,y);
600 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
604 % R a i s e I m a g e %
608 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
610 % RaiseImage() creates a simulated three-dimensional button-like effect
611 % by lightening and darkening the edges of the image. Members width and
612 % height of raise_info define the width of the vertical and horizontal
613 % edge of the effect.
615 % The format of the RaiseImage method is:
617 % MagickBooleanType RaiseImage(const Image *image,
618 % const RectangleInfo *raise_info,const MagickBooleanType raise,
619 % ExceptionInfo *exception)
621 % A description of each parameter follows:
623 % o image: the image.
625 % o raise_info: Define the width and height of the raise area.
627 % o raise: A value other than zero creates a 3-D raise effect,
628 % otherwise it has a lowered effect.
630 % o exception: return any errors or warnings in this structure.
633 MagickExport MagickBooleanType RaiseImage(Image *image,
634 const RectangleInfo *raise_info,const MagickBooleanType raise,
635 ExceptionInfo *exception)
637 #define AccentuateFactor ScaleCharToQuantum(135)
638 #define HighlightFactor ScaleCharToQuantum(190)
639 #define ShadowFactor ScaleCharToQuantum(190)
640 #define RaiseImageTag "Raise/Image"
641 #define TroughFactor ScaleCharToQuantum(135)
659 assert(image != (Image *) NULL);
660 assert(image->signature == MagickSignature);
661 if (image->debug != MagickFalse)
662 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
663 assert(raise_info != (RectangleInfo *) NULL);
664 if ((image->columns <= (raise_info->width << 1)) ||
665 (image->rows <= (raise_info->height << 1)))
666 ThrowBinaryException(OptionError,"ImageSizeMustExceedBevelWidth",
668 foreground=(Quantum) QuantumRange;
669 background=(Quantum) 0;
670 if (raise == MagickFalse)
672 foreground=(Quantum) 0;
673 background=(Quantum) QuantumRange;
675 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
682 image_view=AcquireCacheView(image);
683 #if defined(MAGICKCORE_OPENMP_SUPPORT)
684 #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
686 for (y=0; y < (ssize_t) raise_info->height; y++)
698 if (status == MagickFalse)
700 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
701 if (q == (Quantum *) NULL)
706 for (x=0; x < y; x++)
708 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
710 traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
711 if ((traits & UpdatePixelTrait) != 0)
712 q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
713 HighlightFactor+(MagickRealType) foreground*(QuantumRange-
716 q+=GetPixelChannels(image);
718 for ( ; x < (ssize_t) (image->columns-y); x++)
720 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
722 traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
723 if ((traits & UpdatePixelTrait) != 0)
724 q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
725 AccentuateFactor+(MagickRealType) foreground*(QuantumRange-
728 q+=GetPixelChannels(image);
730 for ( ; x < (ssize_t) image->columns; x++)
732 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
734 traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
735 if ((traits & UpdatePixelTrait) != 0)
736 q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
737 ShadowFactor+(MagickRealType) background*(QuantumRange-
740 q+=GetPixelChannels(image);
742 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
744 if (image->progress_monitor != (MagickProgressMonitor) NULL)
749 proceed=SetImageProgress(image,RaiseImageTag,progress++,image->rows);
750 if (proceed == MagickFalse)
754 #if defined(MAGICKCORE_OPENMP_SUPPORT)
755 #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
757 for (y=(ssize_t) raise_info->height; y < (ssize_t) (image->rows-raise_info->height); y++)
769 if (status == MagickFalse)
771 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
772 if (q == (Quantum *) NULL)
777 for (x=0; x < (ssize_t) raise_info->width; x++)
779 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
781 traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
782 if ((traits & UpdatePixelTrait) != 0)
783 q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
784 HighlightFactor+(MagickRealType) foreground*(QuantumRange-
787 q+=GetPixelChannels(image);
789 for ( ; x < (ssize_t) (image->columns-raise_info->width); x++)
790 q+=GetPixelChannels(image);
791 for ( ; x < (ssize_t) image->columns; x++)
793 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
795 traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
796 if ((traits & UpdatePixelTrait) != 0)
797 q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
798 ShadowFactor+(MagickRealType) background*(QuantumRange-
801 q+=GetPixelChannels(image);
803 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
805 if (image->progress_monitor != (MagickProgressMonitor) NULL)
810 proceed=SetImageProgress(image,RaiseImageTag,progress++,image->rows);
811 if (proceed == MagickFalse)
815 #if defined(MAGICKCORE_OPENMP_SUPPORT)
816 #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
818 for (y=(ssize_t) (image->rows-raise_info->height); y < (ssize_t) image->rows; y++)
830 if (status == MagickFalse)
832 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
833 if (q == (Quantum *) NULL)
838 for (x=0; x < (ssize_t) (image->rows-y); x++)
840 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
842 traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
843 if ((traits & UpdatePixelTrait) != 0)
844 q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
845 HighlightFactor+(MagickRealType) foreground*(QuantumRange-
848 q+=GetPixelChannels(image);
850 for ( ; x < (ssize_t) (image->columns-(image->rows-y)); x++)
852 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
854 traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
855 if ((traits & UpdatePixelTrait) != 0)
856 q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
857 TroughFactor+(MagickRealType) background*(QuantumRange-
860 q+=GetPixelChannels(image);
862 for ( ; x < (ssize_t) image->columns; x++)
864 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
866 traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
867 if ((traits & UpdatePixelTrait) != 0)
868 q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
869 ShadowFactor+(MagickRealType) background*(QuantumRange-
872 q+=GetPixelChannels(image);
874 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
876 if (image->progress_monitor != (MagickProgressMonitor) NULL)
881 #if defined(MAGICKCORE_OPENMP_SUPPORT)
882 #pragma omp critical (MagickCore_RaiseImage)
884 proceed=SetImageProgress(image,RaiseImageTag,progress++,image->rows);
885 if (proceed == MagickFalse)
889 image_view=DestroyCacheView(image_view);