}
// Specify drawing fill alpha
-Magick::DrawableFillOpacity::~DrawableFillOpacity ( void )
+Magick::DrawableFillAlpha::~DrawableFillAlpha ( void )
{
}
-void Magick::DrawableFillOpacity::operator()
+void Magick::DrawableFillAlpha::operator()
( MagickCore::DrawingWand * context_ ) const
{
- DrawSetFillOpacity( context_, _alpha );
+ DrawSetFillAlpha( context_, _alpha );
}
-Magick::DrawableBase* Magick::DrawableFillOpacity::copy() const
+Magick::DrawableBase* Magick::DrawableFillAlpha::copy() const
{
- return new DrawableFillOpacity(*this);
+ return new DrawableFillAlpha(*this);
}
// Specify text font
}
// Stroke alpha
-Magick::DrawableStrokeOpacity::~DrawableStrokeOpacity ( void )
+Magick::DrawableStrokeAlpha::~DrawableStrokeAlpha ( void )
{
}
-void Magick::DrawableStrokeOpacity::operator()
+void Magick::DrawableStrokeAlpha::operator()
( MagickCore::DrawingWand * context_ ) const
{
- DrawSetStrokeOpacity( context_, _alpha );
+ DrawSetStrokeAlpha( context_, _alpha );
}
-Magick::DrawableBase* Magick::DrawableStrokeOpacity::copy() const
+Magick::DrawableBase* Magick::DrawableStrokeAlpha::copy() const
{
- return new DrawableStrokeOpacity(*this);
+ return new DrawableStrokeAlpha(*this);
}
// Stroke width
// Floodfill pixels matching color (within fuzz factor) of target
// pixel(x,y) with replacement alpha value using method.
-void Magick::Image::floodFillOpacity( const ssize_t x_,
+void Magick::Image::floodFillAlpha( const ssize_t x_,
const ssize_t y_,
const unsigned int alpha_,
const PaintMethod method_ )
void Magick::Image::alpha ( const unsigned int alpha_ )
{
modifyImage();
- SetImageOpacity( image(), alpha_ );
+ SetImageAlpha( image(), alpha_ );
}
// Change the color of an opaque pixel to the pen color.
// desired, then set the matte channel to opaque.
if ((matteFlag_ && !constImage()->matte) ||
(constImage()->matte && !matteFlag_))
- SetImageOpacity(image(),OpaqueAlpha);
+ SetImageAlpha(image(),OpaqueAlpha);
image()->matte = (MagickBooleanType) matteFlag_;
}
};
// Specify drawing fill alpha
-class MagickPPExport DrawableFillOpacity : public DrawableBase
+class MagickPPExport DrawableFillAlpha : public DrawableBase
{
public:
- DrawableFillOpacity ( double alpha_ )
+ DrawableFillAlpha ( double alpha_ )
: _alpha(alpha_)
{
}
- /*virtual*/ ~DrawableFillOpacity ( void );
+ /*virtual*/ ~DrawableFillAlpha ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
};
// Stroke alpha
-class MagickPPExport DrawableStrokeOpacity : public DrawableBase
+class MagickPPExport DrawableStrokeAlpha : public DrawableBase
{
public:
- DrawableStrokeOpacity ( double alpha_ )
+ DrawableStrokeAlpha ( double alpha_ )
: _alpha(alpha_)
{
}
- /*virtual*/ ~DrawableStrokeOpacity ( void );
+ /*virtual*/ ~DrawableStrokeAlpha ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Floodfill pixels matching color (within fuzz factor) of target
// pixel(x,y) with replacement alpha value using method.
- void floodFillOpacity ( const ::ssize_t x_,
+ void floodFillAlpha ( const ::ssize_t x_,
const ::ssize_t y_,
const unsigned int alpha_,
const PaintMethod method_ );
using MagickCore::MagentaChannel;
using MagickCore::BlueChannel;
using MagickCore::YellowChannel;
- using MagickCore::OpacityChannel;
+ using MagickCore::AlphaChannel;
using MagickCore::BlackChannel;
using MagickCore::DefaultChannels;
using MagickCore::AllChannels;
using MagickCore::DrawSetClipRule;
using MagickCore::DrawSetClipUnits;
using MagickCore::DrawSetFillColor;
- using MagickCore::DrawSetFillOpacity;
+ using MagickCore::DrawSetFillAlpha;
using MagickCore::DrawSetFillPatternURL;
using MagickCore::DrawSetFillRule;
using MagickCore::DrawSetFont;
using MagickCore::DrawSetStrokeLineCap;
using MagickCore::DrawSetStrokeLineJoin;
using MagickCore::DrawSetStrokeMiterLimit;
- using MagickCore::DrawSetStrokeOpacity;
+ using MagickCore::DrawSetStrokeAlpha;
using MagickCore::DrawSetStrokePatternURL;
using MagickCore::DrawSetStrokeWidth;
using MagickCore::DrawSetTextAntialias;
using MagickCore::SetImageExtent;
using MagickCore::SetImageInfo;
using MagickCore::SetImageInfoFile;
- using MagickCore::SetImageOpacity;
+ using MagickCore::SetImageAlpha;
using MagickCore::SetImageOption;
using MagickCore::SetImageProfile;
using MagickCore::SetImageProperty;
(void) SetImageAlphaChannel(composite_image,OpaqueAlphaChannel,
exception);
if (draw_info->alpha != OpaqueAlpha)
- (void) SetImageOpacity(composite_image,draw_info->alpha);
+ (void) SetImageAlpha(composite_image,draw_info->alpha);
SetGeometry(image,&geometry);
image->gravity=draw_info->gravity;
geometry.x=x;
}
case OpaqueAlphaChannel:
{
- status=SetImageOpacity(image,OpaqueAlpha);
+ status=SetImageAlpha(image,OpaqueAlpha);
image->matte=MagickTrue;
break;
}
case TransparentAlphaChannel:
{
- status=SetImageOpacity(image,TransparentAlpha);
+ status=SetImageAlpha(image,TransparentAlpha);
image->matte=MagickTrue;
break;
}
{
if (image->matte == MagickFalse)
{
- status=SetImageOpacity(image,OpaqueAlpha);
+ status=SetImageAlpha(image,OpaqueAlpha);
image->matte=MagickTrue;
}
break;
% %
% %
% %
-% S e t I m a g e O p a c i t y %
+% S e t I m a g e A l p h a %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% SetImageOpacity() sets the opacity levels of the image.
+% SetImageAlphs() sets the alpha levels of the image.
%
-% The format of the SetImageOpacity method is:
+% The format of the SetImageAlpha method is:
%
-% MagickBooleanType SetImageOpacity(Image *image,const Quantum opacity)
+% MagickBooleanType SetImageAlpha(Image *image,const Quantum alpha)
%
% A description of each parameter follows:
%
% o image: the image.
%
-% o opacity: the level of transparency: 0 is fully opaque and QuantumRange is
+% o Alpha: the level of transparency: 0 is fully opaque and QuantumRange is
% fully transparent.
%
*/
-MagickExport MagickBooleanType SetImageOpacity(Image *image,
- const Quantum opacity)
+MagickExport MagickBooleanType SetImageAlpha(Image *image,const Quantum alpha)
{
CacheView
*image_view;
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(image->signature == MagickSignature);
- image->matte=opacity != OpaqueAlpha ? MagickTrue : MagickFalse;
+ image->matte=alpha != OpaqueAlpha ? MagickTrue : MagickFalse;
status=MagickTrue;
exception=(&image->exception);
image_view=AcquireCacheView(image);
}
for (x=0; x < (ssize_t) image->columns; x++)
{
- SetPixelAlpha(image,opacity,q);
+ SetPixelAlpha(image,alpha,q);
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
ModifyImage(Image **,ExceptionInfo *),
ResetImagePage(Image *,const char *),
SeparateImage(Image *),
+ SetImageAlpha(Image *,const Quantum),
SetImageAlphaChannel(Image *,const AlphaChannelType,ExceptionInfo *),
SetImageBackgroundColor(Image *),
SetImageClipMask(Image *,const Image *,ExceptionInfo *),
SetImageExtent(Image *,const size_t,const size_t,ExceptionInfo *),
SetImageInfo(ImageInfo *,const unsigned int,ExceptionInfo *),
SetImageMask(Image *,const Image *,ExceptionInfo *),
- SetImageOpacity(Image *,const Quantum),
SetImageStorageClass(Image *,const ClassType,ExceptionInfo *),
SetImageType(Image *,const ImageType,ExceptionInfo *),
StripImage(Image *),
/* #undef AUTOTRACE_DELEGATE */
/* Define if coders and filters are to be built as modules. */
-/* #undef BUILD_MODULES */
+#ifndef MAGICKCORE_BUILD_MODULES
+#define MAGICKCORE_BUILD_MODULES 1
+#endif
/* Define if you have the bzip2 library */
#ifndef MAGICKCORE_BZLIB_DELEGATE
#endif
/* Define if you have FFTW library */
-/* #undef FFTW_DELEGATE */
+#ifndef MAGICKCORE_FFTW_DELEGATE
+#define MAGICKCORE_FFTW_DELEGATE 1
+#endif
/* Location of filter modules */
#ifndef MAGICKCORE_FILTER_PATH
#endif
/* Define to 1 if you have the <CL/cl.h> header file. */
-/* #undef HAVE_CL_CL_H */
+#ifndef MAGICKCORE_HAVE_CL_CL_H
+#define MAGICKCORE_HAVE_CL_CL_H 1
+#endif
/* Define to 1 if you have the <complex.h> header file. */
#ifndef MAGICKCORE_HAVE_COMPLEX_H
#endif
/* Define if you have the <lcms2.h> header file. */
-#ifndef MAGICKCORE_HAVE_LCMS2_H
-#define MAGICKCORE_HAVE_LCMS2_H 1
-#endif
+/* #undef HAVE_LCMS2_H */
/* Define if you have the <lcms2/lcms2.h> header file. */
/* #undef HAVE_LCMS2_LCMS2_H */
/* Define if you have the <lcms.h> header file. */
-/* #undef HAVE_LCMS_H */
+#ifndef MAGICKCORE_HAVE_LCMS_H
+#define MAGICKCORE_HAVE_LCMS_H 1
+#endif
/* Define if you have the <lcms/lcms.h> header file. */
/* #undef HAVE_LCMS_LCMS_H */
#endif
/* Define if you have JBIG library */
-/* #undef JBIG_DELEGATE */
+#ifndef MAGICKCORE_JBIG_DELEGATE
+#define MAGICKCORE_JBIG_DELEGATE 1
+#endif
/* Define if you have JPEG version 2 "Jasper" library */
#ifndef MAGICKCORE_JP2_DELEGATE
#endif
/* Define if you have LQR library */
-/* #undef LQR_DELEGATE */
+#ifndef MAGICKCORE_LQR_DELEGATE
+#define MAGICKCORE_LQR_DELEGATE 1
+#endif
/* Define if using libltdl to support dynamically loadable modules */
#ifndef MAGICKCORE_LTDL_DELEGATE
/* Define to the system default library search path. */
#ifndef MAGICKCORE_LT_DLSEARCH_PATH
-#define MAGICKCORE_LT_DLSEARCH_PATH "/lib64:/usr/lib64:/lib:/usr/lib:/usr/lib64/atlas:/usr/lib/llvm:/usr/lib64/llvm:/usr/lib64/mysql:/usr/lib64/qt-3.3/lib:/usr/lib64/tcl8.5/tclx8.4:/usr/lib64/tcl8.5:/usr/lib/wine/:/usr/lib64/wine/:/usr/lib64/xulrunner-2"
+#define MAGICKCORE_LT_DLSEARCH_PATH "/lib64:/usr/lib64:/lib:/usr/lib:/usr/lib64/R/lib:/usr/lib64/atlas:/opt/modules/pkg/intel/f77/10.0.025/lib:/opt/intel/lib/intel64:/usr/lib64/llvm:/usr/local/lib:/usr/lib64/mysql:/usr/lib64/nvidia:/usr/lib64/qt-3.3/lib:/usr/lib64/xulrunner-2"
#endif
/* The archive extension */
/* #undef NO_MINUS_C_MINUS_O */
/* Define if you have OPENEXR library */
-/* #undef OPENEXR_DELEGATE */
+#ifndef MAGICKCORE_OPENEXR_DELEGATE
+#define MAGICKCORE_OPENEXR_DELEGATE 1
+#endif
/* Define to the address where bug reports for this package should be sent. */
#ifndef MAGICKCORE_PACKAGE_BUGREPORT
#endif
/* Define if you have RSVG library */
-/* #undef RSVG_DELEGATE */
+#ifndef MAGICKCORE_RSVG_DELEGATE
+#define MAGICKCORE_RSVG_DELEGATE 1
+#endif
/* Define to the type of arg 1 for `select'. */
#ifndef MAGICKCORE_SELECT_TYPE_ARG1
/* Define if you have WEBP library */
-/* #undef WEBP_DELEGATE */
+#ifndef MAGICKCORE_WEBP_DELEGATE
+#define MAGICKCORE_WEBP_DELEGATE 1
+#endif
/* Define to use the Windows GDI32 library */
/* #undef WINGDI32_DELEGATE */
/* #undef WITH_DMALLOC */
/* Define if you have WMF library */
-/* #undef WMF_DELEGATE */
+#ifndef MAGICKCORE_WMF_DELEGATE
+#define MAGICKCORE_WMF_DELEGATE 1
+#endif
/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
significant byte first (like Motorola and SPARC, unlike Intel). */
/* #undef _MINIX */
/* Define this for the OpenCL Accelerator */
-/* #undef _OPENCL */
+#ifndef MAGICKCORE__OPENCL
+#define MAGICKCORE__OPENCL 1
+#endif
/* Define to 2 if the system does not provide POSIX.1 features except with
this defined. */
*/
#define MagickPackageName "ImageMagick"
#define MagickCopyright "Copyright (C) 1999-2011 ImageMagick Studio LLC"
-#define MagickSVNRevision "5481"
+#define MagickSVNRevision "exported"
#define MagickLibVersion 0x700
#define MagickLibVersionText "7.0.0"
#define MagickLibVersionNumber 7,0,0
channel_distortion[BlueChannel]);
if (image->matte != MagickFalse)
(void) FormatLocaleFile(stderr," alpha: %g (%g)\n",
- QuantumRange*channel_distortion[OpacityChannel],
- channel_distortion[OpacityChannel]);
+ QuantumRange*channel_distortion[AlphaChannel],
+ channel_distortion[AlphaChannel]);
break;
}
case CMYKColorspace:
channel_distortion[BlackChannel]);
if (image->matte != MagickFalse)
(void) FormatLocaleFile(stderr," alpha: %g (%g)\n",
- QuantumRange*channel_distortion[OpacityChannel],
- channel_distortion[OpacityChannel]);
+ QuantumRange*channel_distortion[AlphaChannel],
+ channel_distortion[AlphaChannel]);
break;
}
case GRAYColorspace:
channel_distortion[GrayChannel]);
if (image->matte != MagickFalse)
(void) FormatLocaleFile(stderr," alpha: %g (%g)\n",
- QuantumRange*channel_distortion[OpacityChannel],
- channel_distortion[OpacityChannel]);
+ QuantumRange*channel_distortion[AlphaChannel],
+ channel_distortion[AlphaChannel]);
break;
}
}
channel_distortion[BlueChannel]);
if (image->matte != MagickFalse)
(void) FormatLocaleFile(stderr," alpha: %g\n",
- channel_distortion[OpacityChannel]);
+ channel_distortion[AlphaChannel]);
break;
}
case CMYKColorspace:
channel_distortion[BlackChannel]);
if (image->matte != MagickFalse)
(void) FormatLocaleFile(stderr," alpha: %g\n",
- channel_distortion[OpacityChannel]);
+ channel_distortion[AlphaChannel]);
break;
}
case GRAYColorspace:
channel_distortion[GrayChannel]);
if (image->matte != MagickFalse)
(void) FormatLocaleFile(stderr," alpha: %g\n",
- channel_distortion[OpacityChannel]);
+ channel_distortion[AlphaChannel]);
break;
}
}
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% DrawGetFillOpacity() returns the opacity used when drawing using the fill
+% DrawGetFillAlpha() returns the alpha used when drawing using the fill
% color or fill texture. Fully opaque is 1.0.
%
-% The format of the DrawGetFillOpacity method is:
+% The format of the DrawGetFillAlpha method is:
%
-% double DrawGetFillOpacity(const DrawingWand *wand)
+% double DrawGetFillAlpha(const DrawingWand *wand)
%
% A description of each parameter follows:
%
% o wand: the drawing wand.
%
*/
-WandExport double DrawGetFillOpacity(const DrawingWand *wand)
+WandExport double DrawGetFillAlpha(const DrawingWand *wand)
{
double
alpha;
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% DrawGetOpacity() returns the opacity used when drawing with the fill
+% DrawGetAlpha() returns the alpha used when drawing with the fill
% or stroke color or texture. Fully opaque is 1.0.
%
-% The format of the DrawGetOpacity method is:
+% The format of the DrawGetAlpha method is:
%
-% double DrawGetOpacity(const DrawingWand *wand)
+% double DrawGetAlpha(const DrawingWand *wand)
%
% A description of each parameter follows:
%
% o wand: the drawing wand.
%
*/
-WandExport double DrawGetOpacity(const DrawingWand *wand)
+WandExport double DrawGetAlpha(const DrawingWand *wand)
{
double
alpha;
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% DrawGetStrokeOpacity() returns the opacity of stroked object outlines.
+% DrawGetStrokeAlpha() returns the alpha of stroked object outlines.
%
-% The format of the DrawGetStrokeOpacity method is:
+% The format of the DrawGetStrokeAlpha method is:
%
-% double DrawGetStrokeOpacity(const DrawingWand *wand)
+% double DrawGetStrokeAlpha(const DrawingWand *wand)
%
% A description of each parameter follows:
%
% o wand: the drawing wand.
%
*/
-WandExport double DrawGetStrokeOpacity(const DrawingWand *wand)
+WandExport double DrawGetStrokeAlpha(const DrawingWand *wand)
{
double
alpha;
GetColorTuple(&pixel,MagickTrue,value);
(void) SetXMLTreeContent(child,value);
}
- child=AddChildToXMLTree(xml_info,"fill-opacity",0);
+ child=AddChildToXMLTree(xml_info,"fill-alpha",0);
if (child != (XMLTreeInfo *) NULL)
{
(void) FormatLocaleString(value,MaxTextExtent,"%g",
CurrentContext->miterlimit);
(void) SetXMLTreeContent(child,value);
}
- child=AddChildToXMLTree(xml_info,"stroke-opacity",0);
+ child=AddChildToXMLTree(xml_info,"stroke-alpha",0);
if (child != (XMLTreeInfo *) NULL)
{
(void) FormatLocaleString(value,MaxTextExtent,"%g",
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% DrawLine() draws a line on the image using the current stroke color,
-% stroke opacity, and stroke width.
+% stroke alpha, and stroke width.
%
% The format of the DrawLine method is:
%
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% DrawMatte() paints on the image's opacity channel in order to set effected
+% DrawMatte() paints on the image's alpha channel in order to set effected
% pixels to transparent.
-% to influence the opacity of pixels. The available paint
+% to influence the alpha of pixels. The available paint
% methods are:
%
% PointMethod: Select the target pixel
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% DrawSetFillOpacity() sets the opacity to use when drawing using the fill
+% DrawSetFillAlpha() sets the alpha to use when drawing using the fill
% color or fill texture. Fully opaque is 1.0.
%
-% The format of the DrawSetFillOpacity method is:
+% The format of the DrawSetFillAlpha method is:
%
-% void DrawSetFillOpacity(DrawingWand *wand,const double fill_opacity)
+% void DrawSetFillAlpha(DrawingWand *wand,const double fill_alpha)
%
% A description of each parameter follows:
%
% o wand: the drawing wand.
%
-% o fill_opacity: fill opacity
+% o fill_alpha: fill alpha
%
*/
-WandExport void DrawSetFillOpacity(DrawingWand *wand,const double fill_opacity)
+WandExport void DrawSetFillAlpha(DrawingWand *wand,const double fill_alpha)
{
Quantum
- opacity;
+ alpha;
assert(wand != (DrawingWand *) NULL);
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- opacity=ClampToQuantum((double) QuantumRange*(1.0-fill_opacity));
+ alpha=ClampToQuantum((double) QuantumRange*(1.0-fill_alpha));
if ((wand->filter_off != MagickFalse) ||
- (CurrentContext->fill.alpha != opacity))
+ (CurrentContext->fill.alpha != alpha))
{
- CurrentContext->fill.alpha=opacity;
- (void) MvgPrintf(wand,"fill-opacity %g\n",fill_opacity);
+ CurrentContext->fill.alpha=alpha;
+ (void) MvgPrintf(wand,"fill-alpha %g\n",fill_alpha);
}
}
\f
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% DrawSetOpacity() sets the opacity to use when drawing using the fill or
+% DrawSetAlpha() sets the alpha to use when drawing using the fill or
% stroke color or texture. Fully opaque is 1.0.
%
-% The format of the DrawSetOpacity method is:
+% The format of the DrawSetAlpha method is:
%
-% void DrawSetOpacity(DrawingWand *wand,const double opacity)
+% void DrawSetAlpha(DrawingWand *wand,const double alpha)
%
% A description of each parameter follows:
%
% o wand: the drawing wand.
%
-% o opacity: fill opacity
+% o alpha: fill alpha
%
*/
-WandExport void DrawSetOpacity(DrawingWand *wand,const double opacity)
+WandExport void DrawSetAlpha(DrawingWand *wand,const double alpha)
{
Quantum
- quantum_opacity;
+ quantum_alpha;
assert(wand != (DrawingWand *) NULL);
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- quantum_opacity=ClampToQuantum((double) QuantumRange*(1.0-opacity));
+ quantum_alpha=ClampToQuantum((double) QuantumRange*(1.0-alpha));
if ((wand->filter_off != MagickFalse) ||
- (CurrentContext->alpha != quantum_opacity))
+ (CurrentContext->alpha != quantum_alpha))
{
- CurrentContext->alpha=(Quantum) opacity;
- (void) MvgPrintf(wand,"opacity %g\n",opacity);
+ CurrentContext->alpha=(Quantum) alpha;
+ (void) MvgPrintf(wand,"alpha %g\n",alpha);
}
}
\f
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% DrawSetStrokeOpacity() specifies the opacity of stroked object outlines.
+% DrawSetStrokeAlpha() specifies the alpha of stroked object outlines.
%
-% The format of the DrawSetStrokeOpacity method is:
+% The format of the DrawSetStrokeAlpha method is:
%
-% void DrawSetStrokeOpacity(DrawingWand *wand,
-% const double stroke_opacity)
+% void DrawSetStrokeAlpha(DrawingWand *wand,
+% const double stroke_alpha)
%
% A description of each parameter follows:
%
% o wand: the drawing wand.
%
-% o stroke_opacity: stroke opacity. The value 1.0 is opaque.
+% o stroke_alpha: stroke alpha. The value 1.0 is opaque.
%
*/
-WandExport void DrawSetStrokeOpacity(DrawingWand *wand,
- const double stroke_opacity)
+WandExport void DrawSetStrokeAlpha(DrawingWand *wand,
+ const double stroke_alpha)
{
Quantum
- opacity;
+ alpha;
assert(wand != (DrawingWand *) NULL);
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- opacity=ClampToQuantum((double) QuantumRange*(1.0-stroke_opacity));
+ alpha=ClampToQuantum((double) QuantumRange*(1.0-stroke_alpha));
if ((wand->filter_off != MagickFalse) ||
- (CurrentContext->stroke.alpha != opacity))
+ (CurrentContext->stroke.alpha != alpha))
{
- CurrentContext->stroke.alpha=opacity;
- (void) MvgPrintf(wand,"stroke-opacity %g\n",stroke_opacity);
+ CurrentContext->stroke.alpha=alpha;
+ (void) MvgPrintf(wand,"stroke-alpha %g\n",stroke_alpha);
}
}
\f
(void) QueryColorCompliance(value,AllCompliance,&CurrentContext->fill,
wand->exception);
}
- child=GetXMLTreeChild(xml_info,"fill-opacity");
+ child=GetXMLTreeChild(xml_info,"fill-alpha");
if (child != (XMLTreeInfo *) NULL)
{
value=GetXMLTreeContent(child);
if (value != (const char *) NULL)
CurrentContext->miterlimit=StringToUnsignedLong(value);
}
- child=GetXMLTreeChild(xml_info,"stroke-opacity");
+ child=GetXMLTreeChild(xml_info,"stroke-alpha");
if (child != (XMLTreeInfo *) NULL)
{
value=GetXMLTreeContent(child);
DrawGetTextDecoration(const DrawingWand *);
extern WandExport double
- DrawGetFillOpacity(const DrawingWand *),
+ DrawGetFillAlpha(const DrawingWand *),
DrawGetFontSize(const DrawingWand *),
- DrawGetOpacity(const DrawingWand *),
+ DrawGetAlpha(const DrawingWand *),
*DrawGetStrokeDashArray(const DrawingWand *,size_t *),
DrawGetStrokeDashOffset(const DrawingWand *),
- DrawGetStrokeOpacity(const DrawingWand *),
+ DrawGetStrokeAlpha(const DrawingWand *),
DrawGetStrokeWidth(const DrawingWand *),
DrawGetTextKerning(DrawingWand *),
DrawGetTextInterlineSpacing(DrawingWand *),
DrawSetClipRule(DrawingWand *,const FillRule),
DrawSetClipUnits(DrawingWand *,const ClipPathUnits),
DrawSetFillColor(DrawingWand *,const PixelWand *),
- DrawSetFillOpacity(DrawingWand *,const double),
+ DrawSetFillAlpha(DrawingWand *,const double),
DrawSetFillRule(DrawingWand *,const FillRule),
DrawSetFontSize(DrawingWand *,const double),
DrawSetFontStretch(DrawingWand *,const StretchType),
DrawSetFontStyle(DrawingWand *,const StyleType),
DrawSetFontWeight(DrawingWand *,const size_t),
DrawSetGravity(DrawingWand *,const GravityType),
- DrawSetOpacity(DrawingWand *,const double),
+ DrawSetAlpha(DrawingWand *,const double),
DrawSetStrokeAntialias(DrawingWand *,const MagickBooleanType),
DrawSetStrokeColor(DrawingWand *,const PixelWand *),
DrawSetStrokeDashOffset(DrawingWand *,const double dashoffset),
DrawSetStrokeLineCap(DrawingWand *,const LineCap),
DrawSetStrokeLineJoin(DrawingWand *,const LineJoin),
DrawSetStrokeMiterLimit(DrawingWand *,const size_t),
- DrawSetStrokeOpacity(DrawingWand *, const double),
+ DrawSetStrokeAlpha(DrawingWand *, const double),
DrawSetStrokeWidth(DrawingWand *,const double),
DrawSetTextAlignment(DrawingWand *,const AlignType),
DrawSetTextAntialias(DrawingWand *,const MagickBooleanType),
(void) PixelSetColor(color,"#ffffff");
DrawSetFillColor(picasso,color);
DrawRectangle(picasso,23.69,22.97,564.6,802.2);
- DrawSetFillOpacity(picasso,1.0);
+ DrawSetFillAlpha(picasso,1.0);
(void) PixelSetColor(color,"none");
DrawSetFillColor(picasso,color);
DrawSetStrokeColor(picasso,color);
(void) FormatLocaleString(thresholds,MaxTextExtent,
QuantumFormat "," QuantumFormat "," QuantumFormat "," QuantumFormat,
PixelGetRedQuantum(threshold),PixelGetGreenQuantum(threshold),
- PixelGetBlueQuantum(threshold),PixelGetOpacityQuantum(threshold));
+ PixelGetBlueQuantum(threshold),PixelGetAlphaQuantum(threshold));
status=BlackThresholdImage(wand->images,thresholds,&wand->images->exception);
if (status == MagickFalse)
InheritException(wand->exception,&wand->images->exception);
% The format of the MagickColorizeImage method is:
%
% MagickBooleanType MagickColorizeImage(MagickWand *wand,
-% const PixelWand *colorize,const PixelWand *opacity)
+% const PixelWand *colorize,const PixelWand *alpha)
%
% A description of each parameter follows:
%
%
% o colorize: the colorize pixel wand.
%
-% o opacity: the opacity pixel wand.
+% o alpha: the alpha pixel wand.
%
*/
WandExport MagickBooleanType MagickColorizeImage(MagickWand *wand,
- const PixelWand *colorize,const PixelWand *opacity)
+ const PixelWand *colorize,const PixelWand *alpha)
{
char
percent_opaque[MaxTextExtent];
ThrowWandException(WandError,"ContainsNoImages",wand->name);
(void) FormatLocaleString(percent_opaque,MaxTextExtent,
"%g,%g,%g,%g",(double) (100.0*QuantumScale*
- PixelGetRedQuantum(opacity)),(double) (100.0*QuantumScale*
- PixelGetGreenQuantum(opacity)),(double) (100.0*QuantumScale*
- PixelGetBlueQuantum(opacity)),(double) (100.0*QuantumScale*
- PixelGetOpacityQuantum(opacity)));
+ PixelGetRedQuantum(alpha)),(double) (100.0*QuantumScale*
+ PixelGetGreenQuantum(alpha)),(double) (100.0*QuantumScale*
+ PixelGetBlueQuantum(alpha)),(double) (100.0*QuantumScale*
+ PixelGetAlphaQuantum(alpha)));
PixelGetQuantumPacket(colorize,&target);
colorize_image=ColorizeImage(wand->images,percent_opaque,target,
wand->exception);
%
% o map: This string reflects the expected ordering of the pixel array.
% It can be any combination or order of R = red, G = green, B = blue,
-% A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
+% A = alpha (0 is transparent), O = alpha (0 is opaque), C = cyan,
% Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
% P = pad.
%
%
% o map: This string reflects the expected ordering of the pixel array.
% It can be any combination or order of R = red, G = green, B = blue,
-% A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
+% A = alpha (0 is transparent), O = alpha (0 is opaque), C = cyan,
% Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
% P = pad.
%
%
% o map: This string reflects the expected ordering of the pixel array.
% It can be any combination or order of R = red, G = green, B = blue,
-% A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
+% A = alpha (0 is transparent), O = alpha (0 is opaque), C = cyan,
% Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
% P = pad.
%
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
if ((wand->images->matte == MagickFalse) && (matte != MagickFalse))
- (void) SetImageOpacity(wand->images,OpaqueAlpha);
+ (void) SetImageAlpha(wand->images,OpaqueAlpha);
wand->images->matte=matte;
return(MagickTrue);
}
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% MagickSetImageOpacity() sets the image to the specified opacity level.
+% MagickSetImageAlpha() sets the image to the specified alpha level.
%
-% The format of the MagickSetImageOpacity method is:
+% The format of the MagickSetImageAlpha method is:
%
-% MagickBooleanType MagickSetImageOpacity(MagickWand *wand,
+% MagickBooleanType MagickSetImageAlpha(MagickWand *wand,
% const double alpha)
%
% A description of each parameter follows:
% transparent.
%
*/
-WandExport MagickBooleanType MagickSetImageOpacity(MagickWand *wand,
+WandExport MagickBooleanType MagickSetImageAlpha(MagickWand *wand,
const double alpha)
{
MagickBooleanType
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- status=SetImageOpacity(wand->images,ClampToQuantum(QuantumRange*alpha));
+ status=SetImageAlpha(wand->images,ClampToQuantum(QuantumRange*alpha));
if (status == MagickFalse)
InheritException(wand->exception,&wand->images->exception);
return(status);
% The format of the MagickShadowImage method is:
%
% MagickBooleanType MagickShadowImage(MagickWand *wand,
-% const double opacity,const double sigma,const ssize_t x,const ssize_t y)
+% const double alpha,const double sigma,const ssize_t x,const ssize_t y)
%
% A description of each parameter follows:
%
% o wand: the magick wand.
%
-% o opacity: percentage transparency.
+% o alpha: percentage transparency.
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
%
*/
WandExport MagickBooleanType MagickShadowImage(MagickWand *wand,
- const double opacity,const double sigma,const ssize_t x,const ssize_t y)
+ const double alpha,const double sigma,const ssize_t x,const ssize_t y)
{
Image
*shadow_image;
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- shadow_image=ShadowImage(wand->images,opacity,sigma,x,y,wand->exception);
+ shadow_image=ShadowImage(wand->images,alpha,sigma,x,y,wand->exception);
if (shadow_image == (Image *) NULL)
return(MagickFalse);
ReplaceImageInList(&wand->images,shadow_image);
% The format of the MagickTintImage method is:
%
% MagickBooleanType MagickTintImage(MagickWand *wand,
-% const PixelWand *tint,const PixelWand *opacity)
+% const PixelWand *tint,const PixelWand *alpha)
%
% A description of each parameter follows:
%
%
% o tint: the tint pixel wand.
%
-% o opacity: the opacity pixel wand.
+% o alpha: the alpha pixel wand.
%
*/
WandExport MagickBooleanType MagickTintImage(MagickWand *wand,
- const PixelWand *tint,const PixelWand *opacity)
+ const PixelWand *tint,const PixelWand *alpha)
{
char
percent_opaque[MaxTextExtent];
if (wand->images->colorspace != CMYKColorspace)
(void) FormatLocaleString(percent_opaque,MaxTextExtent,
"%g,%g,%g,%g",(double) (100.0*QuantumScale*
- PixelGetRedQuantum(opacity)),(double) (100.0*QuantumScale*
- PixelGetGreenQuantum(opacity)),(double) (100.0*QuantumScale*
- PixelGetBlueQuantum(opacity)),(double) (100.0*QuantumScale*
- PixelGetOpacityQuantum(opacity)));
+ PixelGetRedQuantum(alpha)),(double) (100.0*QuantumScale*
+ PixelGetGreenQuantum(alpha)),(double) (100.0*QuantumScale*
+ PixelGetBlueQuantum(alpha)),(double) (100.0*QuantumScale*
+ PixelGetAlphaQuantum(alpha)));
else
(void) FormatLocaleString(percent_opaque,MaxTextExtent,
"%g,%g,%g,%g,%g",(double) (100.0*QuantumScale*
- PixelGetCyanQuantum(opacity)),(double) (100.0*QuantumScale*
- PixelGetMagentaQuantum(opacity)),(double) (100.0*QuantumScale*
- PixelGetYellowQuantum(opacity)),(double) (100.0*QuantumScale*
- PixelGetBlackQuantum(opacity)),(double) (100.0*QuantumScale*
- PixelGetOpacityQuantum(opacity)));
+ PixelGetCyanQuantum(alpha)),(double) (100.0*QuantumScale*
+ PixelGetMagentaQuantum(alpha)),(double) (100.0*QuantumScale*
+ PixelGetYellowQuantum(alpha)),(double) (100.0*QuantumScale*
+ PixelGetBlackQuantum(alpha)),(double) (100.0*QuantumScale*
+ PixelGetAlphaQuantum(alpha)));
target=PixelGetPixel(tint);
tint_image=TintImage(wand->images,percent_opaque,&target,wand->exception);
if (tint_image == (Image *) NULL)
%
% o wand: the magick wand.
%
-% o target: Change this target color to specified opacity value within
+% o target: Change this target color to specified alpha value within
% the image.
%
% o alpha: the level of transparency: 1.0 is fully opaque and 0.0 is fully
(void) FormatLocaleString(thresholds,MaxTextExtent,
QuantumFormat "," QuantumFormat "," QuantumFormat "," QuantumFormat,
PixelGetRedQuantum(threshold),PixelGetGreenQuantum(threshold),
- PixelGetBlueQuantum(threshold),PixelGetOpacityQuantum(threshold));
+ PixelGetBlueQuantum(threshold),PixelGetAlphaQuantum(threshold));
status=WhiteThresholdImage(wand->images,thresholds,&wand->images->exception);
if (status == MagickFalse)
InheritException(wand->exception,&wand->images->exception);
MagickSetImageIterations(MagickWand *,const size_t),
MagickSetImageMatte(MagickWand *,const MagickBooleanType),
MagickSetImageMatteColor(MagickWand *,const PixelWand *),
- MagickSetImageOpacity(MagickWand *,const double),
+ MagickSetImageAlpha(MagickWand *,const double),
MagickSetImageOrientation(MagickWand *,const OrientationType),
MagickSetImagePage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t),
% %
% %
% %
-% P i x e l G e t O p a c i t y %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% PixelGetOpacity() returns the normalized opacity color of the pixel wand.
-%
-% The format of the PixelGetOpacity method is:
-%
-% double PixelGetOpacity(const PixelWand *wand)
-%
-% A description of each parameter follows:
-%
-% o wand: the pixel wand.
-%
-*/
-WandExport double PixelGetOpacity(const PixelWand *wand)
-{
- assert(wand != (const PixelWand *) NULL);
- assert(wand->signature == WandSignature);
- if (wand->debug != MagickFalse)
- (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- return((double) QuantumScale*wand->pixel.alpha);
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
-% P i x e l G e t O p a c i t y Q u a n t u m %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% PixelGetOpacityQuantum() returns the opacity color of the pixel wand.
-%
-% The format of the PixelGetOpacityQuantum method is:
-%
-% Quantum PixelGetOpacityQuantum(const PixelWand *wand)
-%
-% A description of each parameter follows:
-%
-% o wand: the pixel wand.
-%
-*/
-WandExport Quantum PixelGetOpacityQuantum(const PixelWand *wand)
-{
- assert(wand != (const PixelWand *) NULL);
- assert(wand->signature == WandSignature);
- if (wand->debug != MagickFalse)
- (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- return(ClampToQuantum(wand->pixel.alpha));
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
% P i x e l G e t P i x e l %
% %
% %
% The format of the PixelSetAlphaQuantum method is:
%
% void PixelSetAlphaQuantum(PixelWand *wand,
-% const Quantum opacity)
+% const Quantum alpha)
%
% A description of each parameter follows:
%
% o wand: the pixel wand.
%
-% o opacity: the opacity color.
+% o alpha: the alpha color.
%
*/
-WandExport void PixelSetAlphaQuantum(PixelWand *wand,const Quantum opacity)
+WandExport void PixelSetAlphaQuantum(PixelWand *wand,const Quantum alpha)
{
assert(wand != (const PixelWand *) NULL);
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- wand->pixel.alpha=(MagickRealType) opacity;
+ wand->pixel.alpha=(MagickRealType) alpha;
}
\f
/*
% %
% %
% %
-% P i x e l S e t O p a c i t y %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% PixelSetOpacity() sets the normalized opacity color of the pixel wand.
-%
-% The format of the PixelSetOpacity method is:
-%
-% void PixelSetOpacity(PixelWand *wand,const double opacity)
-%
-% A description of each parameter follows:
-%
-% o wand: the pixel wand.
-%
-% o opacity: the opacity color.
-%
-*/
-WandExport void PixelSetOpacity(PixelWand *wand,const double opacity)
-{
- assert(wand != (const PixelWand *) NULL);
- assert(wand->signature == WandSignature);
- if (wand->debug != MagickFalse)
- (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- wand->pixel.matte=MagickTrue;
- wand->pixel.alpha=(MagickRealType) ClampToQuantum((MagickRealType)
- QuantumRange*opacity);
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
-% P i x e l S e t O p a c i t y Q u a n t u m %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% PixelSetOpacityQuantum() sets the opacity color of the pixel wand.
-%
-% The format of the PixelSetOpacityQuantum method is:
-%
-% void PixelSetOpacityQuantum(PixelWand *wand,
-% const Quantum opacity)
-%
-% A description of each parameter follows:
-%
-% o wand: the pixel wand.
-%
-% o opacity: the opacity color.
-%
-*/
-WandExport void PixelSetOpacityQuantum(PixelWand *wand,const Quantum opacity)
-{
- assert(wand != (const PixelWand *) NULL);
- assert(wand->signature == WandSignature);
- if (wand->debug != MagickFalse)
- (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- wand->pixel.alpha=(MagickRealType) opacity;
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
% P i x e l S e t Q u a n t u m P a c k e t %
% %
% %
PixelGetFuzz(const PixelWand *),
PixelGetGreen(const PixelWand *),
PixelGetMagenta(const PixelWand *),
- PixelGetOpacity(const PixelWand *),
+ PixelGetAlpha(const PixelWand *),
PixelGetRed(const PixelWand *),
PixelGetYellow(const PixelWand *);
PixelGetGreenQuantum(const PixelWand *),
PixelGetIndex(const PixelWand *),
PixelGetMagentaQuantum(const PixelWand *),
- PixelGetOpacityQuantum(const PixelWand *),
+ PixelGetAlphaQuantum(const PixelWand *),
PixelGetRedQuantum(const PixelWand *),
PixelGetYellowQuantum(const PixelWand *);
PixelSetMagenta(PixelWand *,const double),
PixelSetMagentaQuantum(PixelWand *,const Quantum),
PixelSetPixelInfo(PixelWand *,const PixelInfo *),
- PixelSetOpacity(PixelWand *,const double),
- PixelSetOpacityQuantum(PixelWand *,const Quantum),
+ PixelSetAlpha(PixelWand *,const double),
+ PixelSetAlphaQuantum(PixelWand *,const Quantum),
PixelSetQuantumPacket(PixelWand *,const PixelPacket *),
PixelSetQuantumPixel(const Image *,const Quantum *,PixelWand *),
PixelSetRed(PixelWand *,const double),
if (attribute_flag[6] != 0) /* opacity */
{
if (compose != DissolveCompositeOp)
- (void) SetImageOpacity(composite_image,(Quantum)
+ (void) SetImageAlpha(composite_image,(Quantum)
SiPrefixToDouble(argument_list[6].string_reference,
QuantumRange));
else
opacity=(Quantum) SiPrefixToDouble(
argument_list[6].string_reference,QuantumRange);
if (composite_image->matte != MagickTrue)
- (void) SetImageOpacity(composite_image,OpaqueAlpha);
+ (void) SetImageAlpha(composite_image,OpaqueAlpha);
composite_view=AcquireCacheView(composite_image);
for (y=0; y < (ssize_t) composite_image->rows ; y++)
{
if (attribute_flag[2] != 0)
geometry.y=argument_list[2].integer_reference;
if (image->matte == MagickFalse)
- (void) SetImageOpacity(image,OpaqueAlpha);
+ (void) SetImageAlpha(image,OpaqueAlpha);
(void) GetOneVirtualMagickPixel(image,geometry.x,geometry.y,&target,
exception);
if (attribute_flag[4] != 0)
image=AcquireImage(image_info,exception);
if ((image->columns == 0) || (image->rows == 0))
ThrowReaderException(OptionError,"MustSpecifyImageSize");
- (void) SetImageOpacity(image,(Quantum) TransparentAlpha);
+ (void) SetImageAlpha(image,(Quantum) TransparentAlpha);
(void) CopyMagickString(image->filename,image_info->filename,MaxTextExtent);
(void) CopyMagickString(colorname,image_info->filename,MaxTextExtent);
(void) sscanf(image_info->filename,"%[^-]",colorname);
opacity=StringToLong(value);
if (compose != DissolveCompositeOp)
{
- (void) SetImageOpacity(composite_image,(Quantum)
+ (void) SetImageAlpha(composite_image,(Quantum)
opacity);
break;
}
(void) SetImageArtifact(msl_info->image[n],
"compose:args",value);
if (composite_image->matte != MagickTrue)
- (void) SetImageOpacity(composite_image,OpaqueAlpha);
+ (void) SetImageAlpha(composite_image,OpaqueAlpha);
composite_view=AcquireCacheView(composite_image);
for (y=0; y < (ssize_t) composite_image->rows ; y++)
{
opac = (int)(QuantumRange * ((float)opac/100));
} else
opac = StringToLong( value );
- (void) SetImageOpacity( msl_info->image[n], (Quantum) opac );
+ (void) SetImageAlpha( msl_info->image[n], (Quantum) opac );
break;
}
(void) SetMSLAttributes(msl_info,keyword,value);
{
/* Add an opaque matte channel */
image->matte = MagickTrue;
- (void) SetImageOpacity(image,0);
+ (void) SetImageAlpha(image,OpaqueAlpha);
if (logging != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
projects / imagemagick / commitdiff