% MagickCore Image Decoration Methods %
% %
% Software Design %
-% John Cristy %
+% Cristy %
% July 1992 %
% %
% %
-% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2017 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
% obtain a copy of the License at %
% %
-% http://www.imagemagick.org/script/license.php %
+% https://www.imagemagick.org/script/license.php %
% %
% Unless required by applicable law or agreed to in writing, software %
% distributed under the License is distributed on an "AS IS" BASIS, %
#include "MagickCore/pixel-accessor.h"
#include "MagickCore/quantum.h"
#include "MagickCore/quantum-private.h"
+#include "MagickCore/resource_.h"
#include "MagickCore/thread-private.h"
#include "MagickCore/transform.h"
\f
% The format of the BorderImage method is:
%
% Image *BorderImage(const Image *image,const RectangleInfo *border_info,
-% ExceptionInfo *exception)
+% const CompositeOperator compose,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
-% o border_info: Define the width and height of the border.
+% o border_info: define the width and height of the border.
+%
+% o compose: the composite operator.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *BorderImage(const Image *image,
- const RectangleInfo *border_info,ExceptionInfo *exception)
+ const RectangleInfo *border_info,const CompositeOperator compose,
+ ExceptionInfo *exception)
{
Image
*border_image,
frame_info;
assert(image != (const Image *) NULL);
- assert(image->signature == MagickSignature);
+ assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(border_info != (RectangleInfo *) NULL);
if (clone_image == (Image *) NULL)
return((Image *) NULL);
clone_image->matte_color=image->border_color;
- border_image=FrameImage(clone_image,&frame_info,exception);
+ border_image=FrameImage(clone_image,&frame_info,compose,exception);
clone_image=DestroyImage(clone_image);
if (border_image != (Image *) NULL)
border_image->matte_color=image->matte_color;
% The format of the FrameImage method is:
%
% Image *FrameImage(const Image *image,const FrameInfo *frame_info,
-% ExceptionInfo *exception)
+% const CompositeOperator compose,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o frame_info: Define the width and height of the frame and its bevels.
%
+% o compose: the composite operator.
+%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
- ExceptionInfo *exception)
+ const CompositeOperator compose,ExceptionInfo *exception)
{
#define FrameImageTag "Frame/Image"
PixelInfo
accentuate,
- border,
highlight,
- interior,
matte,
shadow,
trough;
Check frame geometry.
*/
assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
+ assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(frame_info != (FrameInfo *) NULL);
if ((frame_info->outer_bevel < 0) || (frame_info->inner_bevel < 0))
ThrowImageException(OptionError,"FrameIsLessThanImageSize");
bevel_width=(size_t) (frame_info->outer_bevel+frame_info->inner_bevel);
- width=frame_info->width-frame_info->x-bevel_width;
- height=frame_info->height-frame_info->y-bevel_width;
- if ((width < image->columns) || (height < image->rows))
+ x=(ssize_t) frame_info->width-frame_info->x-bevel_width;
+ y=(ssize_t) frame_info->height-frame_info->y-bevel_width;
+ if ((x < (ssize_t) image->columns) | (y < (ssize_t) image->rows))
ThrowImageException(OptionError,"FrameIsLessThanImageSize");
/*
Initialize framed image attributes.
exception);
if (frame_image == (Image *) NULL)
return((Image *) NULL);
- if (SetImageStorageClass(frame_image,DirectClass) == MagickFalse)
+ if (SetImageStorageClass(frame_image,DirectClass,exception) == MagickFalse)
{
- InheritException(exception,&frame_image->exception);
frame_image=DestroyImage(frame_image);
return((Image *) NULL);
}
- if (frame_image->matte_color.alpha != OpaqueAlpha)
- frame_image->matte=MagickTrue;
+ if ((IsPixelInfoGray(&frame_image->border_color) == MagickFalse) &&
+ (IsGrayColorspace(frame_image->colorspace) != MagickFalse))
+ (void) SetImageColorspace(frame_image,sRGBColorspace,exception);
+ if ((frame_image->matte_color.alpha_trait != UndefinedPixelTrait) &&
+ (frame_image->alpha_trait == UndefinedPixelTrait))
+ (void) SetImageAlpha(frame_image,OpaqueAlpha,exception);
frame_image->page=image->page;
if ((image->page.width != 0) && (image->page.height != 0))
{
/*
Initialize 3D effects color.
*/
- GetPixelInfo(frame_image,&interior);
- SetPixelInfoPacket(frame_image,&image->border_color,&interior);
- GetPixelInfo(frame_image,&matte);
- matte.colorspace=RGBColorspace;
- SetPixelInfoPacket(frame_image,&image->matte_color,&matte);
- GetPixelInfo(frame_image,&border);
- border.colorspace=RGBColorspace;
- SetPixelInfoPacket(frame_image,&image->border_color,&border);
- GetPixelInfo(frame_image,&accentuate);
- accentuate.red=(MagickRealType) (QuantumScale*((QuantumRange-
+ matte=image->matte_color;
+ accentuate=matte;
+ accentuate.red=(double) (QuantumScale*((QuantumRange-
AccentuateModulate)*matte.red+(QuantumRange*AccentuateModulate)));
- accentuate.green=(MagickRealType) (QuantumScale*((QuantumRange-
+ accentuate.green=(double) (QuantumScale*((QuantumRange-
AccentuateModulate)*matte.green+(QuantumRange*AccentuateModulate)));
- accentuate.blue=(MagickRealType) (QuantumScale*((QuantumRange-
+ accentuate.blue=(double) (QuantumScale*((QuantumRange-
AccentuateModulate)*matte.blue+(QuantumRange*AccentuateModulate)));
+ accentuate.black=(double) (QuantumScale*((QuantumRange-
+ AccentuateModulate)*matte.black+(QuantumRange*AccentuateModulate)));
accentuate.alpha=matte.alpha;
- GetPixelInfo(frame_image,&highlight);
- highlight.red=(MagickRealType) (QuantumScale*((QuantumRange-
+ highlight=matte;
+ highlight.red=(double) (QuantumScale*((QuantumRange-
HighlightModulate)*matte.red+(QuantumRange*HighlightModulate)));
- highlight.green=(MagickRealType) (QuantumScale*((QuantumRange-
+ highlight.green=(double) (QuantumScale*((QuantumRange-
HighlightModulate)*matte.green+(QuantumRange*HighlightModulate)));
- highlight.blue=(MagickRealType) (QuantumScale*((QuantumRange-
+ highlight.blue=(double) (QuantumScale*((QuantumRange-
HighlightModulate)*matte.blue+(QuantumRange*HighlightModulate)));
+ highlight.black=(double) (QuantumScale*((QuantumRange-
+ HighlightModulate)*matte.black+(QuantumRange*HighlightModulate)));
highlight.alpha=matte.alpha;
- GetPixelInfo(frame_image,&shadow);
+ shadow=matte;
shadow.red=QuantumScale*matte.red*ShadowModulate;
shadow.green=QuantumScale*matte.green*ShadowModulate;
shadow.blue=QuantumScale*matte.blue*ShadowModulate;
+ shadow.black=QuantumScale*matte.black*ShadowModulate;
shadow.alpha=matte.alpha;
- GetPixelInfo(frame_image,&trough);
+ trough=matte;
trough.red=QuantumScale*matte.red*TroughModulate;
trough.green=QuantumScale*matte.green*TroughModulate;
trough.blue=QuantumScale*matte.blue*TroughModulate;
+ trough.black=QuantumScale*matte.black*TroughModulate;
trough.alpha=matte.alpha;
- if (image->colorspace == CMYKColorspace)
- {
- ConvertRGBToCMYK(&interior);
- ConvertRGBToCMYK(&matte);
- ConvertRGBToCMYK(&border);
- ConvertRGBToCMYK(&accentuate);
- ConvertRGBToCMYK(&highlight);
- ConvertRGBToCMYK(&shadow);
- ConvertRGBToCMYK(&trough);
- }
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- frame_view=AcquireCacheView(frame_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ frame_view=AcquireAuthenticCacheView(frame_image,exception);
height=(size_t) (frame_info->outer_bevel+(frame_info->y-bevel_width)+
frame_info->inner_bevel);
if (height != 0)
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
/*
Draw top of ornamental border.
for (x=0; x < (ssize_t) (frame_image->columns-y); x++)
{
if (x < y)
- SetPixelPixelInfo(frame_image,&highlight,q);
+ SetPixelViaPixelInfo(frame_image,&highlight,q);
else
- SetPixelPixelInfo(frame_image,&accentuate,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&accentuate,q);
+ q+=GetPixelChannels(frame_image);
}
for ( ; x < (ssize_t) frame_image->columns; x++)
{
- SetPixelPixelInfo(frame_image,&shadow,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&shadow,q);
+ q+=GetPixelChannels(frame_image);
}
}
for (y=0; y < (ssize_t) (frame_info->y-bevel_width); y++)
{
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&highlight,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&highlight,q);
+ q+=GetPixelChannels(frame_image);
}
width=frame_image->columns-2*frame_info->outer_bevel;
for (x=0; x < (ssize_t) width; x++)
{
- SetPixelPixelInfo(frame_image,&matte,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&matte,q);
+ q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&shadow,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&shadow,q);
+ q+=GetPixelChannels(frame_image);
}
}
for (y=0; y < (ssize_t) frame_info->inner_bevel; y++)
{
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&highlight,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&highlight,q);
+ q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
{
- SetPixelPixelInfo(frame_image,&matte,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&matte,q);
+ q+=GetPixelChannels(frame_image);
}
width=image->columns+((size_t) frame_info->inner_bevel << 1)-
y;
for (x=0; x < (ssize_t) width; x++)
{
if (x < y)
- SetPixelPixelInfo(frame_image,&shadow,q);
+ SetPixelViaPixelInfo(frame_image,&shadow,q);
else
- SetPixelPixelInfo(frame_image,&trough,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&trough,q);
+ q+=GetPixelChannels(frame_image);
}
for ( ; x < (ssize_t) (image->columns+2*frame_info->inner_bevel); x++)
{
- SetPixelPixelInfo(frame_image,&highlight,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&highlight,q);
+ q+=GetPixelChannels(frame_image);
}
width=frame_info->width-frame_info->x-image->columns-bevel_width;
for (x=0; x < (ssize_t) width; x++)
{
- SetPixelPixelInfo(frame_image,&matte,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&matte,q);
+ q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&shadow,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&shadow,q);
+ q+=GetPixelChannels(frame_image);
}
}
(void) SyncCacheViewAuthenticPixels(frame_view,exception);
/*
Draw sides of ornamental border.
*/
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ magick_threads(image,frame_image,1,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
+
+ size_t
+ width;
/*
Initialize scanline with matte color.
continue;
q=QueueCacheViewAuthenticPixels(frame_view,0,frame_info->y+y,
frame_image->columns,1,exception);
- if (q == (const Quantum *) NULL)
+ if (q == (Quantum *) NULL)
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&highlight,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&highlight,q);
+ q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
{
- SetPixelPixelInfo(frame_image,&matte,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&matte,q);
+ q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&shadow,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&shadow,q);
+ q+=GetPixelChannels(frame_image);
}
/*
- Set frame interior to interior color.
+ Set frame interior pixels.
*/
- if ((image->compose != CopyCompositeOp) &&
- ((image->compose != OverCompositeOp) || (image->matte != MagickFalse)))
- for (x=0; x < (ssize_t) image->columns; x++)
- {
- SetPixelPixelInfo(frame_image,&interior,q);
- q+=GetPixelComponents(frame_image);
- }
- else
- {
- register const Quantum
- *p;
-
- p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
- if (p == (const Quantum *) NULL)
- {
- status=MagickFalse;
- continue;
- }
- for (x=0; x < (ssize_t) image->columns; x++)
- {
- SetPixelRed(frame_image,GetPixelRed(image,p),q);
- SetPixelGreen(frame_image,GetPixelGreen(image,p),q);
- SetPixelBlue(frame_image,GetPixelBlue(image,p),q);
- if (image->colorspace == CMYKColorspace)
- SetPixelBlack(frame_image,GetPixelBlack(image,p),q);
- SetPixelAlpha(frame_image,GetPixelAlpha(image,p),q);
- p+=GetPixelComponents(image);
- q+=GetPixelComponents(frame_image);
- }
- }
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ SetPixelViaPixelInfo(frame_image,&frame_image->border_color,q);
+ q+=GetPixelChannels(frame_image);
+ }
for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&highlight,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&highlight,q);
+ q+=GetPixelChannels(frame_image);
}
width=frame_info->width-frame_info->x-image->columns-bevel_width;
for (x=0; x < (ssize_t) width; x++)
{
- SetPixelPixelInfo(frame_image,&matte,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&matte,q);
+ q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&shadow,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&shadow,q);
+ q+=GetPixelChannels(frame_image);
}
if (SyncCacheViewAuthenticPixels(frame_view,exception) == MagickFalse)
status=MagickFalse;
MagickBooleanType
proceed;
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_FrameImage)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp critical (MagickCore_FrameImage)
#endif
proceed=SetImageProgress(image,FrameImageTag,progress++,image->rows);
if (proceed == MagickFalse)
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
/*
Draw bottom of ornamental border.
{
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&highlight,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&highlight,q);
+ q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
{
- SetPixelPixelInfo(frame_image,&matte,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&matte,q);
+ q+=GetPixelChannels(frame_image);
}
for (x=0; x < y; x++)
{
- SetPixelPixelInfo(frame_image,&shadow,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&shadow,q);
+ q+=GetPixelChannels(frame_image);
}
for ( ; x < (ssize_t) (image->columns+2*frame_info->inner_bevel); x++)
{
if (x >= (ssize_t) (image->columns+2*frame_info->inner_bevel-y))
- SetPixelPixelInfo(frame_image,&highlight,q);
+ SetPixelViaPixelInfo(frame_image,&highlight,q);
else
- SetPixelPixelInfo(frame_image,&accentuate,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&accentuate,q);
+ q+=GetPixelChannels(frame_image);
}
width=frame_info->width-frame_info->x-image->columns-bevel_width;
for (x=0; x < (ssize_t) width; x++)
{
- SetPixelPixelInfo(frame_image,&matte,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&matte,q);
+ q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&shadow,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&shadow,q);
+ q+=GetPixelChannels(frame_image);
}
}
height=frame_info->height-frame_info->y-image->rows-bevel_width;
{
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&highlight,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&highlight,q);
+ q+=GetPixelChannels(frame_image);
}
width=frame_image->columns-2*frame_info->outer_bevel;
for (x=0; x < (ssize_t) width; x++)
{
- SetPixelPixelInfo(frame_image,&matte,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&matte,q);
+ q+=GetPixelChannels(frame_image);
}
for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
{
- SetPixelPixelInfo(frame_image,&shadow,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&shadow,q);
+ q+=GetPixelChannels(frame_image);
}
}
for (y=frame_info->outer_bevel-1; y >= 0; y--)
{
for (x=0; x < y; x++)
{
- SetPixelPixelInfo(frame_image,&highlight,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&highlight,q);
+ q+=GetPixelChannels(frame_image);
}
for ( ; x < (ssize_t) frame_image->columns; x++)
{
if (x >= (ssize_t) (frame_image->columns-y))
- SetPixelPixelInfo(frame_image,&shadow,q);
+ SetPixelViaPixelInfo(frame_image,&shadow,q);
else
- SetPixelPixelInfo(frame_image,&trough,q);
- q+=GetPixelComponents(frame_image);
+ SetPixelViaPixelInfo(frame_image,&trough,q);
+ q+=GetPixelChannels(frame_image);
}
}
(void) SyncCacheViewAuthenticPixels(frame_view,exception);
}
frame_view=DestroyCacheView(frame_view);
image_view=DestroyCacheView(image_view);
- if ((image->compose != CopyCompositeOp) &&
- ((image->compose != OverCompositeOp) || (image->matte != MagickFalse)))
- {
- x=(ssize_t) (frame_info->outer_bevel+(frame_info->x-bevel_width)+
- frame_info->inner_bevel);
- y=(ssize_t) (frame_info->outer_bevel+(frame_info->y-bevel_width)+
- frame_info->inner_bevel);
- (void) CompositeImage(frame_image,image->compose,image,x,y);
- }
+ x=(ssize_t) (frame_info->outer_bevel+(frame_info->x-bevel_width)+
+ frame_info->inner_bevel);
+ y=(ssize_t) (frame_info->outer_bevel+(frame_info->y-bevel_width)+
+ frame_info->inner_bevel);
+ if (status != MagickFalse)
+ status=CompositeImage(frame_image,image,compose,MagickTrue,x,y,
+ exception);
+ if (status == MagickFalse)
+ frame_image=DestroyImage(frame_image);
return(frame_image);
}
\f
% The format of the RaiseImage method is:
%
% MagickBooleanType RaiseImage(const Image *image,
-% const RectangleInfo *raise_info,const MagickBooleanType raise)
+% const RectangleInfo *raise_info,const MagickBooleanType raise,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o raise: A value other than zero creates a 3-D raise effect,
% otherwise it has a lowered effect.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType RaiseImage(Image *image,
- const RectangleInfo *raise_info,const MagickBooleanType raise)
+ const RectangleInfo *raise_info,const MagickBooleanType raise,
+ ExceptionInfo *exception)
{
#define AccentuateFactor ScaleCharToQuantum(135)
#define HighlightFactor ScaleCharToQuantum(190)
CacheView
*image_view;
- ExceptionInfo
- *exception;
-
MagickBooleanType
status;
y;
assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
+ assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(raise_info != (RectangleInfo *) NULL);
(image->rows <= (raise_info->height << 1)))
ThrowBinaryException(OptionError,"ImageSizeMustExceedBevelWidth",
image->filename);
- foreground=(Quantum) QuantumRange;
+ foreground=QuantumRange;
background=(Quantum) 0;
if (raise == MagickFalse)
{
foreground=(Quantum) 0;
- background=(Quantum) QuantumRange;
+ background=QuantumRange;
}
- if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+ if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
/*
Raise image.
*/
status=MagickTrue;
progress=0;
- exception=(&image->exception);
- image_view=AcquireCacheView(image);
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
+ image_view=AcquireAuthenticCacheView(image,exception);
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ magick_threads(image,image,1,1)
#endif
for (y=0; y < (ssize_t) raise_info->height; y++)
{
register ssize_t
+ i,
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
- if (q == (const Quantum *) NULL)
+ if (q == (Quantum *) NULL)
{
status=MagickFalse;
continue;
}
for (x=0; x < y; x++)
{
- SetPixelRed(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelRed(image,q)*HighlightFactor+(MagickRealType) foreground*
- (QuantumRange-HighlightFactor))),q);
- SetPixelGreen(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelGreen(image,q)*HighlightFactor+(MagickRealType) foreground*
- (QuantumRange-HighlightFactor))),q);
- SetPixelBlue(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelBlue(image,q)*HighlightFactor+(MagickRealType) foreground*
- (QuantumRange-HighlightFactor))),q);
- q+=GetPixelComponents(image);
+ if (GetPixelWriteMask(image,q) == 0)
+ {
+ q+=GetPixelChannels(image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel channel=GetPixelChannelChannel(image,i);
+ PixelTrait traits=GetPixelChannelTraits(image,channel);
+ if ((traits & UpdatePixelTrait) == 0)
+ continue;
+ q[i]=ClampToQuantum(QuantumScale*((double) q[i]*HighlightFactor+(double)
+ foreground*(QuantumRange-HighlightFactor)));
+ }
+ q+=GetPixelChannels(image);
}
for ( ; x < (ssize_t) (image->columns-y); x++)
{
- SetPixelRed(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelRed(image,q)*AccentuateFactor+(MagickRealType) foreground*
- (QuantumRange-AccentuateFactor))),q);
- SetPixelGreen(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelGreen(image,q)*AccentuateFactor+(MagickRealType) foreground*
- (QuantumRange-AccentuateFactor))),q);
- SetPixelBlue(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelBlue(image,q)*AccentuateFactor+(MagickRealType) foreground*
- (QuantumRange-AccentuateFactor))),q);
- q+=GetPixelComponents(image);
+ if (GetPixelWriteMask(image,q) == 0)
+ {
+ q+=GetPixelChannels(image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel channel=GetPixelChannelChannel(image,i);
+ PixelTrait traits=GetPixelChannelTraits(image,channel);
+ if ((traits & UpdatePixelTrait) == 0)
+ continue;
+ q[i]=ClampToQuantum(QuantumScale*((double) q[i]*AccentuateFactor+
+ (double) foreground*(QuantumRange-AccentuateFactor)));
+ }
+ q+=GetPixelChannels(image);
}
for ( ; x < (ssize_t) image->columns; x++)
{
- SetPixelRed(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelRed(image,q)*ShadowFactor+(MagickRealType) background*
- (QuantumRange-ShadowFactor))),q);
- SetPixelGreen(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelGreen(image,q)*ShadowFactor+(MagickRealType) background*
- (QuantumRange-ShadowFactor))),q);
- SetPixelBlue(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelBlue(image,q)*ShadowFactor+(MagickRealType) background*
- (QuantumRange-ShadowFactor))),q);
- q+=GetPixelComponents(image);
+ if (GetPixelWriteMask(image,q) == 0)
+ {
+ q+=GetPixelChannels(image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel channel=GetPixelChannelChannel(image,i);
+ PixelTrait traits=GetPixelChannelTraits(image,channel);
+ if ((traits & UpdatePixelTrait) == 0)
+ continue;
+ q[i]=ClampToQuantum(QuantumScale*((double) q[i]*ShadowFactor+(double)
+ background*(QuantumRange-ShadowFactor)));
+ }
+ q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
MagickBooleanType
proceed;
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp critical (MagickCore_RaiseImage)
+#endif
proceed=SetImageProgress(image,RaiseImageTag,progress++,image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ magick_threads(image,image,1,1)
#endif
for (y=(ssize_t) raise_info->height; y < (ssize_t) (image->rows-raise_info->height); y++)
{
register ssize_t
+ i,
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
- if (q == (const Quantum *) NULL)
+ if (q == (Quantum *) NULL)
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) raise_info->width; x++)
{
- SetPixelRed(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelRed(image,q)*HighlightFactor+(MagickRealType) foreground*
- (QuantumRange-HighlightFactor))),q);
- SetPixelGreen(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelGreen(image,q)*HighlightFactor+(MagickRealType) foreground*
- (QuantumRange-HighlightFactor))),q);
- SetPixelBlue(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelBlue(image,q)*HighlightFactor+(MagickRealType) foreground*
- (QuantumRange-HighlightFactor))),q);
- q+=GetPixelComponents(image);
+ if (GetPixelWriteMask(image,q) == 0)
+ {
+ q+=GetPixelChannels(image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel channel=GetPixelChannelChannel(image,i);
+ PixelTrait traits=GetPixelChannelTraits(image,channel);
+ if ((traits & UpdatePixelTrait) == 0)
+ continue;
+ q[i]=ClampToQuantum(QuantumScale*((double) q[i]*HighlightFactor+(double)
+ foreground*(QuantumRange-HighlightFactor)));
+ }
+ q+=GetPixelChannels(image);
}
for ( ; x < (ssize_t) (image->columns-raise_info->width); x++)
- q+=GetPixelComponents(image);
+ q+=GetPixelChannels(image);
for ( ; x < (ssize_t) image->columns; x++)
{
- SetPixelRed(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelRed(image,q)*ShadowFactor+(MagickRealType) background*
- (QuantumRange-ShadowFactor))),q);
- SetPixelGreen(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelGreen(image,q)*ShadowFactor+(MagickRealType) background*
- (QuantumRange-ShadowFactor))),q);
- SetPixelBlue(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelBlue(image,q)*ShadowFactor+(MagickRealType) background*
- (QuantumRange-ShadowFactor))),q);
- q+=GetPixelComponents(image);
+ if (GetPixelWriteMask(image,q) == 0)
+ {
+ q+=GetPixelChannels(image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel channel=GetPixelChannelChannel(image,i);
+ PixelTrait traits=GetPixelChannelTraits(image,channel);
+ if ((traits & UpdatePixelTrait) == 0)
+ continue;
+ q[i]=ClampToQuantum(QuantumScale*((double) q[i]*ShadowFactor+(double)
+ background*(QuantumRange-ShadowFactor)));
+ }
+ q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
MagickBooleanType
proceed;
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp critical (MagickCore_RaiseImage)
+#endif
proceed=SetImageProgress(image,RaiseImageTag,progress++,image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ magick_threads(image,image,1,1)
#endif
for (y=(ssize_t) (image->rows-raise_info->height); y < (ssize_t) image->rows; y++)
{
register ssize_t
+ i,
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
- if (q == (const Quantum *) NULL)
+ if (q == (Quantum *) NULL)
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) (image->rows-y); x++)
{
- SetPixelRed(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelRed(image,q)*HighlightFactor+(MagickRealType) foreground*
- (QuantumRange-HighlightFactor))),q);
- SetPixelGreen(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelGreen(image,q)*HighlightFactor+(MagickRealType) foreground*
- (QuantumRange-HighlightFactor))),q);
- SetPixelBlue(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelBlue(image,q)*HighlightFactor+(MagickRealType) foreground*
- (QuantumRange-HighlightFactor))),q);
- q+=GetPixelComponents(image);
+ if (GetPixelWriteMask(image,q) == 0)
+ {
+ q+=GetPixelChannels(image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel channel=GetPixelChannelChannel(image,i);
+ PixelTrait traits=GetPixelChannelTraits(image,channel);
+ if ((traits & UpdatePixelTrait) == 0)
+ continue;
+ q[i]=ClampToQuantum(QuantumScale*((double) q[i]*HighlightFactor+(double)
+ foreground*(QuantumRange-HighlightFactor)));
+ }
+ q+=GetPixelChannels(image);
}
for ( ; x < (ssize_t) (image->columns-(image->rows-y)); x++)
{
- SetPixelRed(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelRed(image,q)*TroughFactor+(MagickRealType) background*
- (QuantumRange-TroughFactor))),q);
- SetPixelGreen(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelGreen(image,q)*TroughFactor+(MagickRealType) background*
- (QuantumRange-TroughFactor))),q);
- SetPixelBlue(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelBlue(image,q)*TroughFactor+(MagickRealType) background*
- (QuantumRange-TroughFactor))),q);
- q+=GetPixelComponents(image);
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel channel=GetPixelChannelChannel(image,i);
+ PixelTrait traits=GetPixelChannelTraits(image,channel);
+ if ((traits & UpdatePixelTrait) == 0)
+ continue;
+ q[i]=ClampToQuantum(QuantumScale*((double) q[i]*TroughFactor+
+ (double) background*(QuantumRange-TroughFactor)));
+ }
+ q+=GetPixelChannels(image);
}
for ( ; x < (ssize_t) image->columns; x++)
{
- SetPixelRed(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelRed(image,q)*ShadowFactor+(MagickRealType) background*
- (QuantumRange-ShadowFactor))),q);
- SetPixelGreen(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelGreen(image,q)*ShadowFactor+(MagickRealType) background*
- (QuantumRange-ShadowFactor))),q);
- SetPixelBlue(image,ClampToQuantum(QuantumScale*((MagickRealType)
- GetPixelBlue(image,q)*ShadowFactor+(MagickRealType) background*
- (QuantumRange-ShadowFactor))),q);
- q+=GetPixelComponents(image);
+ if (GetPixelWriteMask(image,q) == 0)
+ {
+ q+=GetPixelChannels(image);
+ continue;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel channel=GetPixelChannelChannel(image,i);
+ PixelTrait traits=GetPixelChannelTraits(image,channel);
+ if ((traits & UpdatePixelTrait) == 0)
+ continue;
+ q[i]=ClampToQuantum(QuantumScale*((double) q[i]*ShadowFactor+(double)
+ background*(QuantumRange-ShadowFactor)));
+ }
+ q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_RaiseImage)
+ #pragma omp critical (MagickCore_RaiseImage)
#endif
proceed=SetImageProgress(image,RaiseImageTag,progress++,image->rows);
if (proceed == MagickFalse)
projects / imagemagick / blobdiff