This source file includes following definitions.
- adjoin
- adjoin
- antiAlias
- antiAlias
- animationDelay
- animationDelay
- animationIterations
- animationIterations
- attenuate
- backgroundColor
- backgroundColor
- backgroundTexture
- backgroundTexture
- baseColumns
- baseFilename
- baseRows
- blackPointCompensation
- blackPointCompensation
- borderColor
- borderColor
- boundingBox
- boxColor
- boxColor
- cacheThreshold
- classType
- clipMask
- clipMask
- colorFuzz
- colorFuzz
- colorMapSize
- colorMapSize
- colorSpace
- colorSpace
- colorspaceType
- colorspaceType
- comment
- comment
- compose
- compose
- compressType
- compressType
- debug
- debug
- density
- density
- depth
- depth
- directory
- endian
- endian
- exifProfile
- exifProfile
- fileName
- fileName
- fileSize
- fillColor
- fillColor
- fillRule
- fillRule
- fillPattern
- fillPattern
- filterType
- filterType
- font
- font
- fontFamily
- fontFamily
- fontPointsize
- fontPointsize
- format
- fontStyle
- fontStyle
- fontWeight
- fontWeight
- formatExpression
- gamma
- geometry
- gifDisposeMethod
- gifDisposeMethod
- highlightColor
- iccColorProfile
- iccColorProfile
- interlaceType
- interlaceType
- interpolate
- interpolate
- iptcProfile
- iptcProfile
- isOpaque
- isValid
- isValid
- label
- label
- lowlightColor
- magick
- magick
- mask
- mask
- matte
- matte
- matteColor
- matteColor
- meanErrorPerPixel
- modulusDepth
- modulusDepth
- monochrome
- monochrome
- montageGeometry
- normalizedMaxError
- normalizedMeanError
- orientation
- orientation
- page
- page
- penColor
- penColor
- penTexture
- penTexture
- quality
- quality
- quantizeColors
- quantizeColors
- quantizeColorSpace
- quantizeColorSpace
- quantizeDither
- quantizeDither
- quantizeDitherMethod
- quantizeDitherMethod
- quantizeTreeDepth
- quantizeTreeDepth
- quiet
- quiet
- renderingIntent
- renderingIntent
- resolutionUnits
- resolutionUnits
- scene
- scene
- size
- size
- strokeAntiAlias
- strokeAntiAlias
- strokeColor
- strokeColor
- strokeDashArray
- strokeDashArray
- strokeDashOffset
- strokeDashOffset
- strokeLineCap
- strokeLineCap
- strokeLineJoin
- strokeLineJoin
- strokeMiterLimit
- strokeMiterLimit
- strokePattern
- strokePattern
- strokeWidth
- strokeWidth
- subImage
- subImage
- subRange
- subRange
- textDirection
- textDirection
- textEncoding
- textEncoding
- textGravity
- textGravity
- textInterlineSpacing
- textInterlineSpacing
- textInterwordSpacing
- textInterwordSpacing
- textKerning
- textKerning
- textUnderColor
- textUnderColor
- tileName
- tileName
- totalColors
- transformRotation
- transformSkewX
- transformSkewY
- type
- type
- verbose
- verbose
- view
- view
- virtualPixelMethod
- virtualPixelMethod
- x11Display
- x11Display
- xResolution
- yResolution
- adaptiveBlur
- adaptiveResize
- adaptiveSharpen
- adaptiveSharpenChannel
- adaptiveThreshold
- addNoise
- addNoiseChannel
- affineTransform
- alphaChannel
- annotate
- annotate
- annotate
- annotate
- artifact
- artifact
- attribute
- attribute
- autoGamma
- autoGammaChannel
- autoLevel
- autoLevelChannel
- autoOrient
- blackThreshold
- blackThresholdChannel
- blueShift
- blur
- blurChannel
- border
- brightnessContrast
- brightnessContrastChannel
- cannyEdge
- cdl
- channel
- channelDepth
- channelDepth
- charcoal
- chop
- chromaBluePrimary
- chromaBluePrimary
- chromaGreenPrimary
- chromaGreenPrimary
- chromaRedPrimary
- chromaRedPrimary
- chromaWhitePoint
- chromaWhitePoint
- clamp
- clampChannel
- clip
- clipPath
- clut
- clutChannel
- colorize
- colorize
- colorMap
- colorMap
- colorMatrix
- compare
- compare
- compareChannel
- compare
- compareChannel
- composite
- composite
- composite
- connectedComponents
- contrast
- contrastStretch
- contrastStretchChannel
- convolve
- copyPixels
- crop
- cycleColormap
- decipher
- defineSet
- defineSet
- defineValue
- defineValue
- deskew
- despeckle
- determineType
- display
- distort
- draw
- draw
- edge
- emboss
- encipher
- enhance
- equalize
- erase
- extent
- extent
- extent
- extent
- flip
- floodFillColor
- floodFillColor
- floodFillColor
- floodFillColor
- floodFillColor
- floodFillColor
- floodFillColor
- floodFillColor
- floodFillOpacity
- floodFillOpacity
- floodFillOpacity
- floodFillTexture
- floodFillTexture
- floodFillTexture
- floodFillTexture
- floodFillTexture
- floodFillTexture
- floodFillTexture
- floodFillTexture
- flop
- fontTypeMetrics
- fontTypeMetricsMultiline
- frame
- frame
- fx
- fx
- gamma
- gamma
- gaussianBlur
- gaussianBlurChannel
- getConstIndexes
- getConstPixels
- getIndexes
- getPixels
- grayscale
- haldClut
- houghLine
- implode
- inverseFourierTransform
- inverseFourierTransform
- kuwahara
- kuwaharaChannel
- level
- levelChannel
- levelColors
- levelColorsChannel
- levelize
- levelizeChannel
- linearStretch
- liquidRescale
- localContrast
- magnify
- map
- matteFloodfill
- medianFilter
- mergeLayers
- minify
- modulate
- moments
- morphology
- morphology
- morphologyChannel
- morphologyChannel
- motionBlur
- negate
- negateChannel
- normalize
- oilPaint
- opacity
- opaque
- orderedDither
- orderedDitherChannel
- perceptible
- perceptibleChannel
- ping
- ping
- pixelColor
- pixelColor
- polaroid
- posterize
- posterizeChannel
- process
- profile
- profile
- quantize
- quantumOperator
- quantumOperator
- quantumOperator
- raise
- randomThreshold
- randomThresholdChannel
- read
- read
- read
- read
- read
- read
- read
- read
- readPixels
- reduceNoise
- repage
- resample
- resize
- roll
- roll
- rotate
- rotationalBlur
- rotationalBlurChannel
- sample
- scale
- segment
- selectiveBlur
- selectiveBlurChannel
- separate
- sepiaTone
- setPixels
- shade
- shadow
- sharpen
- sharpenChannel
- shave
- shear
- sigmoidalContrast
- signature
- sketch
- solarize
- sparseColor
- splice
- splice
- splice
- spread
- statistics
- stegano
- stereo
- strip
- subImageSearch
- swirl
- syncPixels
- texture
- threshold
- thumbnail
- tint
- transform
- transform
- transformOrigin
- transformReset
- transformScale
- transparent
- transparentChroma
- transpose
- transverse
- trim
- uniqueColors
- unsharpmask
- unsharpmaskChannel
- vignette
- wave
- whiteThreshold
- whiteThresholdChannel
- write
- write
- write
- write
- write
- writePixels
- zoom
- image
- constImage
- imageInfo
- constImageInfo
- options
- constOptions
- quantizeInfo
- constQuantizeInfo
- modifyImage
- replaceImage
- throwImageException
- read
- floodFill
#define MAGICKCORE_IMPLEMENTATION 1
#define MAGICK_PLUSPLUS_IMPLEMENTATION 1
#include "Magick++/Include.h"
#include <cstdlib>
#include <string>
#include <string.h>
#include <errno.h>
#include <math.h>
using namespace std;
#include "Magick++/Image.h"
#include "Magick++/Functions.h"
#include "Magick++/Pixels.h"
#include "Magick++/Options.h"
#include "Magick++/ImageRef.h"
#include "Magick++/ResourceLimits.h"
#define AbsoluteValue(x) ((x) < 0 ? -(x) : (x))
#define MagickPI 3.14159265358979323846264338327950288419716939937510
#define DegreesToRadians(x) (MagickPI*(x)/180.0)
#define ThrowImageException ThrowPPException(quiet())
MagickPPExport const char *Magick::borderGeometryDefault="6x6+0+0";
MagickPPExport const char *Magick::frameGeometryDefault="25x25+6+6";
MagickPPExport const char *Magick::raiseGeometryDefault="6x6+0+0";
MagickPPExport int Magick::operator == (const Magick::Image &left_,
const Magick::Image &right_)
{
return((left_.rows() == right_.rows()) &&
(left_.columns() == right_.columns()) &&
(left_.signature() == right_.signature()));
}
MagickPPExport int Magick::operator != (const Magick::Image &left_,
const Magick::Image &right_)
{
return(!(left_ == right_));
}
MagickPPExport int Magick::operator > (const Magick::Image &left_,
const Magick::Image &right_)
{
return(!(left_ < right_) && (left_ != right_));
}
MagickPPExport int Magick::operator < (const Magick::Image &left_,
const Magick::Image &right_)
{
return((left_.rows() * left_.columns()) < (right_.rows() *
right_.columns()));
}
MagickPPExport int Magick::operator >= (const Magick::Image &left_,
const Magick::Image &right_)
{
return((left_ > right_) || (left_ == right_));
}
MagickPPExport int Magick::operator <= (const Magick::Image &left_,
const Magick::Image &right_)
{
return((left_ < right_) || (left_ == right_));
}
Magick::Image::Image(void)
: _imgRef(new ImageRef)
{
}
Magick::Image::Image(const Blob &blob_)
: _imgRef(new ImageRef)
{
try
{
quiet(true);
read(blob_);
quiet(false);
}
catch(const Error&)
{
delete _imgRef;
throw;
}
}
Magick::Image::Image(const Blob &blob_,const Geometry &size_)
: _imgRef(new ImageRef)
{
try
{
quiet(true);
read(blob_,size_);
quiet(false);
}
catch(const Error&)
{
delete _imgRef;
throw;
}
}
Magick::Image::Image(const Blob &blob_,const Geometry &size_,
const size_t depth_)
: _imgRef(new ImageRef)
{
try
{
quiet(true);
read(blob_,size_,depth_);
quiet(false);
}
catch(const Error&)
{
delete _imgRef;
throw;
}
}
Magick::Image::Image(const Blob &blob_,const Geometry &size_,
const size_t depth_,const std::string &magick_)
: _imgRef(new ImageRef)
{
try
{
quiet(true);
read(blob_,size_,depth_,magick_);
quiet(false);
}
catch(const Error&)
{
delete _imgRef;
throw;
}
}
Magick::Image::Image(const Blob &blob_,const Geometry &size_,
const std::string &magick_)
: _imgRef(new ImageRef)
{
try
{
quiet(true);
read(blob_,size_,magick_);
quiet(false);
}
catch(const Error&)
{
delete _imgRef;
throw;
}
}
Magick::Image::Image(const Geometry &size_,const Color &color_)
: _imgRef(new ImageRef)
{
std::string imageSpec("xc:");
imageSpec+=color_;
try
{
quiet(true);
size(size_);
read(imageSpec);
quiet(false);
}
catch(const Error&)
{
delete _imgRef;
throw;
}
}
Magick::Image::Image(const Image &image_)
: _imgRef(image_._imgRef)
{
Lock lock(&_imgRef->_mutexLock);
++_imgRef->_refCount;
}
Magick::Image::Image(const Image &image_,const Geometry &geometry_)
: _imgRef(new ImageRef)
{
const RectangleInfo
geometry=geometry_;
OffsetInfo
offset;
MagickCore::Image
*image;
GetPPException;
image=CloneImage(image_.constImage(),geometry_.width(),geometry_.height(),
MagickTrue,exceptionInfo);
replaceImage(image);
_imgRef->options(new Options(*image_.constOptions()));
offset.x=0;
offset.y=0;
(void) CopyImagePixels(image,image_.constImage(),&geometry,&offset,
exceptionInfo);
ThrowImageException;
}
Magick::Image::Image(const size_t width_,const size_t height_,
const std::string &map_,const StorageType type_,const void *pixels_)
: _imgRef(new ImageRef)
{
try
{
quiet(true);
read(width_,height_,map_,type_,pixels_);
quiet(false);
}
catch(const Error&)
{
delete _imgRef;
throw;
}
}
Magick::Image::Image(const std::string &imageSpec_)
: _imgRef(new ImageRef)
{
try
{
quiet(true);
read(imageSpec_);
quiet(false);
}
catch(const Error&)
{
delete _imgRef;
throw;
}
}
Magick::Image::~Image()
{
bool
doDelete=false;
{
Lock lock(&_imgRef->_mutexLock);
if (--_imgRef->_refCount == 0)
doDelete=true;
}
if (doDelete)
delete _imgRef;
_imgRef=0;
}
Magick::Image& Magick::Image::operator=(const Magick::Image &image_)
{
if (this != &image_)
{
bool
doDelete=false;
{
Lock lock(&image_._imgRef->_mutexLock);
++image_._imgRef->_refCount;
}
{
Lock lock(&_imgRef->_mutexLock);
if (--_imgRef->_refCount == 0)
doDelete=true;
}
if (doDelete)
{
delete _imgRef;
_imgRef=0;
}
_imgRef=image_._imgRef;
}
return(*this);
}
void Magick::Image::adjoin(const bool flag_)
{
modifyImage();
options()->adjoin(flag_);
}
bool Magick::Image::adjoin(void) const
{
return(constOptions()->adjoin());
}
void Magick::Image::antiAlias(const bool flag_)
{
modifyImage();
options()->antiAlias(flag_);
}
bool Magick::Image::antiAlias(void) const
{
return(constOptions()->antiAlias());
}
void Magick::Image::animationDelay(const size_t delay_)
{
modifyImage();
image()->delay=delay_;
}
size_t Magick::Image::animationDelay(void) const
{
return(constImage()->delay);
}
void Magick::Image::animationIterations(const size_t iterations_)
{
modifyImage();
image()->iterations=iterations_;
}
size_t Magick::Image::animationIterations(void) const
{
return(constImage()->iterations);
}
void Magick::Image::attenuate(const double attenuate_)
{
char
value[MaxTextExtent];
modifyImage();
FormatLocaleString(value,MaxTextExtent,"%.20g",attenuate_);
(void) SetImageArtifact(image(),"attenuate",value);
}
void Magick::Image::backgroundColor(const Color &backgroundColor_)
{
modifyImage();
if (backgroundColor_.isValid())
image()->background_color=backgroundColor_;
else
image()->background_color=Color();
options()->backgroundColor(backgroundColor_);
}
Magick::Color Magick::Image::backgroundColor(void) const
{
return(constOptions()->backgroundColor());
}
void Magick::Image::backgroundTexture(const std::string &backgroundTexture_)
{
modifyImage();
options()->backgroundTexture(backgroundTexture_);
}
std::string Magick::Image::backgroundTexture(void) const
{
return(constOptions()->backgroundTexture());
}
size_t Magick::Image::baseColumns(void) const
{
return(constImage()->magick_columns);
}
std::string Magick::Image::baseFilename(void) const
{
return(std::string(constImage()->magick_filename));
}
size_t Magick::Image::baseRows(void) const
{
return(constImage()->magick_rows);
}
void Magick::Image::blackPointCompensation(const bool flag_)
{
image()->black_point_compensation=(MagickBooleanType) flag_;
}
bool Magick::Image::blackPointCompensation(void) const
{
return(static_cast<bool>(constImage()->black_point_compensation));
}
void Magick::Image::borderColor(const Color &borderColor_)
{
modifyImage();
if (borderColor_.isValid())
image()->border_color=borderColor_;
else
image()->border_color=Color();
options()->borderColor(borderColor_);
}
Magick::Color Magick::Image::borderColor(void) const
{
return(constOptions()->borderColor());
}
Magick::Geometry Magick::Image::boundingBox(void) const
{
RectangleInfo
bbox;
GetPPException;
bbox=GetImageBoundingBox(constImage(),exceptionInfo);
ThrowImageException;
return(Geometry(bbox));
}
void Magick::Image::boxColor(const Color &boxColor_)
{
modifyImage();
options()->boxColor(boxColor_);
}
Magick::Color Magick::Image::boxColor(void) const
{
return(constOptions()->boxColor());
}
void Magick::Image::cacheThreshold(const size_t threshold_)
{
ResourceLimits::memory((MagickSizeType) threshold_);
}
void Magick::Image::classType(const ClassType class_)
{
if (classType() == PseudoClass && class_ == DirectClass)
{
modifyImage();
SyncImage(image());
image()->colormap=(PixelPacket *)RelinquishMagickMemory(
image()->colormap);
image()->storage_class=static_cast<MagickCore::ClassType>(DirectClass);
}
else if (classType() == DirectClass && class_ == PseudoClass)
{
modifyImage();
quantizeColors(MaxColormapSize);
quantize();
image()->storage_class=static_cast<MagickCore::ClassType>(PseudoClass);
}
}
void Magick::Image::clipMask(const Magick::Image &clipMask_)
{
modifyImage();
if (clipMask_.isValid())
SetImageClipMask(image(),clipMask_.constImage());
else
SetImageClipMask(image(),0);
}
Magick::Image Magick::Image::clipMask(void) const
{
MagickCore::Image
*image;
GetPPException;
image=GetImageClipMask(constImage(),exceptionInfo);
ThrowImageException;
if (image == (MagickCore::Image *) NULL)
return(Magick::Image());
else
return(Magick::Image(image));
}
void Magick::Image::colorFuzz(const double fuzz_)
{
modifyImage();
image()->fuzz=fuzz_;
options()->colorFuzz(fuzz_);
}
double Magick::Image::colorFuzz(void) const
{
return(constOptions()->colorFuzz());
}
void Magick::Image::colorMapSize(const size_t entries_)
{
if (entries_ > MaxColormapSize)
throwExceptionExplicit(OptionError,
"Colormap entries must not exceed MaxColormapSize");
modifyImage();
(void) AcquireImageColormap(image(),entries_);
}
size_t Magick::Image::colorMapSize(void) const
{
if (!constImage()->colormap)
throwExceptionExplicit(OptionError,"Image does not contain a colormap");
return(constImage()->colors);
}
void Magick::Image::colorSpace(const ColorspaceType colorSpace_)
{
if (image()->colorspace == colorSpace_)
return;
modifyImage();
TransformImageColorspace(image(),colorSpace_);
throwImageException();
}
Magick::ColorspaceType Magick::Image::colorSpace(void) const
{
return(constImage()->colorspace);
}
void Magick::Image::colorspaceType(const ColorspaceType colorSpace_)
{
modifyImage();
SetImageColorspace(image(),colorSpace_);
throwImageException();
options()->colorspaceType(colorSpace_);
}
Magick::ColorspaceType Magick::Image::colorspaceType(void) const
{
return(constOptions()->colorspaceType());
}
void Magick::Image::comment(const std::string &comment_)
{
modifyImage();
SetImageProperty(image(),"Comment",NULL);
if (comment_.length() > 0)
SetImageProperty(image(),"Comment",comment_.c_str());
throwImageException();
}
std::string Magick::Image::comment(void) const
{
const char
*value;
value=GetImageProperty(constImage(),"Comment");
if (value)
return(std::string(value));
return(std::string());
}
void Magick::Image::compose(const CompositeOperator compose_)
{
image()->compose=compose_;
}
Magick::CompositeOperator Magick::Image::compose(void) const
{
return(constImage()->compose);
}
void Magick::Image::compressType(const CompressionType compressType_)
{
modifyImage();
image()->compression=compressType_;
options()->compressType(compressType_);
}
Magick::CompressionType Magick::Image::compressType(void) const
{
return(constImage()->compression);
}
void Magick::Image::debug(const bool flag_)
{
modifyImage();
options()->debug(flag_);
}
bool Magick::Image::debug(void) const
{
return(constOptions()->debug());
}
void Magick::Image::density(const Geometry &density_)
{
modifyImage();
options()->density(density_);
if (density_.isValid())
{
image()->x_resolution=density_.width();
if (density_.height() != 0)
image()->y_resolution=density_.height();
else
image()->y_resolution=density_.width();
}
else
{
image()->x_resolution=0;
image()->y_resolution=0;
}
}
Magick::Geometry Magick::Image::density(void) const
{
if (isValid())
{
ssize_t
x_resolution=72,
y_resolution=72;
if (constImage()->x_resolution > 0.0)
x_resolution=static_cast<ssize_t>(constImage()->x_resolution + 0.5);
if (constImage()->y_resolution > 0.0)
y_resolution=static_cast<ssize_t>(constImage()->y_resolution + 0.5);
return(Geometry(x_resolution,y_resolution));
}
return(constOptions()->density());
}
void Magick::Image::depth(const size_t depth_)
{
size_t
depth=depth_;
if (depth > MAGICKCORE_QUANTUM_DEPTH)
depth=MAGICKCORE_QUANTUM_DEPTH;
modifyImage();
image()->depth=depth;
options()->depth(depth);
}
size_t Magick::Image::depth(void) const
{
return(constImage()->depth);
}
std::string Magick::Image::directory(void) const
{
if (constImage()->directory)
return(std::string(constImage()->directory));
throwExceptionExplicit(CorruptImageWarning,
"Image does not contain a directory");
return(std::string());
}
void Magick::Image::endian(const Magick::EndianType endian_)
{
modifyImage();
options()->endian(endian_);
image()->endian=endian_;
}
Magick::EndianType Magick::Image::endian(void) const
{
return(constImage()->endian);
}
void Magick::Image::exifProfile(const Magick::Blob &exifProfile_)
{
if (exifProfile_.data() != 0)
{
StringInfo
*exif_profile;
modifyImage();
exif_profile=AcquireStringInfo(exifProfile_.length());
SetStringInfoDatum(exif_profile,(unsigned char *) exifProfile_.data());
(void) SetImageProfile(image(),"exif",exif_profile);
exif_profile=DestroyStringInfo(exif_profile);
}
}
Magick::Blob Magick::Image::exifProfile(void) const
{
const StringInfo
*exif_profile;
exif_profile=GetImageProfile(constImage(),"exif");
if (exif_profile == (StringInfo *) NULL)
return(Blob());
return(Blob(GetStringInfoDatum(exif_profile),GetStringInfoLength(
exif_profile)));
}
void Magick::Image::fileName(const std::string &fileName_)
{
modifyImage();
fileName_.copy(image()->filename,sizeof(image()->filename)-1);
image()->filename[fileName_.length()]=0;
options()->fileName(fileName_);
}
std::string Magick::Image::fileName(void) const
{
return(constOptions()->fileName());
}
off_t Magick::Image::fileSize(void) const
{
return((off_t) GetBlobSize(constImage()));
}
void Magick::Image::fillColor(const Magick::Color &fillColor_)
{
modifyImage();
options()->fillColor(fillColor_);
}
Magick::Color Magick::Image::fillColor(void) const
{
return(constOptions()->fillColor());
}
void Magick::Image::fillRule(const Magick::FillRule &fillRule_)
{
modifyImage();
options()->fillRule(fillRule_);
}
Magick::FillRule Magick::Image::fillRule(void) const
{
return(constOptions()->fillRule());
}
void Magick::Image::fillPattern(const Image &fillPattern_)
{
modifyImage();
if(fillPattern_.isValid())
options()->fillPattern(fillPattern_.constImage());
else
options()->fillPattern(static_cast<MagickCore::Image*>(NULL));
}
Magick::Image Magick::Image::fillPattern(void) const
{
const MagickCore::Image
*tmpTexture;
Image
texture;
tmpTexture=constOptions()->fillPattern();
if(tmpTexture)
{
MagickCore::Image
*image;
GetPPException;
image=CloneImage(tmpTexture,0,0,MagickTrue,exceptionInfo);
texture.replaceImage(image);
ThrowImageException;
}
return(texture);
}
void Magick::Image::filterType(const Magick::FilterTypes filterType_)
{
modifyImage();
image()->filter=filterType_;
}
Magick::FilterTypes Magick::Image::filterType(void) const
{
return(constImage()->filter);
}
void Magick::Image::font(const std::string &font_)
{
modifyImage();
options()->font(font_);
}
std::string Magick::Image::font(void) const
{
return(constOptions()->font());
}
void Magick::Image::fontFamily(const std::string &family_)
{
modifyImage();
options()->fontFamily(family_);
}
std::string Magick::Image::fontFamily(void) const
{
return(constOptions()->fontFamily());
}
void Magick::Image::fontPointsize(const double pointSize_)
{
modifyImage();
options()->fontPointsize(pointSize_);
}
double Magick::Image::fontPointsize(void) const
{
return(constOptions()->fontPointsize());
}
std::string Magick::Image::format(void) const
{
const MagickInfo
*magick_info;
GetPPException;
magick_info=GetMagickInfo(constImage()->magick,exceptionInfo);
ThrowImageException;
if ((magick_info != 0) && (*magick_info->description != '\0'))
return(std::string(magick_info->description));
throwExceptionExplicit(CorruptImageWarning,"Unrecognized image magick type");
return(std::string());
}
void Magick::Image::fontStyle(const StyleType pointSize_)
{
modifyImage();
options()->fontStyle(pointSize_);
}
Magick::StyleType Magick::Image::fontStyle(void) const
{
return(constOptions()->fontStyle());
}
void Magick::Image::fontWeight(const size_t weight_)
{
modifyImage();
options()->fontWeight(weight_);
}
size_t Magick::Image::fontWeight(void) const
{
return(constOptions()->fontWeight());
}
std::string Magick::Image::formatExpression(const std::string expression)
{
char
*text;
std::string
text_string;
modifyImage();
text=InterpretImageProperties(constImageInfo(),image(),expression.c_str());
if (text != (char *) NULL)
{
text_string=std::string(text);
text=DestroyString(text);
}
throwImageException();
return(text_string);
}
double Magick::Image::gamma(void) const
{
return(constImage()->gamma);
}
Magick::Geometry Magick::Image::geometry(void) const
{
if (constImage()->geometry)
return(Geometry(constImage()->geometry));
throwExceptionExplicit(OptionWarning,"Image does not contain a geometry");
return(Geometry());
}
void Magick::Image::gifDisposeMethod(const size_t disposeMethod_)
{
modifyImage();
image()->dispose=(DisposeType) disposeMethod_;
}
size_t Magick::Image::gifDisposeMethod(void) const
{
return ((size_t) constImage()->dispose);
}
void Magick::Image::highlightColor(const Color color_)
{
std::string
value;
value=color_;
artifact("highlight-color",value);
}
void Magick::Image::iccColorProfile(const Magick::Blob &colorProfile_)
{
profile("icc",colorProfile_);
}
Magick::Blob Magick::Image::iccColorProfile(void) const
{
const StringInfo
*color_profile;
color_profile=GetImageProfile(constImage(),"icc");
if (color_profile == (StringInfo *) NULL)
return Blob();
return(Blob(GetStringInfoDatum(color_profile),GetStringInfoLength(
color_profile)));
}
void Magick::Image::interlaceType(const InterlaceType interlace_)
{
modifyImage();
image()->interlace=interlace_;
options()->interlaceType(interlace_);
}
Magick::InterlaceType Magick::Image::interlaceType(void) const
{
return constImage()->interlace;
}
void Magick::Image::interpolate(const InterpolatePixelMethod interpolate_)
{
modifyImage();
image()->interpolate=interpolate_;
}
Magick::InterpolatePixelMethod Magick::Image::interpolate(void) const
{
return constImage()->interpolate;
}
void Magick::Image::iptcProfile(const Magick::Blob &iptcProfile_)
{
modifyImage();
if (iptcProfile_.data() != 0)
{
StringInfo
*iptc_profile;
iptc_profile=AcquireStringInfo(iptcProfile_.length());
SetStringInfoDatum(iptc_profile,(unsigned char *) iptcProfile_.data());
(void) SetImageProfile(image(),"iptc",iptc_profile);
iptc_profile=DestroyStringInfo(iptc_profile );
}
}
Magick::Blob Magick::Image::iptcProfile(void) const
{
const StringInfo
*iptc_profile;
iptc_profile=GetImageProfile(constImage(),"iptc");
if (iptc_profile == (StringInfo *) NULL)
return(Blob());
return(Blob(GetStringInfoDatum(iptc_profile),GetStringInfoLength(
iptc_profile)));
}
bool Magick::Image::isOpaque(void) const
{
MagickBooleanType
result;
GetPPException;
result=IsOpaqueImage(constImage(),exceptionInfo);
ThrowImageException;
return(result != MagickFalse ? true : false);
}
void Magick::Image::isValid(const bool isValid_)
{
if (!isValid_)
{
delete _imgRef;
_imgRef = new ImageRef;
}
else if (!isValid())
{
size(Geometry(1,1));
read("xc:black");
}
}
bool Magick::Image::isValid(void) const
{
return(rows() && columns());
}
void Magick::Image::label(const std::string &label_)
{
modifyImage();
(void) SetImageProperty(image(),"Label",NULL);
if (label_.length() > 0)
(void) SetImageProperty(image(),"Label",label_.c_str());
throwImageException();
}
std::string Magick::Image::label(void) const
{
const char
*value;
value=GetImageProperty(constImage(),"Label");
if (value)
return(std::string(value));
return(std::string());
}
void Magick::Image::lowlightColor(const Color color_)
{
std::string
value;
value=color_;
artifact("lowlight-color",value);
}
void Magick::Image::magick(const std::string &magick_)
{
size_t
length;
modifyImage();
length=sizeof(image()->magick)-1;
if (magick_.length() < length)
length=magick_.length();
if (!magick_.empty())
magick_.copy(image()->magick,length);
image()->magick[length]=0;
options()->magick(magick_);
}
std::string Magick::Image::magick(void) const
{
if (*(constImage()->magick) != '\0')
return(std::string(constImage()->magick));
return(constOptions()->magick());
}
void Magick::Image::mask(const Magick::Image &mask_)
{
modifyImage();
if (mask_.isValid())
SetImageMask(image(),mask_.constImage());
else
SetImageMask(image(),0);
}
Magick::Image Magick::Image::mask(void) const
{
MagickCore::Image
*image;
GetPPException;
image=GetImageMask(constImage(),exceptionInfo);
ThrowImageException;
if (image == (MagickCore::Image *) NULL)
return(Magick::Image());
else
return(Magick::Image(image));
}
void Magick::Image::matte(const bool matteFlag_)
{
modifyImage();
if ((matteFlag_ && !constImage()->matte) || (constImage()->matte &&
!matteFlag_))
SetImageOpacity(image(),OpaqueOpacity);
image()->matte=(MagickBooleanType) matteFlag_;
}
bool Magick::Image::matte(void) const
{
if (constImage()->matte)
return true;
else
return false;
}
void Magick::Image::matteColor(const Color &matteColor_)
{
modifyImage();
if (matteColor_.isValid())
{
image()->matte_color=matteColor_;
options()->matteColor(matteColor_);
}
else
{
Color
tmpColor("#BDBDBD");
image()->matte_color=tmpColor;
options()->matteColor(tmpColor);
}
}
Magick::Color Magick::Image::matteColor(void) const
{
return(Color(constImage()->matte_color.red,constImage()->matte_color.green,
constImage()->matte_color.blue));
}
double Magick::Image::meanErrorPerPixel(void) const
{
return(constImage()->error.mean_error_per_pixel);
}
void Magick::Image::modulusDepth(const size_t depth_)
{
modifyImage();
SetImageDepth(image(),depth_);
options()->depth(depth_);
}
size_t Magick::Image::modulusDepth(void) const
{
size_t
depth;
GetPPException;
depth=GetImageDepth(constImage(),exceptionInfo);
ThrowImageException;
return(depth);
}
void Magick::Image::monochrome(const bool monochromeFlag_)
{
modifyImage();
options()->monochrome(monochromeFlag_);
}
bool Magick::Image::monochrome(void) const
{
return(constOptions()->monochrome());
}
Magick::Geometry Magick::Image::montageGeometry(void) const
{
if (constImage()->montage)
return(Magick::Geometry(constImage()->montage));
throwExceptionExplicit(CorruptImageWarning,
"Image does not contain a montage");
return(Magick::Geometry());
}
double Magick::Image::normalizedMaxError(void) const
{
return(constImage()->error.normalized_maximum_error);
}
double Magick::Image::normalizedMeanError(void) const
{
return (constImage()->error.normalized_mean_error);
}
void Magick::Image::orientation(const Magick::OrientationType orientation_)
{
modifyImage();
image()->orientation=orientation_;
}
Magick::OrientationType Magick::Image::orientation(void) const
{
return(constImage()->orientation);
}
void Magick::Image::page(const Magick::Geometry &pageSize_)
{
modifyImage();
options()->page(pageSize_);
image()->page=pageSize_;
}
Magick::Geometry Magick::Image::page(void) const
{
return(Geometry(constImage()->page.width,constImage()->page.height,
AbsoluteValue(constImage()->page.x),AbsoluteValue(constImage()->page.y),
constImage()->page.x < 0 ? true : false,
constImage()->page.y < 0 ? true : false));
}
void Magick::Image::penColor(const Color &penColor_)
{
modifyImage();
options()->fillColor(penColor_);
options()->strokeColor(penColor_);
}
Magick::Color Magick::Image::penColor(void) const
{
return(constOptions()->fillColor());
}
void Magick::Image::penTexture(const Image &penTexture_)
{
modifyImage();
if(penTexture_.isValid())
options()->fillPattern(penTexture_.constImage());
else
options()->fillPattern(static_cast<MagickCore::Image*>(NULL));
}
Magick::Image Magick::Image::penTexture(void) const
{
const MagickCore::Image
*tmpTexture;
Image
texture;
tmpTexture=constOptions()->fillPattern();
if (tmpTexture)
{
MagickCore::Image
*image;
GetPPException;
image=CloneImage(tmpTexture,0,0,MagickTrue,exceptionInfo);
texture.replaceImage(image);
ThrowImageException;
}
return(texture);
}
void Magick::Image::quality(const size_t quality_)
{
modifyImage();
image()->quality=quality_;
options()->quality(quality_);
}
size_t Magick::Image::quality(void) const
{
return(constImage()->quality);
}
void Magick::Image::quantizeColors(const size_t colors_)
{
modifyImage();
options()->quantizeColors(colors_);
}
size_t Magick::Image::quantizeColors(void) const
{
return(constOptions()->quantizeColors());
}
void Magick::Image::quantizeColorSpace(
const Magick::ColorspaceType colorSpace_)
{
modifyImage();
options()->quantizeColorSpace(colorSpace_);
}
Magick::ColorspaceType Magick::Image::quantizeColorSpace(void) const
{
return(constOptions()->quantizeColorSpace());
}
void Magick::Image::quantizeDither(const bool ditherFlag_)
{
modifyImage();
options()->quantizeDither(ditherFlag_);
}
bool Magick::Image::quantizeDither(void) const
{
return(constOptions()->quantizeDither());
}
void Magick::Image::quantizeDitherMethod(const DitherMethod ditherMethod_)
{
modifyImage();
options()->quantizeDitherMethod(ditherMethod_);
}
MagickCore::DitherMethod Magick::Image::quantizeDitherMethod(void) const
{
return(constOptions()->quantizeDitherMethod());
}
void Magick::Image::quantizeTreeDepth(const size_t treeDepth_)
{
modifyImage();
options()->quantizeTreeDepth(treeDepth_);
}
size_t Magick::Image::quantizeTreeDepth(void) const
{
return(constOptions()->quantizeTreeDepth());
}
void Magick::Image::quiet(const bool quiet_)
{
modifyImage();
options()->quiet(quiet_);
}
bool Magick::Image::quiet(void) const
{
return(constOptions()->quiet());
}
void Magick::Image::renderingIntent(
const Magick::RenderingIntent renderingIntent_)
{
modifyImage();
image()->rendering_intent=renderingIntent_;
}
Magick::RenderingIntent Magick::Image::renderingIntent(void) const
{
return(static_cast<Magick::RenderingIntent>(
constImage()->rendering_intent));
}
void Magick::Image::resolutionUnits(
const Magick::ResolutionType resolutionUnits_)
{
modifyImage();
image()->units=resolutionUnits_;
options()->resolutionUnits(resolutionUnits_);
}
Magick::ResolutionType Magick::Image::resolutionUnits(void) const
{
return(static_cast<Magick::ResolutionType>(constImage()->units));
}
void Magick::Image::scene(const size_t scene_)
{
modifyImage();
image()->scene=scene_;
}
size_t Magick::Image::scene(void) const
{
return(constImage()->scene);
}
void Magick::Image::size(const Geometry &geometry_)
{
modifyImage();
options()->size(geometry_);
image()->rows=geometry_.height();
image()->columns=geometry_.width();
}
Magick::Geometry Magick::Image::size(void) const
{
return(Magick::Geometry(constImage()->columns,constImage()->rows));
}
void Magick::Image::strokeAntiAlias(const bool flag_)
{
modifyImage();
options()->strokeAntiAlias(flag_);
}
bool Magick::Image::strokeAntiAlias(void) const
{
return(constOptions()->strokeAntiAlias());
}
void Magick::Image::strokeColor(const Magick::Color &strokeColor_)
{
std::string
value;
modifyImage();
options()->strokeColor(strokeColor_);
value=strokeColor_;
artifact("stroke",value);
}
Magick::Color Magick::Image::strokeColor(void) const
{
return(constOptions()->strokeColor());
}
void Magick::Image::strokeDashArray(const double *strokeDashArray_)
{
modifyImage();
options()->strokeDashArray(strokeDashArray_);
}
const double *Magick::Image::strokeDashArray(void) const
{
return(constOptions()->strokeDashArray());
}
void Magick::Image::strokeDashOffset(const double strokeDashOffset_)
{
modifyImage();
options()->strokeDashOffset(strokeDashOffset_);
}
double Magick::Image::strokeDashOffset(void) const
{
return(constOptions()->strokeDashOffset());
}
void Magick::Image::strokeLineCap(const Magick::LineCap lineCap_)
{
modifyImage();
options()->strokeLineCap(lineCap_);
}
Magick::LineCap Magick::Image::strokeLineCap(void) const
{
return(constOptions()->strokeLineCap());
}
void Magick::Image::strokeLineJoin(const Magick::LineJoin lineJoin_)
{
modifyImage();
options()->strokeLineJoin(lineJoin_);
}
Magick::LineJoin Magick::Image::strokeLineJoin(void) const
{
return(constOptions()->strokeLineJoin());
}
void Magick::Image::strokeMiterLimit(const size_t strokeMiterLimit_)
{
modifyImage();
options()->strokeMiterLimit(strokeMiterLimit_);
}
size_t Magick::Image::strokeMiterLimit(void) const
{
return constOptions()->strokeMiterLimit();
}
void Magick::Image::strokePattern(const Image &strokePattern_)
{
modifyImage();
if(strokePattern_.isValid())
options()->strokePattern(strokePattern_.constImage());
else
options()->strokePattern(static_cast<MagickCore::Image*>(NULL));
}
Magick::Image Magick::Image::strokePattern(void) const
{
const MagickCore::Image
*tmpTexture;
Image
texture;
tmpTexture=constOptions()->strokePattern();
if (tmpTexture)
{
MagickCore::Image
*image;
GetPPException;
image=CloneImage(tmpTexture,0,0,MagickTrue,exceptionInfo);
texture.replaceImage(image);
ThrowImageException;
}
return(texture);
}
void Magick::Image::strokeWidth(const double strokeWidth_)
{
char
value[MaxTextExtent];
modifyImage();
options()->strokeWidth(strokeWidth_);
FormatLocaleString(value,MaxTextExtent,"%.20g",strokeWidth_);
(void) SetImageArtifact(image(),"strokewidth",value);
}
double Magick::Image::strokeWidth(void) const
{
return(constOptions()->strokeWidth());
}
void Magick::Image::subImage(const size_t subImage_)
{
modifyImage();
options()->subImage(subImage_);
}
size_t Magick::Image::subImage(void) const
{
return(constOptions()->subImage());
}
void Magick::Image::subRange(const size_t subRange_)
{
modifyImage();
options()->subRange(subRange_);
}
size_t Magick::Image::subRange(void) const
{
return(constOptions()->subRange());
}
void Magick::Image::textDirection(DirectionType direction_)
{
modifyImage();
options()->textDirection(direction_);
}
Magick::DirectionType Magick::Image::textDirection(void) const
{
return(constOptions()->textDirection());
}
void Magick::Image::textEncoding(const std::string &encoding_)
{
modifyImage();
options()->textEncoding(encoding_);
}
std::string Magick::Image::textEncoding(void) const
{
return(constOptions()->textEncoding());
}
void Magick::Image::textGravity(GravityType gravity_)
{
modifyImage();
options()->textGravity(gravity_);
}
Magick::GravityType Magick::Image::textGravity(void) const
{
return(constOptions()->textGravity());
}
void Magick::Image::textInterlineSpacing(double spacing_)
{
modifyImage();
options()->textInterlineSpacing(spacing_);
}
double Magick::Image::textInterlineSpacing(void) const
{
return(constOptions()->textInterlineSpacing());
}
void Magick::Image::textInterwordSpacing(double spacing_)
{
modifyImage();
options()->textInterwordSpacing(spacing_);
}
double Magick::Image::textInterwordSpacing(void) const
{
return(constOptions()->textInterwordSpacing());
}
void Magick::Image::textKerning(double kerning_)
{
modifyImage();
options()->textKerning(kerning_);
}
double Magick::Image::textKerning(void) const
{
return(constOptions()->textKerning());
}
void Magick::Image::textUnderColor(const Color &underColor_)
{
modifyImage();
options()->textUnderColor(underColor_);
}
Magick::Color Magick::Image::textUnderColor(void) const
{
return(constOptions()->textUnderColor());
}
void Magick::Image::tileName(const std::string &tileName_)
{
modifyImage();
options()->tileName(tileName_);
}
std::string Magick::Image::tileName(void) const
{
return(constOptions()->tileName());
}
size_t Magick::Image::totalColors(void) const
{
size_t
colors;
GetPPException;
colors=GetNumberColors(constImage(),0,exceptionInfo);
ThrowImageException;
return(colors);
}
void Magick::Image::transformRotation(const double angle_)
{
modifyImage();
options()->transformRotation(angle_);
}
void Magick::Image::transformSkewX(const double skewx_)
{
modifyImage();
options()->transformSkewX(skewx_);
}
void Magick::Image::transformSkewY(const double skewy_)
{
modifyImage();
options()->transformSkewY(skewy_);
}
void Magick::Image::type(const Magick::ImageType type_)
{
modifyImage();
options()->type(type_);
SetImageType(image(),type_);
}
Magick::ImageType Magick::Image::type(void) const
{
if (constOptions()->type() != UndefinedType)
return(constOptions()->type());
else if (constImage()->type != UndefinedType)
return(constImage()->type);
else
return(determineType());
}
void Magick::Image::verbose(const bool verboseFlag_)
{
modifyImage();
options()->verbose(verboseFlag_);
}
bool Magick::Image::verbose(void) const
{
return(constOptions()->verbose());
}
void Magick::Image::view(const std::string &view_)
{
modifyImage();
options()->view(view_);
}
std::string Magick::Image::view(void) const
{
return(constOptions()->view());
}
void Magick::Image::virtualPixelMethod(
const VirtualPixelMethod virtual_pixel_method_)
{
modifyImage();
SetImageVirtualPixelMethod(image(),virtual_pixel_method_);
options()->virtualPixelMethod(virtual_pixel_method_);
}
Magick::VirtualPixelMethod Magick::Image::virtualPixelMethod(void) const
{
return(GetImageVirtualPixelMethod(constImage()));
}
void Magick::Image::x11Display(const std::string &display_)
{
modifyImage();
options()->x11Display(display_);
}
std::string Magick::Image::x11Display(void) const
{
return(constOptions()->x11Display());
}
double Magick::Image::xResolution(void) const
{
return(constImage()->x_resolution);
}
double Magick::Image::yResolution(void) const
{
return(constImage()->y_resolution);
}
void Magick::Image::adaptiveBlur(const double radius_,const double sigma_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=AdaptiveBlurImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::adaptiveResize(const Geometry &geometry_)
{
MagickCore::Image
*newImage;
size_t
width=columns(),
height=rows();
ssize_t
x=0,
y=0;
ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
&height);
GetPPException;
newImage=AdaptiveResizeImage(constImage(),width,height,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::adaptiveSharpen(const double radius_,const double sigma_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=AdaptiveSharpenImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::adaptiveSharpenChannel(const ChannelType channel_,
const double radius_,const double sigma_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=AdaptiveSharpenImageChannel(constImage(),channel_,radius_,sigma_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::adaptiveThreshold(const size_t width_,const size_t height_,
const ssize_t offset_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=AdaptiveThresholdImage(constImage(),width_,height_,offset_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::addNoise(const NoiseType noiseType_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=AddNoiseImage(constImage(),noiseType_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::addNoiseChannel(const ChannelType channel_,
const NoiseType noiseType_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=AddNoiseImageChannel(constImage(),channel_,noiseType_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::affineTransform(const DrawableAffine &affine_ )
{
AffineMatrix
_affine;
MagickCore::Image
*newImage;
_affine.sx = affine_.sx();
_affine.sy = affine_.sy();
_affine.rx = affine_.rx();
_affine.ry = affine_.ry();
_affine.tx = affine_.tx();
_affine.ty = affine_.ty();
GetPPException;
newImage=AffineTransformImage(constImage(),&_affine,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::alphaChannel(AlphaChannelType alphaType_)
{
modifyImage();
SetImageAlphaChannel(image(), alphaType_);
throwImageException();
}
void Magick::Image::annotate(const std::string &text_,
const Geometry &location_)
{
annotate(text_,location_,NorthWestGravity,0.0);
}
void Magick::Image::annotate(const std::string &text_,
const Geometry &boundingArea_,const GravityType gravity_)
{
annotate(text_,boundingArea_,gravity_,0.0);
}
void Magick::Image::annotate(const std::string &text_,
const Geometry &boundingArea_,const GravityType gravity_,
const double degrees_)
{
AffineMatrix
oaffine;
char
boundingArea[MaxTextExtent];
DrawInfo
*drawInfo;
modifyImage();
drawInfo=options()->drawInfo();
drawInfo->text=const_cast<char *>(text_.c_str());
drawInfo->geometry=0;
if (boundingArea_.isValid())
{
if (boundingArea_.width() == 0 || boundingArea_.height() == 0)
{
FormatLocaleString(boundingArea,MaxTextExtent,"%+.20g%+.20g",
(double) boundingArea_.xOff(),(double) boundingArea_.yOff());
}
else
{
(void) CopyMagickString(boundingArea,
std::string(boundingArea_).c_str(), MaxTextExtent);
}
drawInfo->geometry=boundingArea;
}
drawInfo->gravity=gravity_;
oaffine=drawInfo->affine;
if (degrees_ != 0.0)
{
AffineMatrix
affine,
current;
affine.sx=1.0;
affine.rx=0.0;
affine.ry=0.0;
affine.sy=1.0;
affine.tx=0.0;
affine.ty=0.0;
current=drawInfo->affine;
affine.sx=cos(DegreesToRadians(fmod(degrees_,360.0)));
affine.rx=sin(DegreesToRadians(fmod(degrees_,360.0)));
affine.ry=(-sin(DegreesToRadians(fmod(degrees_,360.0))));
affine.sy=cos(DegreesToRadians(fmod(degrees_,360.0)));
drawInfo->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
drawInfo->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
drawInfo->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
drawInfo->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
drawInfo->affine.tx=current.sx*affine.tx+current.ry*affine.ty
+current.tx;
}
AnnotateImage(image(),drawInfo);
drawInfo->affine=oaffine;
drawInfo->text=0;
drawInfo->geometry=0;
throwImageException();
}
void Magick::Image::annotate(const std::string &text_,
const GravityType gravity_)
{
DrawInfo
*drawInfo;
modifyImage();
drawInfo=options()->drawInfo();
drawInfo->text=const_cast<char *>(text_.c_str());
drawInfo->gravity=gravity_;
AnnotateImage(image(),drawInfo);
drawInfo->gravity=NorthWestGravity;
drawInfo->text=0;
throwImageException();
}
void Magick::Image::artifact(const std::string &name_,
const std::string &value_)
{
modifyImage();
(void) SetImageArtifact(image(),name_.c_str(),value_.c_str());
}
std::string Magick::Image::artifact(const std::string &name_) const
{
const char
*value;
value=GetImageArtifact(constImage(),name_.c_str());
if (value)
return(std::string(value));
return(std::string());
}
void Magick::Image::attribute(const std::string name_,const std::string value_)
{
modifyImage();
SetImageProperty(image(),name_.c_str(),value_.c_str());
}
std::string Magick::Image::attribute(const std::string name_) const
{
const char
*value;
value=GetImageProperty(constImage(),name_.c_str());
if (value)
return(std::string(value));
return(std::string());
}
void Magick::Image::autoGamma(void)
{
modifyImage();
(void) AutoGammaImage(image());
throwImageException();
}
void Magick::Image::autoGammaChannel(const ChannelType channel_)
{
modifyImage();
(void) AutoGammaImageChannel(image(),channel_);
throwImageException();
}
void Magick::Image::autoLevel(void)
{
modifyImage();
(void) AutoLevelImage(image());
throwImageException();
}
void Magick::Image::autoLevelChannel(const ChannelType channel_)
{
modifyImage();
(void) AutoLevelImageChannel(image(),channel_);
throwImageException();
}
void Magick::Image::autoOrient(void)
{
MagickCore::Image
*newImage;
if (image()->orientation == UndefinedOrientation ||
image()->orientation == TopLeftOrientation)
return;
GetPPException;
newImage=AutoOrientImage(constImage(),image()->orientation,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::blackThreshold(const std::string &threshold_)
{
modifyImage();
BlackThresholdImage(image(),threshold_.c_str());
throwImageException();
}
void Magick::Image::blackThresholdChannel(const ChannelType channel_,
const std::string &threshold_)
{
modifyImage();
GetPPException;
BlackThresholdImageChannel(image(),channel_,threshold_.c_str(),
exceptionInfo);
ThrowImageException;
}
void Magick::Image::blueShift(const double factor_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=BlueShiftImage(constImage(),factor_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::blur(const double radius_, const double sigma_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=BlurImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::blurChannel(const ChannelType channel_,
const double radius_,const double sigma_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=BlurImageChannel(constImage(),channel_,radius_,sigma_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::border(const Geometry &geometry_)
{
MagickCore::Image
*newImage;
RectangleInfo
borderInfo=geometry_;
GetPPException;
newImage=BorderImage(constImage(),&borderInfo,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::brightnessContrast(const double brightness_,
const double contrast_)
{
modifyImage();
BrightnessContrastImage(image(),brightness_,contrast_);
throwImageException();
}
void Magick::Image::brightnessContrastChannel(const ChannelType channel_,
const double brightness_,const double contrast_)
{
modifyImage();
BrightnessContrastImageChannel(image(),channel_,brightness_,contrast_);
throwImageException();
}
void Magick::Image::cannyEdge(const double radius_,const double sigma_,
const double lowerPercent_,const double upperPercent_)
{
MagickCore::Image
*newImage;
modifyImage();
GetPPException;
newImage=CannyEdgeImage(constImage(),radius_,sigma_,lowerPercent_,
upperPercent_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::cdl(const std::string &cdl_)
{
modifyImage();
(void) ColorDecisionListImage(image(),cdl_.c_str());
throwImageException();
}
void Magick::Image::channel(const ChannelType channel_)
{
modifyImage();
SeparateImageChannel(image(),channel_);
throwImageException();
}
void Magick::Image::channelDepth(const ChannelType channel_,
const size_t depth_)
{
modifyImage();
SetImageChannelDepth(image(),channel_,depth_);
throwImageException();
}
size_t Magick::Image::channelDepth(const ChannelType channel_)
{
size_t
channel_depth;
GetPPException;
channel_depth=GetImageChannelDepth(constImage(), channel_,exceptionInfo);
ThrowImageException;
return channel_depth;
}
void Magick::Image::charcoal(const double radius_,const double sigma_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=CharcoalImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::chop(const Geometry &geometry_)
{
MagickCore::Image
*newImage;
RectangleInfo
chopInfo=geometry_;
GetPPException;
newImage=ChopImage(constImage(),&chopInfo,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::chromaBluePrimary(const double x_,const double y_)
{
modifyImage();
image()->chromaticity.blue_primary.x=x_;
image()->chromaticity.blue_primary.y=y_;
}
void Magick::Image::chromaBluePrimary(double *x_,double *y_) const
{
*x_=constImage()->chromaticity.blue_primary.x;
*y_=constImage()->chromaticity.blue_primary.y;
}
void Magick::Image::chromaGreenPrimary(const double x_,const double y_)
{
modifyImage();
image()->chromaticity.green_primary.x=x_;
image()->chromaticity.green_primary.y=y_;
}
void Magick::Image::chromaGreenPrimary(double *x_,double *y_) const
{
*x_=constImage()->chromaticity.green_primary.x;
*y_=constImage()->chromaticity.green_primary.y;
}
void Magick::Image::chromaRedPrimary(const double x_,const double y_)
{
modifyImage();
image()->chromaticity.red_primary.x=x_;
image()->chromaticity.red_primary.y=y_;
}
void Magick::Image::chromaRedPrimary(double *x_,double *y_) const
{
*x_=constImage()->chromaticity.red_primary.x;
*y_=constImage()->chromaticity.red_primary.y;
}
void Magick::Image::chromaWhitePoint(const double x_,const double y_)
{
modifyImage();
image()->chromaticity.white_point.x=x_;
image()->chromaticity.white_point.y=y_;
}
void Magick::Image::chromaWhitePoint(double *x_,double *y_) const
{
*x_=constImage()->chromaticity.white_point.x;
*y_=constImage()->chromaticity.white_point.y;
}
void Magick::Image::clamp(void)
{
modifyImage();
ClampImage(image());
throwImageException();
}
void Magick::Image::clampChannel(const ChannelType channel_)
{
modifyImage();
ClampImageChannel(image(),channel_);
throwImageException();
}
void Magick::Image::clip(void )
{
modifyImage();
ClipImage(image());
throwImageException();
}
void Magick::Image::clipPath(const std::string pathname_,const bool inside_)
{
modifyImage();
ClipImagePath(image(),pathname_.c_str(),(MagickBooleanType) inside_);
throwImageException();
}
void Magick::Image::clut(const Image &clutImage_)
{
modifyImage();
ClutImage(image(),clutImage_.constImage());
throwImageException();
}
void Magick::Image::clutChannel(const ChannelType channel_,
const Image &clutImage_)
{
modifyImage();
ClutImageChannel(image(),channel_,clutImage_.constImage());
throwImageException();
}
void Magick::Image::colorize(const unsigned int opacityRed_,
const unsigned int opacityGreen_,const unsigned int opacityBlue_,
const Color &penColor_)
{
char
opacity[MaxTextExtent];
MagickCore::Image
*newImage;
if (!penColor_.isValid())
throwExceptionExplicit( OptionError, "Pen color argument is invalid" );
FormatLocaleString(opacity,MaxTextExtent,"%u/%u/%u",opacityRed_,
opacityGreen_,opacityBlue_);
GetPPException;
newImage=ColorizeImage(image(),opacity,penColor_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::colorize(const unsigned int opacity_,
const Color &penColor_)
{
colorize(opacity_,opacity_,opacity_,penColor_);
}
void Magick::Image::colorMap(const size_t index_,const Color &color_)
{
if (index_ > (MaxColormapSize-1) )
throwExceptionExplicit(OptionError,
"Colormap index must be less than MaxColormapSize");
if (!color_.isValid())
throwExceptionExplicit(OptionError,"Color argument is invalid");
modifyImage();
if (colorMapSize() < (index_+1))
colorMapSize(index_+1);
(image()->colormap)[index_]=color_;
}
Magick::Color Magick::Image::colorMap(const size_t index_) const
{
if (!constImage()->colormap)
{
throwExceptionExplicit(OptionError,"Image does not contain a colormap");
return(Color());
}
if (index_ > constImage()->colors-1)
throwExceptionExplicit(OptionError,"Index out of range");
return(Color((constImage()->colormap)[index_]));
}
void Magick::Image::colorMatrix(const size_t order_,
const double *color_matrix_)
{
KernelInfo
*kernel_info;
MagickCore::Image
*newImage;
GetPPException;
kernel_info=AcquireKernelInfo("1");
if (kernel_info != (KernelInfo *) NULL)
{
kernel_info->width=order_;
kernel_info->height=order_;
kernel_info->values=(double *) color_matrix_;
newImage=ColorMatrixImage(constImage(),kernel_info,exceptionInfo);
kernel_info->values=(double *) NULL;
kernel_info=DestroyKernelInfo(kernel_info);
replaceImage(newImage);
ThrowImageException;
}
}
bool Magick::Image::compare(const Image &reference_)
{
bool
status;
Image
ref=reference_;
modifyImage();
ref.modifyImage();
status=static_cast<bool>(IsImagesEqual(image(),ref.constImage()));
throwImageException();
return(status);
}
double Magick::Image::compare(const Image &reference_,const MetricType metric_)
{
double
distortion=0.0;
GetPPException;
GetImageDistortion(image(),reference_.constImage(),metric_,&distortion,
exceptionInfo);
ThrowImageException;
return(distortion);
}
double Magick::Image::compareChannel(const ChannelType channel_,
const Image &reference_,const MetricType metric_)
{
double
distortion=0.0;
GetPPException;
GetImageChannelDistortion(image(),reference_.constImage(),channel_,metric_,
&distortion,exceptionInfo);
ThrowImageException;
return(distortion);
}
Magick::Image Magick::Image::compare(const Image &reference_,
const MetricType metric_,double *distortion)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=CompareImages(image(),reference_.constImage(),metric_,distortion,
exceptionInfo);
ThrowImageException;
if (newImage == (MagickCore::Image *) NULL)
return(Magick::Image());
else
return(Magick::Image(newImage));
}
Magick::Image Magick::Image::compareChannel(const ChannelType channel_,
const Image &reference_,const MetricType metric_,double *distortion)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=CompareImageChannels(image(),reference_.constImage(),channel_,
metric_,distortion,exceptionInfo);
ThrowImageException;
if (newImage == (MagickCore::Image *) NULL)
return(Magick::Image());
else
return(Magick::Image(newImage));
}
void Magick::Image::composite(const Image &compositeImage_,
const Geometry &offset_,const CompositeOperator compose_)
{
size_t
height=rows(),
width=columns();
ssize_t
x=offset_.xOff(),
y=offset_.yOff();
modifyImage();
ParseMetaGeometry(static_cast<std::string>(offset_).c_str(),&x,&y,&width,
&height);
CompositeImage(image(),compose_,compositeImage_.constImage(),x,y);
throwImageException();
}
void Magick::Image::composite(const Image &compositeImage_,
const GravityType gravity_,const CompositeOperator compose_)
{
RectangleInfo
geometry;
modifyImage();
SetGeometry(compositeImage_.constImage(),&geometry);
GravityAdjustGeometry(columns(),rows(),gravity_,&geometry);
CompositeImage(image(),compose_,compositeImage_.constImage(),geometry.x,
geometry.y);
throwImageException();
}
void Magick::Image::composite(const Image &compositeImage_,
const ssize_t xOffset_,const ssize_t yOffset_,
const CompositeOperator compose_)
{
modifyImage();
CompositeImage(image(),compose_,compositeImage_.constImage(),xOffset_,
yOffset_);
throwImageException();
}
void Magick::Image::connectedComponents(const size_t connectivity_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=ConnectedComponentsImage(constImage(),connectivity_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::contrast(const size_t sharpen_)
{
modifyImage();
ContrastImage(image(),(MagickBooleanType) sharpen_);
throwImageException();
}
void Magick::Image::contrastStretch(const double black_point_,
const double white_point_)
{
modifyImage();
ContrastStretchImageChannel(image(),DefaultChannels,black_point_,
white_point_);
throwImageException();
}
void Magick::Image::contrastStretchChannel(const ChannelType channel_,
const double black_point_,const double white_point_)
{
modifyImage();
ContrastStretchImageChannel(image(),channel_,black_point_,white_point_);
throwImageException();
}
void Magick::Image::convolve(const size_t order_,const double *kernel_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=ConvolveImage(constImage(),order_,kernel_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::copyPixels(const Image &source_,const Geometry &geometry_,
const Offset &offset_)
{
const OffsetInfo
offset=offset_;
const RectangleInfo
geometry=geometry_;
GetPPException;
(void) CopyImagePixels(image(),source_.constImage(),&geometry,&offset,
exceptionInfo);
ThrowImageException;
}
void Magick::Image::crop(const Geometry &geometry_)
{
MagickCore::Image
*newImage;
RectangleInfo
cropInfo=geometry_;
GetPPException;
newImage=CropImage(constImage(),&cropInfo,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::cycleColormap(const ssize_t amount_)
{
modifyImage();
CycleColormapImage(image(),amount_);
throwImageException();
}
void Magick::Image::decipher(const std::string &passphrase_)
{
modifyImage();
GetPPException;
DecipherImage(image(),passphrase_.c_str(),exceptionInfo);
ThrowImageException;
}
void Magick::Image::defineSet(const std::string &magick_,
const std::string &key_,bool flag_)
{
std::string
definition;
modifyImage();
definition=magick_ + ":" + key_;
if (flag_)
(void) SetImageOption(imageInfo(),definition.c_str(),"");
else
DeleteImageOption(imageInfo(),definition.c_str());
}
bool Magick::Image::defineSet(const std::string &magick_,
const std::string &key_) const
{
const char
*option;
std::string
key;
key=magick_ + ":" + key_;
option=GetImageOption(constImageInfo(),key.c_str());
if (option)
return(true);
return(false);
}
void Magick::Image::defineValue(const std::string &magick_,
const std::string &key_,const std::string &value_)
{
std::string
format;
modifyImage();
format=magick_ + ":" + key_;
(void) SetImageOption(imageInfo(),format.c_str(),value_.c_str());
}
std::string Magick::Image::defineValue(const std::string &magick_,
const std::string &key_) const
{
const char
*option;
std::string
definition;
definition=magick_ + ":" + key_;
option=GetImageOption(constImageInfo(),definition.c_str());
if (option)
return(std::string(option));
return(std::string());
}
void Magick::Image::deskew(const double threshold_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=DeskewImage(constImage(),threshold_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::despeckle(void)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=DespeckleImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
Magick::ImageType Magick::Image::determineType(void) const
{
ImageType
image_type;
GetPPException;
image_type=GetImageType(constImage(),exceptionInfo);
ThrowImageException;
return(image_type);
}
void Magick::Image::display(void)
{
DisplayImages(imageInfo(),image());
}
void Magick::Image::distort(const DistortImageMethod method_,
const size_t number_arguments_,const double *arguments_,const bool bestfit_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=DistortImage(constImage(),method_,number_arguments_,arguments_,
bestfit_ == true ? MagickTrue : MagickFalse,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::draw(const Magick::Drawable &drawable_)
{
DrawingWand
*wand;
modifyImage();
wand=AcquireDrawingWand(options()->drawInfo(),image());
if(wand)
{
drawable_.operator()(wand);
if (constImage()->exception.severity == UndefinedException)
DrawRender(wand);
wand=DestroyDrawingWand(wand);
}
throwImageException();
}
void Magick::Image::draw(const std::list<Magick::Drawable> &drawable_)
{
DrawingWand
*wand;
modifyImage();
wand=AcquireDrawingWand(options()->drawInfo(),image());
if(wand)
{
for (std::list<Magick::Drawable>::const_iterator p = drawable_.begin();
p != drawable_.end(); p++)
{
p->operator()(wand);
if (constImage()->exception.severity != UndefinedException)
break;
}
if (constImage()->exception.severity == UndefinedException)
DrawRender(wand);
wand=DestroyDrawingWand(wand);
}
throwImageException();
}
void Magick::Image::edge(const double radius_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=EdgeImage(constImage(),radius_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::emboss(const double radius_,const double sigma_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=EmbossImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::encipher(const std::string &passphrase_)
{
modifyImage();
GetPPException;
EncipherImage(image(),passphrase_.c_str(),exceptionInfo);
ThrowImageException;
}
void Magick::Image::enhance(void)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=EnhanceImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::equalize(void)
{
modifyImage();
EqualizeImage(image());
throwImageException();
}
void Magick::Image::erase(void)
{
modifyImage();
(void) SetImageBackgroundColor(image());
throwImageException();
}
void Magick::Image::extent(const Geometry &geometry_)
{
MagickCore::Image
*newImage;
RectangleInfo
extentInfo;
modifyImage();
GetPPException;
extentInfo=geometry_;
extentInfo.x=geometry_.xOff();
extentInfo.y=geometry_.yOff();
newImage=ExtentImage(constImage(),&extentInfo,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::extent(const Geometry &geometry_,
const Color &backgroundColor_)
{
backgroundColor(backgroundColor_);
extent(geometry_);
}
void Magick::Image::extent(const Geometry &geometry_,
const Color &backgroundColor_,const GravityType gravity_)
{
image()->gravity=gravity_;
backgroundColor(backgroundColor_);
extent(geometry_,gravity_);
}
void Magick::Image::extent(const Geometry &geometry_,
const GravityType gravity_)
{
RectangleInfo
geometry;
SetGeometry(image(),&geometry);
geometry.width=geometry_.width();
geometry.height=geometry_.height();
GravityAdjustGeometry(image()->columns,image()->rows,gravity_,&geometry);
extent(geometry);
}
void Magick::Image::flip(void)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=FlipImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::floodFillColor(const Geometry &point_,
const Magick::Color &fillColor_)
{
floodFillColor(point_.xOff(),point_.yOff(),fillColor_,false);
}
void Magick::Image::floodFillColor(const Geometry &point_,
const Magick::Color &fillColor_,const bool invert_)
{
floodFillColor(point_.xOff(),point_.yOff(),fillColor_,invert_);
}
void Magick::Image::floodFillColor(const ssize_t x_,const ssize_t y_,
const Magick::Color &fillColor_)
{
floodFillColor(x_,y_,fillColor_,false);
}
void Magick::Image::floodFillColor(const ssize_t x_,const ssize_t y_,
const Magick::Color &fillColor_,const bool invert_)
{
PixelPacket
pixel;
modifyImage();
pixel=pixelColor(x_,y_);
floodFill(x_,y_,(Magick::Image *)NULL,fillColor_,&pixel,invert_);
}
void Magick::Image::floodFillColor(const Geometry &point_,
const Magick::Color &fillColor_,const Magick::Color &borderColor_)
{
floodFillColor(point_.xOff(),point_.yOff(),fillColor_,borderColor_,false);
}
void Magick::Image::floodFillColor(const Geometry &point_,
const Magick::Color &fillColor_,const Magick::Color &borderColor_,
const bool invert_)
{
floodFillColor(point_.xOff(),point_.yOff(),fillColor_,borderColor_,invert_);
}
void Magick::Image::floodFillColor(const ssize_t x_,const ssize_t y_,
const Magick::Color &fillColor_,const Magick::Color &borderColor_)
{
floodFillColor(x_,y_,fillColor_,borderColor_,false);
}
void Magick::Image::floodFillColor(const ssize_t x_,const ssize_t y_,
const Magick::Color &fillColor_,const Magick::Color &borderColor_,
const bool invert_)
{
PixelPacket
pixel;
modifyImage();
pixel=static_cast<PixelPacket>(borderColor_);
floodFill(x_,y_,(Magick::Image *)NULL,fillColor_,&pixel,invert_);
}
void Magick::Image::floodFillOpacity(const ssize_t x_,const ssize_t y_,
const unsigned int opacity_,const bool invert_)
{
MagickPixelPacket
target;
PixelPacket
pixel;
modifyImage();
GetMagickPixelPacket(constImage(),&target);
pixel=static_cast<PixelPacket>(pixelColor(x_,y_));
target.red=pixel.red;
target.green=pixel.green;
target.blue=pixel.blue;
target.opacity=opacity_;
(void) FloodfillPaintImage(image(),OpacityChannel,options()->drawInfo(),
&target,x_,y_,(MagickBooleanType)invert_);
throwImageException();
}
void Magick::Image::floodFillOpacity(const ssize_t x_,const ssize_t y_,
const unsigned int opacity_,const PaintMethod method_)
{
floodFillOpacity(x_,y_,opacity_,method_ == FloodfillMethod ? false : true);
}
void Magick::Image::floodFillOpacity(const ::ssize_t x_,const ::ssize_t y_,
const unsigned int opacity_,const Color &target_,const bool invert_)
{
MagickPixelPacket
target;
PixelPacket
pixel;
modifyImage();
GetMagickPixelPacket(constImage(),&target);
pixel=static_cast<PixelPacket>(target_);
target.red=pixel.red;
target.green=pixel.green;
target.blue=pixel.blue;
target.opacity=opacity_;
(void) FloodfillPaintImage(image(),OpacityChannel,options()->drawInfo(),
&target,x_,y_,(MagickBooleanType)invert_);
throwImageException();
}
void Magick::Image::floodFillTexture(const Magick::Geometry &point_,
const Magick::Image &texture_)
{
floodFillTexture(point_.xOff(),point_.yOff(),texture_,false);
}
void Magick::Image::floodFillTexture(const Magick::Geometry &point_,
const Magick::Image &texture_,const bool invert_)
{
floodFillTexture(point_.xOff(),point_.yOff(),texture_,invert_);
}
void Magick::Image::floodFillTexture(const ssize_t x_,const ssize_t y_,
const Magick::Image &texture_)
{
floodFillTexture(x_,y_,texture_,false);
}
void Magick::Image::floodFillTexture(const ssize_t x_,const ssize_t y_,
const Magick::Image &texture_,const bool invert_)
{
PixelPacket
pixel;
modifyImage();
pixel=static_cast<PixelPacket>(pixelColor(x_,y_));
floodFill(x_,y_,&texture_,Magick::Color(),&pixel,invert_);
}
void Magick::Image::floodFillTexture(const Magick::Geometry &point_,
const Magick::Image &texture_,const Magick::Color &borderColor_)
{
floodFillTexture(point_.xOff(),point_.yOff(),texture_,borderColor_,false);
}
void Magick::Image::floodFillTexture(const Magick::Geometry &point_,
const Magick::Image &texture_,const Magick::Color &borderColor_,
const bool invert_)
{
floodFillTexture(point_.xOff(),point_.yOff(),texture_,borderColor_,invert_);
}
void Magick::Image::floodFillTexture(const ssize_t x_,const ssize_t y_,
const Magick::Image &texture_,const Magick::Color &borderColor_)
{
floodFillTexture(x_,y_,texture_,borderColor_,false);
}
void Magick::Image::floodFillTexture(const ssize_t x_,const ssize_t y_,
const Magick::Image &texture_,const Magick::Color &borderColor_,
const bool invert_)
{
PixelPacket
pixel;
modifyImage();
pixel=static_cast<PixelPacket>(borderColor_);
floodFill(x_,y_,&texture_,Magick::Color(),&pixel,invert_);
}
void Magick::Image::flop(void)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=FlopImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::fontTypeMetrics(const std::string &text_,
TypeMetric *metrics)
{
DrawInfo
*drawInfo;
drawInfo=options()->drawInfo();
drawInfo->text=const_cast<char *>(text_.c_str());
if (GetTypeMetrics(image(),drawInfo,&(metrics->_typeMetric)) == MagickFalse)
throwImageException();
drawInfo->text=0;
}
void Magick::Image::fontTypeMetricsMultiline(const std::string &text_,
TypeMetric *metrics)
{
DrawInfo
*drawInfo;
drawInfo=options()->drawInfo();
drawInfo->text=const_cast<char *>(text_.c_str());
GetMultilineTypeMetrics(image(),drawInfo,&(metrics->_typeMetric));
drawInfo->text=0;
}
void Magick::Image::frame(const Geometry &geometry_)
{
FrameInfo
info;
MagickCore::Image
*newImage;
info.x=static_cast<ssize_t>(geometry_.width());
info.y=static_cast<ssize_t>(geometry_.height());
info.width=columns() + ( static_cast<size_t>(info.x) << 1 );
info.height=rows() + ( static_cast<size_t>(info.y) << 1 );
info.outer_bevel=geometry_.xOff();
info.inner_bevel=geometry_.yOff();
GetPPException;
newImage=FrameImage(constImage(),&info,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::frame(const size_t width_,const size_t height_,
const ssize_t innerBevel_,const ssize_t outerBevel_)
{
FrameInfo
info;
MagickCore::Image
*newImage;
info.x=static_cast<ssize_t>(width_);
info.y=static_cast<ssize_t>(height_);
info.width=columns() + ( static_cast<size_t>(info.x) << 1 );
info.height=rows() + ( static_cast<size_t>(info.y) << 1 );
info.outer_bevel=static_cast<ssize_t>(outerBevel_);
info.inner_bevel=static_cast<ssize_t>(innerBevel_);
GetPPException;
newImage=FrameImage(constImage(),&info,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::fx(const std::string expression)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=FxImageChannel(constImage(),DefaultChannels,expression.c_str(),
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::fx(const std::string expression,
const Magick::ChannelType channel)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=FxImageChannel(constImage(),channel,expression.c_str(),
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::gamma(const double gamma_)
{
char
gamma[MaxTextExtent + 1];
FormatLocaleString(gamma,MaxTextExtent,"%3.6f",gamma_);
modifyImage();
GammaImage(image(),gamma);
}
void Magick::Image::gamma(const double gammaRed_,const double gammaGreen_,
const double gammaBlue_)
{
char
gamma[MaxTextExtent + 1];
FormatLocaleString(gamma,MaxTextExtent,"%3.6f/%3.6f/%3.6f/",gammaRed_,
gammaGreen_,gammaBlue_);
modifyImage();
GammaImage(image(),gamma);
throwImageException();
}
void Magick::Image::gaussianBlur(const double width_,const double sigma_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=GaussianBlurImage(constImage(),width_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::gaussianBlurChannel(const ChannelType channel_,
const double width_,const double sigma_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=GaussianBlurImageChannel(constImage(),channel_,width_,sigma_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
const Magick::IndexPacket* Magick::Image::getConstIndexes(void) const
{
const Magick::IndexPacket
*result;
result=GetVirtualIndexQueue(constImage());
if (!result)
throwImageException();
return(result);
}
const Magick::PixelPacket* Magick::Image::getConstPixels(const ssize_t x_,
const ssize_t y_,const size_t columns_,const size_t rows_) const
{
const PixelPacket
*result;
GetPPException;
result=GetVirtualPixels(constImage(),x_,y_,columns_,rows_,exceptionInfo);
ThrowImageException;
return(result);
}
Magick::IndexPacket *Magick::Image::getIndexes(void)
{
Magick::IndexPacket
*result;
result=GetAuthenticIndexQueue(image());
if(!result)
throwImageException();
return(result);
}
Magick::PixelPacket *Magick::Image::getPixels(const ssize_t x_,
const ssize_t y_,const size_t columns_,const size_t rows_)
{
PixelPacket
*result;
modifyImage();
GetPPException;
result=GetAuthenticPixels(image(),x_,y_,columns_,rows_,exceptionInfo);
ThrowImageException;
return(result);
}
void Magick::Image::grayscale(const PixelIntensityMethod method_)
{
modifyImage();
(void) GrayscaleImage(image(),method_);
throwImageException();
}
void Magick::Image::haldClut(const Image &clutImage_)
{
modifyImage();
(void) HaldClutImage(image(),clutImage_.constImage());
throwImageException();
}
void Magick::Image::houghLine(const size_t width_,const size_t height_,
const size_t threshold_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=HoughLineImage(constImage(),width_,height_,threshold_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::implode(const double factor_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=ImplodeImage(constImage(),factor_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::inverseFourierTransform(const Image &phase_)
{
inverseFourierTransform(phase_,true);
}
void Magick::Image::inverseFourierTransform(const Image &phase_,
const bool magnitude_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=InverseFourierTransformImage(constImage(),phase_.constImage(),
magnitude_ == true ? MagickTrue : MagickFalse,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::kuwahara(const double radius_,const double sigma_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=KuwaharaImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::kuwaharaChannel(const ChannelType channel_,
const double radius_,const double sigma_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=KuwaharaImageChannel(constImage(),channel_,radius_,sigma_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::level(const double black_point,const double white_point,
const double gamma)
{
char
levels[MaxTextExtent];
modifyImage();
FormatLocaleString(levels,MaxTextExtent,"%g,%g,%g",black_point,white_point,
gamma);
(void) LevelImage(image(),levels);
throwImageException();
}
void Magick::Image::levelChannel(const Magick::ChannelType channel,
const double black_point,const double white_point,const double gamma)
{
modifyImage();
(void) LevelImageChannel(image(),channel,black_point,white_point,gamma);
throwImageException();
}
void Magick::Image::levelColors(const Color &blackColor_,
const Color &whiteColor_,const bool invert_)
{
MagickPixelPacket
black,
white;
PixelPacket
pixel;
modifyImage();
GetMagickPixelPacket(image(),&black);
pixel=static_cast<PixelPacket>(blackColor_);
black.red=pixel.red;
black.green=pixel.green;
black.blue=pixel.blue;
black.opacity=pixel.opacity;
GetMagickPixelPacket(image(),&white);
pixel=static_cast<PixelPacket>(whiteColor_);
white.red=pixel.red;
white.green=pixel.green;
white.blue=pixel.blue;
white.opacity=pixel.opacity;
(void) LevelColorsImage(image(),&black,&white,
invert_ == true ? MagickTrue : MagickFalse);
throwImageException();
}
void Magick::Image::levelColorsChannel(const ChannelType channel_,
const Color &blackColor_,const Color &whiteColor_,const bool invert_)
{
MagickPixelPacket
black,
white;
PixelPacket
pixel;
modifyImage();
GetMagickPixelPacket(image(),&black);
pixel=static_cast<PixelPacket>(blackColor_);
black.red=pixel.red;
black.green=pixel.green;
black.blue=pixel.blue;
black.opacity=pixel.opacity;
GetMagickPixelPacket(image(),&white);
pixel=static_cast<PixelPacket>(whiteColor_);
white.red=pixel.red;
white.green=pixel.green;
white.blue=pixel.blue;
white.opacity=pixel.opacity;
(void) LevelColorsImageChannel(image(),channel_,&black,&white,
invert_ == true ? MagickTrue : MagickFalse);
throwImageException();
}
void Magick::Image::levelize(const double blackPoint_,const double whitePoint_,
const double gamma_)
{
modifyImage();
(void) LevelizeImage(image(),blackPoint_,whitePoint_,gamma_);
throwImageException();
}
void Magick::Image::levelizeChannel(const ChannelType channel_,
const double blackPoint_,const double whitePoint_,const double gamma_)
{
modifyImage();
(void) LevelizeImageChannel(image(),channel_,blackPoint_,whitePoint_,gamma_);
throwImageException();
}
void Magick::Image::linearStretch(const double blackPoint_,
const double whitePoint_)
{
modifyImage();
LinearStretchImage(image(),blackPoint_,whitePoint_);
throwImageException();
}
void Magick::Image::liquidRescale(const Geometry &geometry_)
{
MagickCore::Image
*newImage;
size_t
height=rows(),
width=columns();
ssize_t
x=0,
y=0;
ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
&height);
GetPPException;
newImage=LiquidRescaleImage(constImage(),width,height,x,y,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::localContrast(const double radius_,const double strength_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=LocalContrastImage(constImage(),radius_,strength_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::magnify(void)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=MagnifyImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::map(const Image &mapImage_,const bool dither_)
{
modifyImage();
options()->quantizeDither(dither_);
RemapImage(options()->quantizeInfo(),image(),mapImage_.constImage());
throwImageException();
}
void Magick::Image::matteFloodfill(const Color &target_,
const unsigned int opacity_,const ssize_t x_,const ssize_t y_,
const Magick::PaintMethod method_)
{
floodFillOpacity(x_,y_,opacity_,target_,
method_ == FloodfillMethod ? false : true);
}
void Magick::Image::medianFilter(const double radius_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=StatisticImage(constImage(),MedianStatistic,(size_t) radius_,
(size_t) radius_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::mergeLayers(const ImageLayerMethod layerMethod_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=MergeImageLayers(image(),layerMethod_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::minify(void)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=MinifyImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::modulate(const double brightness_,const double saturation_,
const double hue_)
{
char
modulate[MaxTextExtent + 1];
FormatLocaleString(modulate,MaxTextExtent,"%3.6f,%3.6f,%3.6f",brightness_,
saturation_,hue_);
modifyImage();
ModulateImage(image(),modulate);
throwImageException();
}
Magick::ImageMoments Magick::Image::moments(void) const
{
return(ImageMoments(*this));
}
void Magick::Image::morphology(const MorphologyMethod method_,
const std::string kernel_,const ssize_t iterations_)
{
KernelInfo
*kernel;
MagickCore::Image
*newImage;
kernel=AcquireKernelInfo(kernel_.c_str());
if (kernel == (KernelInfo *)NULL)
throwExceptionExplicit(OptionError,"Unable to parse kernel.");
GetPPException;
newImage=MorphologyImage(constImage(),method_,iterations_,kernel,
exceptionInfo);
replaceImage(newImage);
kernel=DestroyKernelInfo(kernel);
ThrowImageException;
}
void Magick::Image::morphology(const MorphologyMethod method_,
const KernelInfoType kernel_,const std::string arguments_,
const ssize_t iterations_)
{
const char
*option;
std::string
kernel;
option=CommandOptionToMnemonic(MagickKernelOptions,kernel_);
if (option == (const char *)NULL)
{
throwExceptionExplicit(OptionError,"Unable to determine kernel type.");
return;
}
kernel=std::string(option);
if (!arguments_.empty())
kernel+=":"+arguments_;
morphology(method_,kernel,iterations_);
}
void Magick::Image::morphologyChannel(const ChannelType channel_,
const MorphologyMethod method_,const std::string kernel_,
const ssize_t iterations_)
{
KernelInfo
*kernel;
MagickCore::Image
*newImage;
kernel=AcquireKernelInfo(kernel_.c_str());
if (kernel == (KernelInfo *)NULL)
{
throwExceptionExplicit(OptionError,"Unable to parse kernel.");
return;
}
GetPPException;
newImage=MorphologyImageChannel(constImage(),channel_,method_,iterations_,
kernel,exceptionInfo);
replaceImage(newImage);
kernel=DestroyKernelInfo(kernel);
ThrowImageException;
}
void Magick::Image::morphologyChannel(const ChannelType channel_,
const MorphologyMethod method_,const KernelInfoType kernel_,
const std::string arguments_,const ssize_t iterations_)
{
const char
*option;
std::string
kernel;
option=CommandOptionToMnemonic(MagickKernelOptions,kernel_);
if (option == (const char *)NULL)
throwExceptionExplicit(OptionError,"Unable to determine kernel type.");
kernel=std::string(option);
if (!arguments_.empty())
kernel+=":"+arguments_;
morphologyChannel(channel_,method_,kernel,iterations_);
}
void Magick::Image::motionBlur(const double radius_,const double sigma_,
const double angle_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=MotionBlurImage(constImage(),radius_,sigma_,angle_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::negate(const bool grayscale_)
{
modifyImage();
NegateImage(image(),(MagickBooleanType) grayscale_);
throwImageException();
}
void Magick::Image::negateChannel(const ChannelType channel_,
const bool grayscale_)
{
modifyImage();
NegateImageChannel(image(),channel_,(MagickBooleanType) grayscale_);
throwImageException();
}
void Magick::Image::normalize(void)
{
modifyImage();
NormalizeImage(image());
throwImageException();
}
void Magick::Image::oilPaint(const double radius_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=OilPaintImage(constImage(),radius_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::opacity(const unsigned int opacity_)
{
modifyImage();
SetImageOpacity(image(),opacity_);
}
void Magick::Image::opaque(const Color &opaqueColor_,const Color &penColor_,
const bool invert_)
{
MagickPixelPacket
opaque,
pen;
std::string
opaqueColor,
penColor;
if (!opaqueColor_.isValid())
throwExceptionExplicit(OptionError,"Opaque color argument is invalid");
if (!penColor_.isValid())
throwExceptionExplicit(OptionError,"Pen color argument is invalid");
opaqueColor=opaqueColor_;
penColor=penColor_;
(void) QueryMagickColor(opaqueColor.c_str(),&opaque,&image()->exception);
(void) QueryMagickColor(penColor.c_str(),&pen,&image()->exception);
modifyImage();
OpaquePaintImage(image(),&opaque,&pen,invert_ ? MagickTrue : MagickFalse);
throwImageException();
}
void Magick::Image::orderedDither(std::string thresholdMap_)
{
modifyImage();
GetPPException;
(void) OrderedPosterizeImage(image(),thresholdMap_.c_str(),exceptionInfo);
ThrowImageException;
}
void Magick::Image::orderedDitherChannel(const ChannelType channel_,
std::string thresholdMap_)
{
modifyImage();
GetPPException;
(void) OrderedPosterizeImageChannel(image(),channel_,thresholdMap_.c_str(),
exceptionInfo);
ThrowImageException;
}
void Magick::Image::perceptible(const double epsilon_)
{
modifyImage();
PerceptibleImage(image(),epsilon_);
throwImageException();
}
void Magick::Image::perceptibleChannel(const ChannelType channel_,
const double epsilon_)
{
modifyImage();
PerceptibleImageChannel(image(),channel_,epsilon_);
throwImageException();
}
void Magick::Image::ping(const Blob& blob_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=PingBlob(imageInfo(),blob_.data(),blob_.length(),exceptionInfo);
read(newImage,exceptionInfo);
}
void Magick::Image::ping(const std::string &imageSpec_)
{
MagickCore::Image
*newImage;
GetPPException;
options()->fileName(imageSpec_);
newImage=PingImage(imageInfo(),exceptionInfo);
read(newImage,exceptionInfo);
}
void Magick::Image::pixelColor(const ssize_t x_,const ssize_t y_,
const Color &color_)
{
if (y_ > (ssize_t) rows() || x_ > (ssize_t) columns())
throwExceptionExplicit(OptionError,"Access outside of image boundary");
modifyImage();
classType(DirectClass);
Pixels pixels(*this);
*(pixels.get(x_,y_,1,1))=color_;
pixels.sync();
}
Magick::Color Magick::Image::pixelColor(const ssize_t x_,
const ssize_t y_) const
{
ClassType
storage_class;
storage_class=classType();
if (storage_class == DirectClass)
{
const PixelPacket
*pixel;
pixel=getConstPixels(x_,y_,1,1);
if (pixel)
return(Color(*pixel));
}
else if (storage_class == PseudoClass)
{
const IndexPacket
*indexes;
indexes=getConstIndexes();
if(indexes)
return(colorMap((size_t) *indexes));
}
return(Color());
}
void Magick::Image::polaroid(const std::string &caption_,const double angle_)
{
MagickCore::Image
*newImage;
GetPPException;
(void) SetImageProperty(image(),"Caption",caption_.c_str());
newImage=PolaroidImage(constImage(),options()->drawInfo(),angle_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::posterize(const size_t levels_,const bool dither_)
{
modifyImage();
PosterizeImage(image(),levels_,(MagickBooleanType) dither_);
throwImageException();
}
void Magick::Image::posterizeChannel(const ChannelType channel_,
const size_t levels_,const bool dither_)
{
modifyImage();
PosterizeImageChannel(image(),channel_,levels_,
(MagickBooleanType) dither_);
throwImageException();
}
void Magick::Image::process(std::string name_,const ssize_t argc,
const char **argv)
{
size_t
status;
modifyImage();
status=InvokeDynamicImageFilter(name_.c_str(),&image(),argc, argv,
&image()->exception);
if (status == false)
throwImageException();
}
void Magick::Image::profile(const std::string name_,
const Magick::Blob &profile_)
{
ssize_t
result;
modifyImage();
result=ProfileImage(image(),name_.c_str(),(unsigned char *)profile_.data(),
profile_.length(),MagickTrue);
if (!result)
throwImageException();
}
Magick::Blob Magick::Image::profile(const std::string name_) const
{
const StringInfo
*profile;
profile=GetImageProfile(constImage(),name_.c_str());
if (profile == (StringInfo *) NULL)
return(Blob());
return(Blob((void*) GetStringInfoDatum(profile),GetStringInfoLength(
profile)));
}
void Magick::Image::quantize(const bool measureError_)
{
modifyImage();
if (measureError_)
options()->quantizeInfo()->measure_error=MagickTrue;
else
options()->quantizeInfo()->measure_error=MagickFalse;
QuantizeImage(options()->quantizeInfo(),image());
throwImageException();
}
void Magick::Image::quantumOperator(const ChannelType channel_,
const MagickEvaluateOperator operator_,double rvalue_)
{
GetPPException;
EvaluateImageChannel(image(),channel_,operator_,rvalue_,exceptionInfo);
ThrowImageException;
}
void Magick::Image::quantumOperator(const ChannelType channel_,
const MagickFunction function_,const size_t number_parameters_,
const double *parameters_)
{
GetPPException;
FunctionImageChannel(image(),channel_,function_,number_parameters_,
parameters_,exceptionInfo);
ThrowImageException;
}
void Magick::Image::quantumOperator(const ssize_t x_,const ssize_t y_,
const size_t columns_,const size_t rows_,const ChannelType channel_,
const MagickEvaluateOperator operator_,const double rvalue_)
{
MagickCore::Image
*cropImage;
RectangleInfo
geometry;
GetPPException;
geometry.width=columns_;
geometry.height=rows_;
geometry.x=x_;
geometry.y=y_;
cropImage=CropImage(image(),&geometry,exceptionInfo);
EvaluateImageChannel(cropImage,channel_,operator_,rvalue_,exceptionInfo);
(void) CompositeImage(image(),image()->matte != MagickFalse ?
OverCompositeOp : CopyCompositeOp,cropImage,geometry.x, geometry.y);
cropImage=DestroyImageList(cropImage);
ThrowImageException;
}
void Magick::Image::raise(const Geometry &geometry_,const bool raisedFlag_)
{
RectangleInfo
raiseInfo;
raiseInfo=geometry_;
modifyImage();
RaiseImage(image(),&raiseInfo,raisedFlag_ == true ?
MagickTrue : MagickFalse);
throwImageException();
}
void Magick::Image::randomThreshold( const Geometry &thresholds_ )
{
GetPPException;
modifyImage();
(void) RandomThresholdImage(image(),static_cast<std::string>(
thresholds_).c_str(),exceptionInfo);
ThrowImageException;
}
void Magick::Image::randomThresholdChannel(const Geometry &thresholds_,
const ChannelType channel_)
{
GetPPException;
modifyImage();
(void) RandomThresholdImageChannel(image(),channel_,static_cast<std::string>(
thresholds_).c_str(),exceptionInfo);
ThrowImageException;
}
void Magick::Image::read(const Blob &blob_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=BlobToImage(imageInfo(),static_cast<const void *>(blob_.data()),
blob_.length(),exceptionInfo);
read(newImage,exceptionInfo);
}
void Magick::Image::read(const Blob &blob_,const Geometry &size_)
{
size(size_);
read(blob_);
}
void Magick::Image::read(const Blob &blob_,const Geometry &size_,
const size_t depth_)
{
size(size_);
depth(depth_);
read(blob_);
}
void Magick::Image::read(const Blob &blob_,const Geometry &size_,
const size_t depth_,const std::string &magick_)
{
size(size_);
depth(depth_);
magick(magick_);
fileName(magick_ + ':');
read(blob_);
}
void Magick::Image::read(const Blob &blob_,const Geometry &size_,
const std::string &magick_)
{
size(size_);
magick(magick_);
fileName(magick_ + ':');
read(blob_);
}
void Magick::Image::read(const Geometry &size_,const std::string &imageSpec_)
{
size(size_);
read(imageSpec_);
}
void Magick::Image::read(const size_t width_,const size_t height_,
const std::string &map_,const StorageType type_,const void *pixels_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=ConstituteImage(width_,height_,map_.c_str(),type_,pixels_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
if (newImage)
throwException(&newImage->exception,quiet());
}
void Magick::Image::read(const std::string &imageSpec_)
{
MagickCore::Image
*newImage;
options()->fileName(imageSpec_);
GetPPException;
newImage=ReadImage(imageInfo(),exceptionInfo);
read(newImage,exceptionInfo);
}
void Magick::Image::readPixels(const Magick::QuantumType quantum_,
const unsigned char *source_)
{
QuantumInfo
*quantum_info;
GetPPException;
quantum_info=AcquireQuantumInfo(imageInfo(),image());
ImportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
quantum_,source_,exceptionInfo);
quantum_info=DestroyQuantumInfo(quantum_info);
ThrowImageException;
}
void Magick::Image::reduceNoise(const double order_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=StatisticImage(constImage(),NonpeakStatistic,(size_t) order_,
(size_t) order_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::repage()
{
modifyImage();
options()->page(Geometry());
image()->page.width = 0;
image()->page.height = 0;
image()->page.x = 0;
image()->page.y = 0;
}
void Magick::Image::resample(const Geometry &geometry_)
{
MagickCore::Image
*newImage;
size_t
width=columns(),
height=rows();
ssize_t
x=0,
y=0;
ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x, &y,&width,
&height);
GetPPException;
newImage=ResampleImage(constImage(),width,height,image()->filter,1.0,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::resize(const Geometry &geometry_)
{
MagickCore::Image
*newImage;
size_t
width=columns(),
height=rows();
ssize_t
x=0,
y=0;
ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x, &y,&width,
&height);
GetPPException;
newImage=ResizeImage(constImage(),width,height,image()->filter,1.0,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::roll(const Geometry &roll_)
{
MagickCore::Image
*newImage;
ssize_t
xOff=roll_.xOff(),
yOff=roll_.yOff();
if (roll_.xNegative())
xOff=0-xOff;
if (roll_.yNegative())
yOff=0-yOff;
GetPPException;
newImage=RollImage(constImage(),xOff,yOff,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::roll(const size_t columns_,const size_t rows_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=RollImage(constImage(),static_cast<ssize_t>(columns_),
static_cast<ssize_t>(rows_),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::rotate(const double degrees_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=RotateImage(constImage(),degrees_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::rotationalBlur(const double angle_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=RotationalBlurImage(constImage(),angle_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::rotationalBlurChannel(const ChannelType channel_,
const double angle_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=RotationalBlurImageChannel(constImage(),channel_,angle_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::sample(const Geometry &geometry_)
{
MagickCore::Image
*newImage;
size_t
height=rows(),
width=columns();
ssize_t
x=0,
y=0;
ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
&height);
GetPPException;
newImage=SampleImage(constImage(),width,height,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::scale(const Geometry &geometry_)
{
MagickCore::Image
*newImage;
size_t
height=rows(),
width=columns();
ssize_t
x=0,
y=0;
ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
&height);
GetPPException;
newImage=ScaleImage(constImage(),width,height,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::segment(const double clusterThreshold_,
const double smoothingThreshold_)
{
modifyImage();
SegmentImage(image(),options()->quantizeColorSpace(),
(MagickBooleanType) options()->verbose(),clusterThreshold_,
smoothingThreshold_);
throwImageException();
SyncImage(image());
throwImageException();
}
void Magick::Image::selectiveBlur(const double radius_,const double sigma_,
const double threshold_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=SelectiveBlurImage(constImage(),radius_,sigma_,threshold_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::selectiveBlurChannel(const ChannelType channel_,
const double radius_,const double sigma_,const double threshold_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=SelectiveBlurImageChannel(constImage(),channel_,radius_,sigma_,
threshold_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
Magick::Image Magick::Image::separate(const ChannelType channel_) const
{
MagickCore::Image
*image;
GetPPException;
image=SeparateImage(constImage(),channel_,exceptionInfo);
ThrowImageException;
if (image == (MagickCore::Image *) NULL)
return(Magick::Image());
else
return(Magick::Image(image));
}
void Magick::Image::sepiaTone(const double threshold_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=SepiaToneImage(constImage(),threshold_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
Magick::PixelPacket *Magick::Image::setPixels(const ssize_t x_,
const ssize_t y_,const size_t columns_,const size_t rows_)
{
PixelPacket
*result;
modifyImage();
GetPPException;
result=QueueAuthenticPixels(image(),x_, y_,columns_,rows_,exceptionInfo);
ThrowImageException;
return(result);
}
void Magick::Image::shade(const double azimuth_,const double elevation_,
const bool colorShading_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=ShadeImage(constImage(),colorShading_ == true ?
MagickTrue : MagickFalse,azimuth_,elevation_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::shadow(const double percent_opacity_,const double sigma_,
const ssize_t x_,const ssize_t y_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=ShadowImage(constImage(),percent_opacity_,sigma_,x_,y_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::sharpen(const double radius_,const double sigma_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=SharpenImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::sharpenChannel(const ChannelType channel_,
const double radius_,const double sigma_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=SharpenImageChannel(constImage(),channel_,radius_,sigma_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::shave(const Geometry &geometry_)
{
MagickCore::Image
*newImage;
RectangleInfo
shaveInfo=geometry_;
GetPPException;
newImage=ShaveImage(constImage(),&shaveInfo,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::shear(const double xShearAngle_,const double yShearAngle_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=ShearImage(constImage(),xShearAngle_,yShearAngle_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::sigmoidalContrast(const size_t sharpen_,
const double contrast,const double midpoint)
{
modifyImage();
(void) SigmoidalContrastImageChannel(image(),DefaultChannels,
(MagickBooleanType) sharpen_,contrast,midpoint);
throwImageException();
}
std::string Magick::Image::signature(const bool force_) const
{
const char
*property;
Lock lock(&_imgRef->_mutexLock);
if (force_ || !GetImageProperty(constImage(), "Signature") ||
constImage()->taint)
SignatureImage(const_cast<MagickCore::Image *>(constImage()));
property=GetImageProperty(constImage(),"Signature");
return(std::string(property));
}
void Magick::Image::sketch(const double radius_,const double sigma_,
const double angle_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=SketchImage(constImage(),radius_,sigma_,angle_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::solarize(const double factor_)
{
modifyImage();
SolarizeImage(image(),factor_);
throwImageException();
}
void Magick::Image::sparseColor(const ChannelType channel,
const SparseColorMethod method,const size_t number_arguments,
const double *arguments)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=SparseColorImage(constImage(),channel,method,number_arguments,
arguments,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::splice(const Geometry &geometry_)
{
MagickCore::Image
*newImage;
RectangleInfo
spliceInfo=geometry_;
GetPPException;
newImage=SpliceImage(constImage(),&spliceInfo,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::splice(const Geometry &geometry_,
const Color &backgroundColor_)
{
backgroundColor(backgroundColor_);
splice(geometry_);
}
void Magick::Image::splice(const Geometry &geometry_,
const Color &backgroundColor_,const GravityType gravity_)
{
backgroundColor(backgroundColor_);
image()->gravity=gravity_;
splice(geometry_);
}
void Magick::Image::spread(const size_t amount_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=SpreadImage(constImage(),amount_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::statistics(ImageStatistics *statistics) const
{
double
maximum,
minimum;
GetPPException;
(void) GetImageChannelRange(constImage(),RedChannel,&minimum,&maximum,
exceptionInfo);
statistics->red.minimum=minimum;
statistics->red.maximum=maximum;
(void) GetImageChannelMean(constImage(),RedChannel,&statistics->red.mean,
&statistics->red.standard_deviation,exceptionInfo);
(void) GetImageChannelKurtosis(constImage(),RedChannel,
&statistics->red.kurtosis,&statistics->red.skewness,exceptionInfo);
(void) GetImageChannelRange(constImage(),GreenChannel,&minimum,&maximum,
exceptionInfo);
statistics->green.minimum=minimum;
statistics->green.maximum=maximum;
(void) GetImageChannelMean(constImage(),GreenChannel,&statistics->green.mean,
&statistics->green.standard_deviation,exceptionInfo);
(void) GetImageChannelKurtosis(constImage(),GreenChannel,
&statistics->green.kurtosis,&statistics->green.skewness,exceptionInfo);
(void) GetImageChannelRange(constImage(),BlueChannel,&minimum,&maximum,
exceptionInfo);
statistics->blue.minimum=minimum;
statistics->blue.maximum=maximum;
(void) GetImageChannelMean(constImage(),BlueChannel,&statistics->blue.mean,
&statistics->blue.standard_deviation,exceptionInfo);
(void) GetImageChannelKurtosis(constImage(),BlueChannel,
&statistics->blue.kurtosis,&statistics->blue.skewness,exceptionInfo);
(void) GetImageChannelRange(constImage(),OpacityChannel,&minimum,&maximum,
exceptionInfo);
statistics->opacity.minimum=minimum;
statistics->opacity.maximum=maximum;
(void) GetImageChannelMean(constImage(),OpacityChannel,
&statistics->opacity.mean,&statistics->opacity.standard_deviation,
exceptionInfo);
(void) GetImageChannelKurtosis(constImage(),OpacityChannel,
&statistics->opacity.kurtosis,&statistics->opacity.skewness,
exceptionInfo);
ThrowImageException;
}
void Magick::Image::stegano(const Image &watermark_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=SteganoImage(constImage(),watermark_.constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::stereo(const Image &rightImage_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=StereoImage(constImage(),rightImage_.constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::strip(void)
{
modifyImage();
StripImage(image());
throwImageException();
}
Magick::Image Magick::Image::subImageSearch(const Image &reference_,
const MetricType metric_,Geometry *offset_,double *similarityMetric_,
const double similarityThreshold)
{
char
artifact[MaxTextExtent];
MagickCore::Image
*newImage;
RectangleInfo
offset;
modifyImage();
(void) FormatLocaleString(artifact,MaxTextExtent,"%g",similarityThreshold);
(void) SetImageArtifact(image(),"compare:similarity-threshold",artifact);
GetPPException;
newImage=SimilarityMetricImage(image(),reference_.constImage(),metric_,
&offset,similarityMetric_,exceptionInfo);
ThrowImageException;
if (offset_ != (Geometry *) NULL)
*offset_=offset;
if (newImage == (MagickCore::Image *) NULL)
return(Magick::Image());
else
return(Magick::Image(newImage));
}
void Magick::Image::swirl(const double degrees_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=SwirlImage(constImage(),degrees_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::syncPixels(void)
{
GetPPException;
(void) SyncAuthenticPixels(image(),exceptionInfo);
ThrowImageException;
}
void Magick::Image::texture(const Image &texture_)
{
modifyImage();
TextureImage(image(),texture_.constImage());
throwImageException();
}
void Magick::Image::threshold(const double threshold_)
{
modifyImage();
BilevelImage(image(),threshold_);
throwImageException();
}
void Magick::Image::thumbnail(const Geometry &geometry_)
{
MagickCore::Image
*newImage;
size_t
height=rows(),
width=columns();
ssize_t
x=0,
y=0;
ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
&height);
GetPPException;
newImage=ThumbnailImage(constImage(),width,height,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::tint(const std::string opacity_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=TintImage(constImage(),opacity_.c_str(),constOptions()->fillColor(),
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::transform(const Geometry &imageGeometry_)
{
modifyImage();
TransformImage(&(image()),0,std::string(imageGeometry_).c_str());
throwImageException();
}
void Magick::Image::transform(const Geometry &imageGeometry_,
const Geometry &cropGeometry_)
{
modifyImage();
TransformImage(&(image()),std::string(cropGeometry_).c_str(),
std::string(imageGeometry_).c_str());
throwImageException();
}
void Magick::Image::transformOrigin(const double x_,const double y_)
{
modifyImage();
options()->transformOrigin(x_,y_);
}
void Magick::Image::transformReset(void)
{
modifyImage();
options()->transformReset();
}
void Magick::Image::transformScale(const double sx_,const double sy_)
{
modifyImage();
options()->transformScale(sx_,sy_);
}
void Magick::Image::transparent(const Color &color_)
{
MagickPixelPacket
target;
std::string
color;
if (!color_.isValid())
throwExceptionExplicit(OptionError,"Color argument is invalid");
color=color_;
(void) QueryMagickColor(std::string(color_).c_str(),&target,
&image()->exception);
modifyImage();
TransparentPaintImage(image(),&target,TransparentOpacity,MagickFalse);
throwImageException();
}
void Magick::Image::transparentChroma(const Color &colorLow_,
const Color &colorHigh_)
{
MagickPixelPacket
targetHigh,
targetLow;
std::string
colorHigh,
colorLow;
if (!colorLow_.isValid() || !colorHigh_.isValid())
throwExceptionExplicit(OptionError,"Color argument is invalid");
colorLow=colorLow_;
colorHigh=colorHigh_;
(void) QueryMagickColor(colorLow.c_str(),&targetLow,&image()->exception);
(void) QueryMagickColor(colorHigh.c_str(),&targetHigh,&image()->exception);
modifyImage();
TransparentPaintImageChroma(image(),&targetLow,&targetHigh,
TransparentOpacity,MagickFalse);
throwImageException();
}
void Magick::Image::transpose(void)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=TransposeImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::transverse(void)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=TransverseImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::trim(void)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=TrimImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
Magick::Image Magick::Image::uniqueColors(void) const
{
MagickCore::Image
*image;
GetPPException;
image=UniqueImageColors(constImage(),exceptionInfo);
ThrowImageException;
if (image == (MagickCore::Image *) NULL)
return(Magick::Image());
else
return(Magick::Image(image));
}
void Magick::Image::unsharpmask(const double radius_,const double sigma_,
const double amount_,const double threshold_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=UnsharpMaskImage(constImage(),radius_,sigma_,amount_,threshold_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::unsharpmaskChannel(const ChannelType channel_,
const double radius_,const double sigma_,const double amount_,
const double threshold_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=UnsharpMaskImageChannel(constImage(),channel_,radius_,sigma_,
amount_,threshold_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::vignette(const double radius_,const double sigma_,
const ssize_t x_,const ssize_t y_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=VignetteImage(constImage(),radius_,sigma_,x_,y_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::wave(const double amplitude_,const double wavelength_)
{
MagickCore::Image
*newImage;
GetPPException;
newImage=WaveImage(constImage(),amplitude_,wavelength_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
void Magick::Image::whiteThreshold(const std::string &threshold_)
{
modifyImage();
WhiteThresholdImage(image(),threshold_.c_str());
throwImageException();
}
void Magick::Image::whiteThresholdChannel(const ChannelType channel_,
const std::string &threshold_)
{
modifyImage();
GetPPException;
WhiteThresholdImageChannel(image(),channel_,threshold_.c_str(),
exceptionInfo);
ThrowImageException;
}
void Magick::Image::write(Blob *blob_)
{
size_t
length=0;
void
*data;
modifyImage();
GetPPException;
data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
if (length > 0)
blob_->updateNoCopy(data,length,Blob::MallocAllocator);
ThrowImageException;
throwImageException();
}
void Magick::Image::write(Blob *blob_,const std::string &magick_)
{
size_t
length=0;
void
*data;
modifyImage();
magick(magick_);
GetPPException;
data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
if (length > 0)
blob_->updateNoCopy(data,length,Blob::MallocAllocator);
ThrowImageException;
throwImageException();
}
void Magick::Image::write(Blob *blob_,const std::string &magick_,
const size_t depth_)
{
size_t
length=0;
void
*data;
modifyImage();
magick(magick_);
depth(depth_);
GetPPException;
data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
if (length > 0)
blob_->updateNoCopy(data,length,Blob::MallocAllocator);
ThrowImageException;
throwImageException();
}
void Magick::Image::write(const ssize_t x_,const ssize_t y_,
const size_t columns_,const size_t rows_,const std::string &map_,
const StorageType type_,void *pixels_)
{
GetPPException;
ExportImagePixels(constImage(),x_,y_,columns_,rows_,map_.c_str(),type_,
pixels_,exceptionInfo);
ThrowImageException;
}
void Magick::Image::write(const std::string &imageSpec_)
{
modifyImage();
fileName(imageSpec_);
WriteImage(constImageInfo(),image());
throwImageException();
}
void Magick::Image::writePixels(const Magick::QuantumType quantum_,
unsigned char *destination_)
{
QuantumInfo
*quantum_info;
quantum_info=AcquireQuantumInfo(imageInfo(),image());
GetPPException;
ExportQuantumPixels(constImage(),(MagickCore::CacheView *) NULL,quantum_info,
quantum_,destination_,exceptionInfo);
quantum_info=DestroyQuantumInfo(quantum_info);
ThrowImageException;
}
void Magick::Image::zoom(const Geometry &geometry_)
{
MagickCore::Image
*newImage;
size_t
height=rows(),
width=columns();
ssize_t
x=0,
y=0;
ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
&height);
GetPPException;
newImage=ResizeImage(constImage(),width,height,image()->filter,image()->blur,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}
Magick::Image::Image(MagickCore::Image *image_)
: _imgRef(new ImageRef(image_))
{
}
MagickCore::Image *&Magick::Image::image(void)
{
return(_imgRef->image());
}
const MagickCore::Image *Magick::Image::constImage(void) const
{
return(_imgRef->image());
}
MagickCore::ImageInfo *Magick::Image::imageInfo(void)
{
return(_imgRef->options()->imageInfo());
}
const MagickCore::ImageInfo *Magick::Image::constImageInfo(void) const
{
return(_imgRef->options()->imageInfo());
}
Magick::Options *Magick::Image::options(void)
{
return(_imgRef->options());
}
const Magick::Options *Magick::Image::constOptions(void) const
{
return(_imgRef->options());
}
MagickCore::QuantizeInfo *Magick::Image::quantizeInfo(void)
{
return(_imgRef->options()->quantizeInfo());
}
const MagickCore::QuantizeInfo *Magick::Image::constQuantizeInfo(void) const
{
return(_imgRef->options()->quantizeInfo());
}
void Magick::Image::modifyImage(void)
{
{
Lock lock(&_imgRef->_mutexLock);
if (_imgRef->_refCount == 1)
return;
}
GetPPException;
replaceImage(CloneImage(constImage(),0,0,MagickTrue,exceptionInfo));
ThrowImageException;
return;
}
MagickCore::Image *Magick::Image::replaceImage(MagickCore::Image *replacement_)
{
MagickCore::Image
*image;
if (replacement_)
image=replacement_;
else
image=AcquireImage(constImageInfo());
{
Lock lock(&_imgRef->_mutexLock);
if (_imgRef->_refCount == 1)
{
_imgRef->image(image);
}
else
{
--_imgRef->_refCount;
_imgRef=new ImageRef(image,constOptions());
}
}
return(_imgRef->_image);
}
void Magick::Image::throwImageException(void) const
{
throwException(&const_cast<MagickCore::Image*>(constImage())->exception,
quiet());
}
void Magick::Image::read(MagickCore::Image *image,
MagickCore::ExceptionInfo *exceptionInfo)
{
if (image != (MagickCore::Image *) NULL &&
image->next != (MagickCore::Image *) NULL)
{
MagickCore::Image
*next;
next=image->next;
image->next=(MagickCore::Image *) NULL;
next->previous=(MagickCore::Image *) NULL;
DestroyImageList(next);
}
replaceImage(image);
if (exceptionInfo->severity == MagickCore::UndefinedException &&
image == (MagickCore::Image *) NULL)
{
(void) MagickCore::DestroyExceptionInfo(exceptionInfo);
throwExceptionExplicit(ImageWarning,"No image was loaded.");
}
ThrowImageException;
if (image != (MagickCore::Image *) NULL)
throwException(&image->exception,quiet());
}
void Magick::Image::floodFill(const ssize_t x_,const ssize_t y_,
const Magick::Image *fillPattern_,const Magick::Color &fill_,
const MagickCore::PixelPacket *target_,const bool invert_)
{
Magick::Color
fillColor;
MagickCore::Image
*fillPattern;
MagickPixelPacket
target;
fillColor=options()->fillColor();
fillPattern=(MagickCore::Image *)NULL;
if (options()->fillPattern() != (MagickCore::Image *)NULL)
{
GetPPException;
fillPattern=CloneImage(options()->fillPattern(),0,0,MagickTrue,
exceptionInfo);
ThrowImageException;
}
if (fillPattern_ == (Magick::Image *)NULL)
{
options()->fillPattern((MagickCore::Image *)NULL);
options()->fillColor(fill_);
}
else
options()->fillPattern(fillPattern_->constImage());
GetMagickPixelPacket(image(),&target);
target.red=target_->red;
target.green=target_->green;
target.blue=target_->blue;
(void) FloodfillPaintImage(image(),DefaultChannels,options()->drawInfo(),
&target,static_cast<ssize_t>(x_),static_cast<ssize_t>(y_),
(MagickBooleanType) invert_);
options()->fillColor(fillColor);
options()->fillPattern(fillPattern);
throwImageException();
}