Magick++ 7.1.2-32
Convert, Edit, Or Compose Bitmap Images
Loading...
Searching...
No Matches
Magick::Image Class Reference

Public Member Functions

 Image (const Blob &blob_)
 Image (const Blob &blob_, const Geometry &size_)
 Image (const Blob &blob_, const Geometry &size_, const size_t depth_)
 Image (const Blob &blob_, const Geometry &size_, const size_t depth_, const std::string &magick_)
 Image (const Blob &blob_, const Geometry &size_, const std::string &magick_)
 Image (const Geometry &size_, const Color &color_)
 Image (const Image &image_)
 Image (const Image &image_, const Geometry &geometry_)
 Image (const size_t width_, const size_t height_, const std::string &map_, const StorageType type_, const void *pixels_)
 Image (const std::string &imageSpec_)
Image & operator= (const Image &image_)
void adjoin (const bool flag_)
bool adjoin (void) const
void alpha (const bool alphaFlag_)
bool alpha (void) const
void matteColor (const Color &matteColor_)
Color matteColor (void) const
void animationDelay (const size_t delay_)
size_t animationDelay (void) const
void animationIterations (const size_t iterations_)
size_t animationIterations (void) const
void backgroundColor (const Color &color_)
Color backgroundColor (void) const
void backgroundTexture (const std::string &backgroundTexture_)
std::string backgroundTexture (void) const
size_t baseColumns (void) const
std::string baseFilename (void) const
size_t baseRows (void) const
void blackPointCompensation (const bool flag_)
bool blackPointCompensation (void) const
void borderColor (const Color &color_)
Color borderColor (void) const
Geometry boundingBox (void) const
void boxColor (const Color &boxColor_)
Color boxColor (void) const
void channelDepth (const ChannelType channel_, const size_t depth_)
size_t channelDepth (const ChannelType channel_)
size_t channels () const
void classType (const ClassType class_)
ClassType classType (void) const
void colorFuzz (const double fuzz_)
double colorFuzz (void) const
void colorMapSize (const size_t entries_)
size_t colorMapSize (void) const
void colorSpace (const ColorspaceType colorSpace_)
ColorspaceType colorSpace (void) const
void colorSpaceType (const ColorspaceType colorSpace_)
ColorspaceType colorSpaceType (void) const
size_t columns (void) const
void comment (const std::string &comment_)
std::string comment (void) const
void compose (const CompositeOperator compose_)
CompositeOperator compose (void) const
void compressType (const CompressionType compressType_)
CompressionType compressType (void) const
void debug (const bool flag_)
bool debug (void) const
void density (const Point &density_)
Point density (void) const
void depth (const size_t depth_)
size_t depth (void) const
std::string directory (void) const
void endian (const EndianType endian_)
EndianType endian (void) const
void exifProfile (const Blob &exifProfile_)
Blob exifProfile (void) const
void fileName (const std::string &fileName_)
std::string fileName (void) const
MagickSizeType fileSize (void) const
void fillColor (const Color &fillColor_)
Color fillColor (void) const
void fillRule (const FillRule &fillRule_)
FillRule fillRule (void) const
void fillPattern (const Image &fillPattern_)
Image fillPattern (void) const
void filterType (const FilterType filterType_)
FilterType filterType (void) const
void font (const std::string &font_)
std::string font (void) const
void fontFamily (const std::string &family_)
std::string fontFamily (void) const
void fontPointsize (const double pointSize_)
double fontPointsize (void) const
void fontStyle (const StyleType style_)
StyleType fontStyle (void) const
void fontWeight (const size_t weight_)
size_t fontWeight (void) const
std::string format (void) const
std::string formatExpression (const std::string expression)
double gamma (void) const
Geometry geometry (void) const
void gifDisposeMethod (const DisposeType disposeMethod_)
DisposeType gifDisposeMethod (void) const
bool hasChannel (const PixelChannel channel) const
void highlightColor (const Color color_)
void iccColorProfile (const Blob &colorProfile_)
Blob iccColorProfile (void) const
void interlaceType (const InterlaceType interlace_)
InterlaceType interlaceType (void) const
void interpolate (const PixelInterpolateMethod interpolate_)
PixelInterpolateMethod interpolate (void) const
void iptcProfile (const Blob &iptcProfile_)
Blob iptcProfile (void) const
bool isOpaque (void) const
void isValid (const bool isValid_)
bool isValid (void) const
void label (const std::string &label_)
std::string label (void) const
void lowlightColor (const Color color_)
void magick (const std::string &magick_)
std::string magick (void) const
void masklightColor (const Color color_)
double meanErrorPerPixel (void) const
void modulusDepth (const size_t modulusDepth_)
size_t modulusDepth (void) const
void monochrome (const bool monochromeFlag_)
bool monochrome (void) const
Geometry montageGeometry (void) const
double normalizedMaxError (void) const
double normalizedMeanError (void) const
void orientation (const OrientationType orientation_)
OrientationType orientation (void) const
void page (const Geometry &pageSize_)
Geometry page (void) const
void quality (const size_t quality_)
size_t quality (void) const
void quantizeColors (const size_t colors_)
size_t quantizeColors (void) const
void quantizeColorSpace (const ColorspaceType colorSpace_)
ColorspaceType quantizeColorSpace (void) const
void quantizeDither (const bool ditherFlag_)
bool quantizeDither (void) const
void quantizeDitherMethod (const DitherMethod ditherMethod_)
DitherMethod quantizeDitherMethod (void) const
void quantizeTreeDepth (const size_t treeDepth_)
size_t quantizeTreeDepth (void) const
void quiet (const bool quiet_)
bool quiet (void) const
void renderingIntent (const RenderingIntent renderingIntent_)
RenderingIntent renderingIntent (void) const
void resolutionUnits (const ResolutionType resolutionUnits_)
ResolutionType resolutionUnits (void) const
size_t rows (void) const
void samplingFactor (const std::string &samplingFactor_)
std::string samplingFactor (void) const
void scene (const size_t scene_)
size_t scene (void) const
void size (const Geometry &geometry_)
Geometry size (void) const
void strokeAntiAlias (const bool flag_)
bool strokeAntiAlias (void) const
void strokeColor (const Color &strokeColor_)
Color strokeColor (void) const
void strokeDashArray (const double *strokeDashArray_)
const double * strokeDashArray (void) const
void strokeDashOffset (const double strokeDashOffset_)
double strokeDashOffset (void) const
void strokeLineCap (const LineCap lineCap_)
LineCap strokeLineCap (void) const
void strokeLineJoin (const LineJoin lineJoin_)
LineJoin strokeLineJoin (void) const
void strokeMiterLimit (const size_t miterLimit_)
size_t strokeMiterLimit (void) const
void strokePattern (const Image &strokePattern_)
Image strokePattern (void) const
void strokeWidth (const double strokeWidth_)
double strokeWidth (void) const
void subImage (const size_t subImage_)
size_t subImage (void) const
void subRange (const size_t subRange_)
size_t subRange (void) const
void textAntiAlias (const bool flag_)
bool textAntiAlias (void) const
void textDirection (DirectionType direction_)
DirectionType textDirection () const
void textEncoding (const std::string &encoding_)
std::string textEncoding (void) const
void textGravity (GravityType gravity_)
GravityType textGravity () const
void textInterlineSpacing (double spacing_)
double textInterlineSpacing (void) const
void textInterwordSpacing (double spacing_)
double textInterwordSpacing (void) const
void textKerning (double kerning_)
double textKerning (void) const
void textUnderColor (const Color &underColor_)
Color textUnderColor (void) const
size_t totalColors (void) const
void transformRotation (const double angle_)
void transformSkewX (const double skewx_)
void transformSkewY (const double skewy_)
void type (const ImageType type_)
ImageType type (void) const
void verbose (const bool verboseFlag_)
bool verbose (void) const
void virtualPixelMethod (const VirtualPixelMethod virtualPixelMethod_)
VirtualPixelMethod virtualPixelMethod (void) const
void x11Display (const std::string &display_)
std::string x11Display (void) const
double xResolution (void) const
double yResolution (void) const
void adaptiveBlur (const double radius_=0.0, const double sigma_=1.0)
void adaptiveResize (const Geometry &geometry_)
void adaptiveSharpen (const double radius_=0.0, const double sigma_=1.0)
void adaptiveSharpenChannel (const ChannelType channel_, const double radius_=0.0, const double sigma_=1.0)
void adaptiveThreshold (const size_t width_, const size_t height_, const double bias_=0.0)
void addNoise (const NoiseType noiseType_, const double attenuate_=1.0)
void addNoiseChannel (const ChannelType channel_, const NoiseType noiseType_, const double attenuate_=1.0)
void affineTransform (const DrawableAffine &affine)
void alpha (const unsigned int alpha_)
void alphaChannel (AlphaChannelOption alphaOption_)
void annotate (const std::string &text_, const Geometry &location_)
void annotate (const std::string &text_, const Geometry &boundingArea_, const GravityType gravity_)
void annotate (const std::string &text_, const Geometry &boundingArea_, const GravityType gravity_, const double degrees_)
void annotate (const std::string &text_, const GravityType gravity_)
void artifact (const std::string &name_, const std::string &value_)
std::string artifact (const std::string &name_) const
void attribute (const std::string name_, const char *value_)
void attribute (const std::string name_, const std::string value_)
std::string attribute (const std::string name_) const
void autoGamma (void)
void autoGammaChannel (const ChannelType channel_)
void autoLevel (void)
void autoLevelChannel (const ChannelType channel_)
void autoOrient (void)
void autoThreshold (const AutoThresholdMethod method_)
void blackThreshold (const std::string &threshold_)
void blackThresholdChannel (const ChannelType channel_, const std::string &threshold_)
void blueShift (const double factor_=1.5)
void blur (const double radius_=0.0, const double sigma_=1.0)
void blurChannel (const ChannelType channel_, const double radius_=0.0, const double sigma_=1.0)
void border (const Geometry &geometry_=borderGeometryDefault)
void brightnessContrast (const double brightness_=0.0, const double contrast_=0.0)
void brightnessContrastChannel (const ChannelType channel_, const double brightness_=0.0, const double contrast_=0.0)
void cannyEdge (const double radius_=0.0, const double sigma_=1.0, const double lowerPercent_=0.1, const double upperPercent_=0.3)
void cdl (const std::string &cdl_)
void channel (const ChannelType channel_)
void charcoal (const double radius_=0.0, const double sigma_=1.0)
void charcoalChannel (const ChannelType channel_, const double radius_=0.0, const double sigma_=1.0)
void chop (const Geometry &geometry_)
void chromaBluePrimary (const double x_, const double y_, const double z_)
void chromaBluePrimary (double *x_, double *y_, double *z_) const
void chromaGreenPrimary (const double x_, const double y_, const double z_)
void chromaGreenPrimary (double *x_, double *y_, double *z_) const
void chromaRedPrimary (const double x_, const double y_, const double z_)
void chromaRedPrimary (double *x_, double *y_, double *z_) const
void chromaWhitePoint (const double x_, const double y_, const double z_)
void chromaWhitePoint (double *x_, double *y_, double *z_) const
void clamp (void)
void clampChannel (const ChannelType channel_)
void clip (void)
void clipPath (const std::string pathname_, const bool inside_)
void clut (const Image &clutImage_, const PixelInterpolateMethod method)
void clutChannel (const ChannelType channel_, const Image &clutImage_, const PixelInterpolateMethod method)
void colorize (const unsigned int alpha_, const Color &penColor_)
void colorize (const unsigned int alphaRed_, const unsigned int alphaGreen_, const unsigned int alphaBlue_, const Color &penColor_)
void colorMap (const size_t index_, const Color &color_)
Color colorMap (const size_t index_) const
void colorMatrix (const size_t order_, const double *color_matrix_)
bool compare (const Image &reference_) const
double compare (const Image &reference_, const MetricType metric_)
double compareChannel (const ChannelType channel_, const Image &reference_, const MetricType metric_)
Image compare (const Image &reference_, const MetricType metric_, double *distortion)
Image compareChannel (const ChannelType channel_, const Image &reference_, const MetricType metric_, double *distortion)
void composite (const Image &compositeImage_, const Geometry &offset_, const CompositeOperator compose_=InCompositeOp)
void composite (const Image &compositeImage_, const GravityType gravity_, const CompositeOperator compose_=InCompositeOp)
void composite (const Image &compositeImage_, const ::ssize_t xOffset_, const ::ssize_t yOffset_, const CompositeOperator compose_=InCompositeOp)
void connectedComponents (const size_t connectivity_)
void contrast (const bool sharpen_)
void contrastStretch (const double blackPoint_, const double whitePoint_)
void contrastStretchChannel (const ChannelType channel_, const double blackPoint_, const double whitePoint_)
void convolve (const size_t order_, const double *kernel_)
void copyPixels (const Image &source_, const Geometry &geometry_, const Offset &offset_)
void crop (const Geometry &geometry_)
void cycleColormap (const ::ssize_t amount_)
void decipher (const std::string &passphrase_)
void defineSet (const std::string &magick_, const std::string &key_, bool flag_)
bool defineSet (const std::string &magick_, const std::string &key_) const
void defineValue (const std::string &magick_, const std::string &key_, const std::string &value_)
std::string defineValue (const std::string &magick_, const std::string &key_) const
void deskew (const double threshold_)
void despeckle (void)
void display (void)
void distort (const DistortMethod method_, const size_t numberArguments_, const double *arguments_, const bool bestfit_=false)
void draw (const Drawable &drawable_)
void draw (const std::vector< Magick::Drawable > &drawable_)
void edge (const double radius_=0.0)
void emboss (const double radius_=0.0, const double sigma_=1.0)
void encipher (const std::string &passphrase_)
void enhance (void)
void equalize (void)
void erase (void)
void evaluate (const ChannelType channel_, const MagickEvaluateOperator operator_,double rvalue_)
void evaluate (const ChannelType channel_, const MagickFunction function_, const size_t number_parameters_, const double *parameters_)
void evaluate (const ChannelType channel_, const ::ssize_t x_, const ::ssize_t y_, const size_t columns_, const size_t rows_, const MagickEvaluateOperator operator_,const double rvalue_)
void extent (const Geometry &geometry_)
void extent (const Geometry &geometry_, const Color &backgroundColor)
void extent (const Geometry &geometry_, const Color &backgroundColor, const GravityType gravity_)
void extent (const Geometry &geometry_, const GravityType gravity_)
void flip (void)
void floodFillAlpha (const ::ssize_t x_, const ::ssize_t y_, const unsigned int alpha_, const bool invert_=false)
void floodFillAlpha (const ssize_t x_, const ssize_t y_, const unsigned int alpha_, const Color &target_, const bool invert_=false)
void floodFillColor (const Geometry &point_, const Color &fillColor_, const bool invert_=false)
void floodFillColor (const ::ssize_t x_, const ::ssize_t y_, const Color &fillColor_, const bool invert_=false)
void floodFillColor (const Geometry &point_, const Color &fillColor_, const Color &borderColor_, const bool invert_=false)
void floodFillColor (const ::ssize_t x_, const ::ssize_t y_, const Color &fillColor_, const Color &borderColor_, const bool invert_=false)
void floodFillTexture (const Geometry &point_, const Image &texture_, const bool invert_=false)
void floodFillTexture (const ::ssize_t x_, const ::ssize_t y_, const Image &texture_, const bool invert_=false)
void floodFillTexture (const Geometry &point_, const Image &texture_, const Color &borderColor_, const bool invert_=false)
void floodFillTexture (const ::ssize_t x_, const ::ssize_t y_, const Image &texture_, const Color &borderColor_, const bool invert_=false)
void flop (void)
void fontTypeMetrics (const std::string &text_, TypeMetric *metrics)
void fontTypeMetricsMultiline (const std::string &text_, TypeMetric *metrics)
void frame (const Geometry &geometry_=frameGeometryDefault)
void frame (const size_t width_, const size_t height_, const ::ssize_t innerBevel_=6, const ::ssize_t outerBevel_=6)
void fx (const std::string expression_)
void fx (const std::string expression_, const Magick::ChannelType channel_)
void gamma (const double gamma_)
void gamma (const double gammaRed_, const double gammaGreen_, const double gammaBlue_)
void gaussianBlur (const double radius_, const double sigma_)
void gaussianBlurChannel (const ChannelType channel_, const double radius_, const double sigma_)
const Quantum * getConstPixels (const ::ssize_t x_, const ::ssize_t y_, const size_t columns_, const size_t rows_) const
const void * getConstMetacontent (void) const
void * getMetacontent (void)
Quantum * getPixels (const ::ssize_t x_, const ::ssize_t y_, const size_t columns_, const size_t rows_)
void grayscale (const PixelIntensityMethod method_)
void haldClut (const Image &clutImage_)
void houghLine (const size_t width_, const size_t height_, const size_t threshold_=40)
ImageType identifyType (void) const
void implode (const double factor_)
void inverseFourierTransform (const Image &phase_)
void inverseFourierTransform (const Image &phase_, const bool magnitude_)
void kuwahara (const double radius_=0.0, const double sigma_=1.0)
void kuwaharaChannel (const ChannelType channel_, const double radius_=0.0, const double sigma_=1.0)
void level (const double blackPoint_, const double whitePoint_, const double gamma_=1.0)
void levelChannel (const ChannelType channel_, const double blackPoint_, const double whitePoint_, const double gamma_=1.0)
void levelColors (const Color &blackColor_, const Color &whiteColor_, const bool invert_=true)
void levelColorsChannel (const ChannelType channel_, const Color &blackColor_, const Color &whiteColor_, const bool invert_=true)
void levelize (const double blackPoint_, const double whitePoint_, const double gamma_=1.0)
void levelizeChannel (const ChannelType channel_, const double blackPoint_, const double whitePoint_, const double gamma_=1.0)
void linearStretch (const double blackPoint_, const double whitePoint_)
void liquidRescale (const Geometry &geometry_)
void localContrast (const double radius_, const double strength_)
void localContrastChannel (const ChannelType channel_, const double radius_, const double strength_)
void magnify (void)
void map (const Image &mapImage_, const bool dither_=false)
void map (const Image &mapImage_, const DitherMethod ditherMethod_)
void meanShift (const size_t width_, const size_t height_, const double color_distance_)
void medianFilter (const double radius_=0.0)
void minify (void)
void modulate (const double brightness_, const double saturation_, const double hue_)
ImageMoments moments (void) const
void morphology (const MorphologyMethod method_, const std::string kernel_, const ssize_t iterations_=1)
void morphology (const MorphologyMethod method_, const KernelInfoType kernel_, const std::string arguments_, const ssize_t iterations_=1)
void morphologyChannel (const ChannelType channel_, const MorphologyMethod method_, const std::string kernel_, const ssize_t iterations_=1)
void morphologyChannel (const ChannelType channel_, const MorphologyMethod method_, const KernelInfoType kernel_, const std::string arguments_, const ssize_t iterations_=1)
void motionBlur (const double radius_, const double sigma_, const double angle_)
void negate (const bool grayscale_=false)
void negateChannel (const ChannelType channel_, const bool grayscale_=false)
void normalize (void)
void oilPaint (const double radius_=0.0, const double sigma=1.0)
void opaque (const Color &opaqueColor_, const Color &penColor_, const bool invert_=false)
void orderedDither (std::string thresholdMap_)
void orderedDitherChannel (const ChannelType channel_, std::string thresholdMap_)
void perceptible (const double epsilon_)
void perceptibleChannel (const ChannelType channel_, const double epsilon_)
Magick::ImagePerceptualHash perceptualHash () const
void ping (const std::string &imageSpec_)
void ping (const Blob &blob_)
void pixelColor (const ::ssize_t x_, const ::ssize_t y_, const Color &color_)
Color pixelColor (const ::ssize_t x_, const ::ssize_t y_) const
void polaroid (const std::string &caption_, const double angle_, const PixelInterpolateMethod method_)
void posterize (const size_t levels_, const DitherMethod method_)
void posterizeChannel (const ChannelType channel_, const size_t levels_, const DitherMethod method_)
void process (std::string name_, const ::ssize_t argc_, const char **argv_)
void profile (const std::string name_, const Blob &colorProfile_)
Blob profile (const std::string name_) const
void quantize (const bool measureError_=false)
void raise (const Geometry &geometry_=raiseGeometryDefault, const bool raisedFlag_=false)
void randomThreshold (const double low_, const double high_)
void randomThresholdChannel (const ChannelType channel_, const double low_, const double high_)
void read (const Blob &blob_)
void read (const Blob &blob_, const Geometry &size_)
void read (const Blob &blob_, const Geometry &size_, const size_t depth_)
void read (const Blob &blob_, const Geometry &size_, const size_t depth_, const std::string &magick_)
void read (const Blob &blob_, const Geometry &size_, const std::string &magick_)
void read (const Geometry &size_, const std::string &imageSpec_)
void read (const size_t width_, const size_t height_, const std::string &map_, const StorageType type_, const void *pixels_)
void read (const std::string &imageSpec_)
void readMask (const Image &mask_)
Image readMask (void) const
void readPixels (const QuantumType quantum_, const unsigned char *source_)
void reduceNoise (void)
void reduceNoise (const size_t order_)
void repage ()
void resample (const Point &density_)
void resize (const Geometry &geometry_)
void roll (const Geometry &roll_)
void roll (const ssize_t columns_, const ssize_t rows_)
void rotate (const double degrees_)
void rotationalBlur (const double angle_)
void rotationalBlurChannel (const ChannelType channel_, const double angle_)
void sample (const Geometry &geometry_)
void scale (const Geometry &geometry_)
void segment (const double clusterThreshold_=1.0, const double smoothingThreshold_=1.5)
void selectiveBlur (const double radius_, const double sigma_, const double threshold_)
void selectiveBlurChannel (const ChannelType channel_, const double radius_, const double sigma_, const double threshold_)
Image separate (const ChannelType channel_) const
void sepiaTone (const double threshold_)
bool setColorMetric (const Image &reference_)
Quantum * setPixels (const ::ssize_t x_, const ::ssize_t y_, const size_t columns_, const size_t rows_)
void shade (const double azimuth_=30, const double elevation_=30, const bool colorShading_=false)
void shadow (const double percentAlpha_=80.0, const double sigma_=0.5, const ssize_t x_=5, const ssize_t y_=5)
void sharpen (const double radius_=0.0, const double sigma_=1.0)
void sharpenChannel (const ChannelType channel_, const double radius_=0.0, const double sigma_=1.0)
void shave (const Geometry &geometry_)
void shear (const double xShearAngle_, const double yShearAngle_)
void sigmoidalContrast (const bool sharpen_, const double contrast, const double midpoint=(double) QuantumRange/2.0)
std::string signature (const bool force_=false) const
void sketch (const double radius_=0.0, const double sigma_=1.0, const double angle_=0.0)
void solarize (const double factor_=50.0)
void sparseColor (const ChannelType channel_, const SparseColorMethod method_, const size_t numberArguments_, const double *arguments_)
void splice (const Geometry &geometry_)
void splice (const Geometry &geometry_, const Color &backgroundColor_)
void splice (const Geometry &geometry_, const Color &backgroundColor_, const GravityType gravity_)
void spread (const double amount_=3.0)
Magick::ImageStatistics statistics () const
void stegano (const Image &watermark_)
void stereo (const Image &rightImage_)
void strip (void)
Image subImageSearch (const Image &reference_, const MetricType metric_, Geometry *offset_, double *similarityMetric_, const double similarityThreshold=(-1.0))
void swirl (const double degrees_)
void syncPixels (void)
void texture (const Image &texture_)
void threshold (const double threshold_)
void thumbnail (const Geometry &geometry_)
void tint (const std::string opacity_)
void transformOrigin (const double x_, const double y_)
void transformReset (void)
void transformScale (const double sx_, const double sy_)
void transparent (const Color &color_, const bool inverse_=false)
void transparentChroma (const Color &colorLow_, const Color &colorHigh_)
void transpose (void)
void transverse (void)
void trim (void)
Image uniqueColors (void) const
void unsharpmask (const double radius_, const double sigma_, const double amount_, const double threshold_)
void unsharpmaskChannel (const ChannelType channel_, const double radius_, const double sigma_, const double amount_, const double threshold_)
void vignette (const double radius_=0.0, const double sigma_=1.0, const ssize_t x_=0, const ssize_t y_=0)
void wave (const double amplitude_=25.0, const double wavelength_=150.0)
void waveletDenoise (const double threshold_, const double softness_)
void whiteThreshold (const std::string &threshold_)
void whiteThresholdChannel (const ChannelType channel_, const std::string &threshold_)
void write (Blob *blob_)
void write (Blob *blob_, const std::string &magick_)
void write (Blob *blob_, const std::string &magick_, const size_t depth_)
void 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_)
void write (const std::string &imageSpec_)
void writeMask (const Image &mask_)
Image writeMask (void) const
void writePixels (const QuantumType quantum_, unsigned char *destination_)
void zoom (const Geometry &geometry_)
 Image (MagickCore::Image *image_)
MagickCore::Image *& image (void)
const MagickCore::Image * constImage (void) const
MagickCore::ImageInfo * imageInfo (void)
const MagickCore::ImageInfo * constImageInfo (void) const
Options * options (void)
const Options * constOptions (void) const
MagickCore::QuantizeInfo * quantizeInfo (void)
const MagickCore::QuantizeInfo * constQuantizeInfo (void) const
void modifyImage (void)
MagickCore::Image * replaceImage (MagickCore::Image *replacement_)

Private Member Functions

void floodFill (const ssize_t x_, const ssize_t y_, const Magick::Image *fillPattern_, const Color &fill_, const PixelInfo *target, const bool invert_)
void mask (const Image &mask_, const PixelMask)
Image mask (const PixelMask) const
void read (MagickCore::Image *image, MagickCore::ExceptionInfo *exceptionInfo)

Private Attributes

ImageRef * _imgRef

Detailed Description

Definition at line 55 of file Image.h.

Constructor & Destructor Documentation

◆ Image() [1/12]

Magick::Image::Image ( void )

Definition at line 72 of file Image.cpp.

73 : _imgRef(new ImageRef)
74{
75}

◆ Image() [2/12]

Magick::Image::Image ( const Blob & blob_)

Definition at line 77 of file Image.cpp.

78 : _imgRef(new ImageRef)
79{
80 try
81 {
82 // Initialize, Allocate and Read images
83 quiet(true);
84 read(blob_);
85 quiet(false);
86 }
87 catch (const Error&)
88 {
89 // Release resources
90 delete _imgRef;
91 throw;
92 }
93}

◆ Image() [3/12]

Magick::Image::Image ( const Blob & blob_,
const Geometry & size_ )

Definition at line 95 of file Image.cpp.

96 : _imgRef(new ImageRef)
97{
98 try
99 {
100 // Read from Blob
101 quiet(true);
102 read(blob_, size_);
103 quiet(false);
104 }
105 catch(const Error&)
106 {
107 // Release resources
108 delete _imgRef;
109 throw;
110 }
111}

◆ Image() [4/12]

Magick::Image::Image ( const Blob & blob_,
const Geometry & size_,
const size_t depth_ )

Definition at line 113 of file Image.cpp.

115 : _imgRef(new ImageRef)
116{
117 try
118 {
119 // Read from Blob
120 quiet(true);
121 read(blob_,size_,depth_);
122 quiet(false);
123 }
124 catch(const Error&)
125 {
126 // Release resources
127 delete _imgRef;
128 throw;
129 }
130}

◆ Image() [5/12]

Magick::Image::Image ( const Blob & blob_,
const Geometry & size_,
const size_t depth_,
const std::string & magick_ )

Definition at line 132 of file Image.cpp.

134 : _imgRef(new ImageRef)
135{
136 try
137 {
138 // Read from Blob
139 quiet(true);
140 read(blob_,size_,depth_,magick_);
141 quiet(false);
142 }
143 catch(const Error&)
144 {
145 // Release resources
146 delete _imgRef;
147 throw;
148 }
149}

◆ Image() [6/12]

Magick::Image::Image ( const Blob & blob_,
const Geometry & size_,
const std::string & magick_ )

Definition at line 151 of file Image.cpp.

153 : _imgRef(new ImageRef)
154{
155 try
156 {
157 // Read from Blob
158 quiet(true);
159 read(blob_,size_,magick_);
160 quiet(false);
161 }
162 catch(const Error&)
163 {
164 // Release resources
165 delete _imgRef;
166 throw;
167 }
168}

◆ Image() [7/12]

Magick::Image::Image ( const Geometry & size_,
const Color & color_ )

Definition at line 170 of file Image.cpp.

171 : _imgRef(new ImageRef)
172{
173 // xc: prefix specifies an X11 color string
174 std::string imageSpec("xc:");
175 imageSpec+=color_;
176
177 try
178 {
179 quiet(true);
180 // Set image size
181 size(size_);
182
183 // Initialize, Allocate and Read images
184 read(imageSpec);
185 quiet(false);
186 }
187 catch(const Error&)
188 {
189 // Release resources
190 delete _imgRef;
191 throw;
192 }
193}

◆ Image() [8/12]

Magick::Image::Image ( const Image & image_)

Definition at line 195 of file Image.cpp.

196 : _imgRef(image_._imgRef)
197{
198 _imgRef->increase();
199}

◆ Image() [9/12]

Magick::Image::Image ( const Image & image_,
const Geometry & geometry_ )

Definition at line 201 of file Image.cpp.

202 : _imgRef(new ImageRef)
203{
204 const RectangleInfo
205 geometry=geometry_;
206
207 OffsetInfo
208 offset;
209
210 MagickCore::Image
211 *image;
212
213 GetPPException;
214 image=CloneImage(image_.constImage(),geometry_.width(),geometry_.height(),
215 MagickTrue,exceptionInfo);
216 replaceImage(image);
217 _imgRef->options(new Options(*image_.constOptions()));
218 offset.x=0;
219 offset.y=0;
220 (void) CopyImagePixels(image,image_.constImage(),&geometry,&offset,
221 exceptionInfo);
222 ThrowImageException;
223}

◆ Image() [10/12]

Magick::Image::Image ( const size_t width_,
const size_t height_,
const std::string & map_,
const StorageType type_,
const void * pixels_ )

Definition at line 225 of file Image.cpp.

227 : _imgRef(new ImageRef)
228{
229 try
230 {
231 quiet(true);
232 read(width_,height_,map_.c_str(),type_,pixels_);
233 quiet(false);
234 }
235 catch(const Error&)
236 {
237 // Release resources
238 delete _imgRef;
239 throw;
240 }
241}

◆ Image() [11/12]

Magick::Image::Image ( const std::string & imageSpec_)

Definition at line 243 of file Image.cpp.

244 : _imgRef(new ImageRef)
245{
246 try
247 {
248 // Initialize, Allocate and Read images
249 quiet(true);
250 read(imageSpec_);
251 quiet(false);
252 }
253 catch(const Error&)
254 {
255 // Release resources
256 delete _imgRef;
257 throw;
258 }
259}

◆ ~Image()

Magick::Image::~Image ( )
virtual

Definition at line 261 of file Image.cpp.

262{
263 try
264 {
265 if (_imgRef->decrease() == 0)
266 delete _imgRef;
267 }
268 catch(Magick::Exception&)
269 {
270 }
271
272 _imgRef=(Magick::ImageRef *) NULL;
273}

◆ Image() [12/12]

Magick::Image::Image ( MagickCore::Image * image_)

Definition at line 5016 of file Image.cpp.

5017 : _imgRef(new ImageRef(image_))
5018{
5019}

Member Function Documentation

◆ adaptiveBlur()

void Magick::Image::adaptiveBlur ( const double radius_ = 0.0,
const double sigma_ = 1.0 )

Definition at line 1717 of file Image.cpp.

1718{
1719 MagickCore::Image
1720 *newImage;
1721
1722 GetPPException;
1723 newImage=AdaptiveBlurImage(constImage(),radius_,sigma_,exceptionInfo);
1724 replaceImage(newImage);
1725 ThrowImageException;
1726}

◆ adaptiveResize()

void Magick::Image::adaptiveResize ( const Geometry & geometry_)

Definition at line 1728 of file Image.cpp.

1729{
1730 MagickCore::Image
1731 *newImage;
1732
1733 size_t
1734 height=rows(),
1735 width=columns();
1736
1737 ssize_t
1738 x=0,
1739 y=0;
1740
1741 ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
1742 &height);
1743
1744 GetPPException;
1745 newImage=AdaptiveResizeImage(constImage(),width,height,exceptionInfo);
1746 replaceImage(newImage);
1747 ThrowImageException;
1748}

◆ adaptiveSharpen()

void Magick::Image::adaptiveSharpen ( const double radius_ = 0.0,
const double sigma_ = 1.0 )

Definition at line 1750 of file Image.cpp.

1751{
1752 MagickCore::Image
1753 *newImage;
1754
1755 GetPPException;
1756 newImage=AdaptiveSharpenImage(constImage(),radius_,sigma_,exceptionInfo);
1757 replaceImage(newImage);
1758 ThrowImageException;
1759}

◆ adaptiveSharpenChannel()

void Magick::Image::adaptiveSharpenChannel ( const ChannelType channel_,
const double radius_ = 0.0,
const double sigma_ = 1.0 )

Definition at line 1761 of file Image.cpp.

1763{
1764 MagickCore::Image
1765 *newImage;
1766
1767 GetPPException;
1768 GetAndSetPPChannelMask(channel_);
1769 newImage=AdaptiveSharpenImage(constImage(),radius_,sigma_,exceptionInfo);
1770 RestorePPChannelMask;
1771 replaceImage(newImage);
1772 ThrowImageException;
1773}

◆ adaptiveThreshold()

void Magick::Image::adaptiveThreshold ( const size_t width_,
const size_t height_,
const double bias_ = 0.0 )

Definition at line 1775 of file Image.cpp.

1777{
1778
1779 MagickCore::Image
1780 *newImage;
1781
1782 GetPPException;
1783 newImage=AdaptiveThresholdImage(constImage(),width_,height_,bias_,
1784 exceptionInfo);
1785 replaceImage(newImage);
1786 ThrowImageException;
1787}

◆ addNoise()

void Magick::Image::addNoise ( const NoiseType noiseType_,
const double attenuate_ = 1.0 )

Definition at line 1789 of file Image.cpp.

1790{
1791 MagickCore::Image
1792 *newImage;
1793
1794 GetPPException;
1795 newImage=AddNoiseImage(constImage(),noiseType_,attenuate_,exceptionInfo);
1796 replaceImage(newImage);
1797 ThrowImageException;
1798}

◆ addNoiseChannel()

void Magick::Image::addNoiseChannel ( const ChannelType channel_,
const NoiseType noiseType_,
const double attenuate_ = 1.0 )

Definition at line 1800 of file Image.cpp.

1802{
1803 MagickCore::Image
1804 *newImage;
1805
1806 GetPPException;
1807 GetAndSetPPChannelMask(channel_);
1808 newImage=AddNoiseImage(constImage(),noiseType_,attenuate_,exceptionInfo);
1809 RestorePPChannelMask;
1810 replaceImage(newImage);
1811 ThrowImageException;
1812}

◆ adjoin() [1/2]

void Magick::Image::adjoin ( const bool flag_)

Definition at line 289 of file Image.cpp.

290{
291 modifyImage();
292 options()->adjoin(flag_);
293}

◆ adjoin() [2/2]

bool Magick::Image::adjoin ( void ) const

Definition at line 295 of file Image.cpp.

296{
297 return(constOptions()->adjoin());
298}

◆ affineTransform()

void Magick::Image::affineTransform ( const DrawableAffine & affine)

Definition at line 1814 of file Image.cpp.

1815{
1816 AffineMatrix
1817 _affine;
1818
1819 MagickCore::Image
1820 *newImage;
1821
1822 _affine.sx=affine_.sx();
1823 _affine.sy=affine_.sy();
1824 _affine.rx=affine_.rx();
1825 _affine.ry=affine_.ry();
1826 _affine.tx=affine_.tx();
1827 _affine.ty=affine_.ty();
1828
1829 GetPPException;
1830 newImage=AffineTransformImage(constImage(),&_affine,exceptionInfo);
1831 replaceImage(newImage);
1832 ThrowImageException;
1833}

◆ alpha() [1/3]

void Magick::Image::alpha ( const bool alphaFlag_)

Definition at line 300 of file Image.cpp.

301{
302 modifyImage();
303
304 // If matte channel is requested, but image doesn't already have a
305 // matte channel, then create an opaque matte channel. Likewise, if
306 // the image already has a matte channel but a matte channel is not
307 // desired, then set the matte channel to opaque.
308 GetPPException;
309 if (bool(alphaFlag_) != bool(constImage()->alpha_trait))
310 SetImageAlpha(image(),OpaqueAlpha,exceptionInfo);
311 ThrowImageException;
312
313 image()->alpha_trait=alphaFlag_ ? BlendPixelTrait : UndefinedPixelTrait;
314}

◆ alpha() [2/3]

void Magick::Image::alpha ( const unsigned int alpha_)

Definition at line 1835 of file Image.cpp.

1836{
1837 modifyImage();
1838 GetPPException;
1839 SetImageAlpha(image(),(Quantum) alpha_,exceptionInfo);
1840 ThrowImageException;
1841}

◆ alpha() [3/3]

bool Magick::Image::alpha ( void ) const

Definition at line 316 of file Image.cpp.

317{
318 if (constImage()->alpha_trait == BlendPixelTrait)
319 return(true);
320 else
321 return(false);
322}

◆ alphaChannel()

void Magick::Image::alphaChannel ( AlphaChannelOption alphaOption_)

Definition at line 1843 of file Image.cpp.

1844{
1845 modifyImage();
1846 GetPPException;
1847 SetImageAlphaChannel(image(),alphaOption_,exceptionInfo);
1848 ThrowImageException;
1849}

◆ animationDelay() [1/2]

void Magick::Image::animationDelay ( const size_t delay_)

Definition at line 347 of file Image.cpp.

348{
349 modifyImage();
350 image()->delay=delay_;
351}

◆ animationDelay() [2/2]

size_t Magick::Image::animationDelay ( void ) const

Definition at line 353 of file Image.cpp.

354{
355 return(constImage()->delay);
356}

◆ animationIterations() [1/2]

void Magick::Image::animationIterations ( const size_t iterations_)

Definition at line 358 of file Image.cpp.

359{
360 modifyImage();
361 image()->iterations=iterations_;
362}

◆ animationIterations() [2/2]

size_t Magick::Image::animationIterations ( void ) const

Definition at line 364 of file Image.cpp.

365{
366 return(constImage()->iterations);
367}

◆ annotate() [1/4]

void Magick::Image::annotate ( const std::string & text_,
const Geometry & boundingArea_,
const GravityType gravity_ )

Definition at line 1857 of file Image.cpp.

1859{
1860 annotate(text_,boundingArea_,gravity_,0.0);
1861}

◆ annotate() [2/4]

void Magick::Image::annotate ( const std::string & text_,
const Geometry & boundingArea_,
const GravityType gravity_,
const double degrees_ )

Definition at line 1863 of file Image.cpp.

1866{
1867 AffineMatrix
1868 oaffine;
1869
1870 char
1871 boundingArea[MagickPathExtent];
1872
1873 DrawInfo
1874 *drawInfo;
1875
1876 modifyImage();
1877
1878 drawInfo=options()->drawInfo();
1879 drawInfo->text=DestroyString(drawInfo->text);
1880 drawInfo->text=const_cast<char *>(text_.c_str());
1881 drawInfo->geometry=DestroyString(drawInfo->geometry);
1882
1883 if (boundingArea_.isValid())
1884 {
1885 if (boundingArea_.width() == 0 || boundingArea_.height() == 0)
1886 {
1887 FormatLocaleString(boundingArea,MagickPathExtent,"%+.20g%+.20g",
1888 (double) boundingArea_.xOff(),(double) boundingArea_.yOff());
1889 }
1890 else
1891 {
1892 (void) CopyMagickString(boundingArea,
1893 std::string(boundingArea_).c_str(), MagickPathExtent);
1894 }
1895 drawInfo->geometry=boundingArea;
1896 }
1897
1898 drawInfo->gravity=gravity_;
1899
1900 oaffine=drawInfo->affine;
1901 if (degrees_ != 0.0)
1902 {
1903 AffineMatrix
1904 affine,
1905 current;
1906
1907 affine.sx=1.0;
1908 affine.rx=0.0;
1909 affine.ry=0.0;
1910 affine.sy=1.0;
1911 affine.tx=0.0;
1912 affine.ty=0.0;
1913
1914 current=drawInfo->affine;
1915 affine.sx=cos(DegreesToRadians(fmod(degrees_,360.0)));
1916 affine.rx=sin(DegreesToRadians(fmod(degrees_,360.0)));
1917 affine.ry=(-sin(DegreesToRadians(fmod(degrees_,360.0))));
1918 affine.sy=cos(DegreesToRadians(fmod(degrees_,360.0)));
1919
1920 drawInfo->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
1921 drawInfo->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
1922 drawInfo->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
1923 drawInfo->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
1924 drawInfo->affine.tx=current.sx*affine.tx+current.ry*affine.ty
1925 +current.tx;
1926 }
1927
1928 GetPPException;
1929 AnnotateImage(image(),drawInfo,exceptionInfo);
1930
1931 // Restore original values
1932 drawInfo->affine=oaffine;
1933 drawInfo->text=(char *) NULL;
1934 drawInfo->geometry=(char *) NULL;
1935
1936 ThrowImageException;
1937}

◆ annotate() [3/4]

void Magick::Image::annotate ( const std::string & text_,
const Geometry & location_ )

Definition at line 1851 of file Image.cpp.

1853{
1854 annotate(text_,location_,NorthWestGravity,0.0);
1855}

◆ annotate() [4/4]

void Magick::Image::annotate ( const std::string & text_,
const GravityType gravity_ )

Definition at line 1939 of file Image.cpp.

1941{
1942 DrawInfo
1943 *drawInfo;
1944
1945 modifyImage();
1946
1947 drawInfo=options()->drawInfo();
1948 drawInfo->text=DestroyString(drawInfo->text);
1949 drawInfo->text=const_cast<char *>(text_.c_str());
1950 drawInfo->gravity=gravity_;
1951
1952 GetPPException;
1953 AnnotateImage(image(),drawInfo,exceptionInfo);
1954
1955 drawInfo->gravity=NorthWestGravity;
1956 drawInfo->text=(char *) NULL;
1957
1958 ThrowImageException;
1959}

◆ artifact() [1/2]

std::string Magick::Image::artifact ( const std::string & name_) const

Definition at line 1967 of file Image.cpp.

1968{
1969 const char
1970 *value;
1971
1972 value=GetImageArtifact(constImage(),name_.c_str());
1973 if (value)
1974 return(std::string(value));
1975 return(std::string());
1976}

◆ artifact() [2/2]

void Magick::Image::artifact ( const std::string & name_,
const std::string & value_ )

Definition at line 1961 of file Image.cpp.

1962{
1963 modifyImage();
1964 (void) SetImageArtifact(image(),name_.c_str(),value_.c_str());
1965}

◆ attribute() [1/3]

std::string Magick::Image::attribute ( const std::string name_) const

Definition at line 1994 of file Image.cpp.

1995{
1996 const char
1997 *value;
1998
1999 GetPPException;
2000 value=GetImageProperty(constImage(),name_.c_str(),exceptionInfo);
2001 ThrowImageException;
2002
2003 if (value)
2004 return(std::string(value));
2005
2006 return(std::string()); // Intentionally no exception
2007}

◆ attribute() [2/3]

void Magick::Image::attribute ( const std::string name_,
const char * value_ )

Definition at line 1978 of file Image.cpp.

1979{
1980 modifyImage();
1981 GetPPException;
1982 SetImageProperty(image(),name_.c_str(),value_,exceptionInfo);
1983 ThrowImageException;
1984}

◆ attribute() [3/3]

void Magick::Image::attribute ( const std::string name_,
const std::string value_ )

Definition at line 1986 of file Image.cpp.

1987{
1988 modifyImage();
1989 GetPPException;
1990 SetImageProperty(image(),name_.c_str(),value_.c_str(),exceptionInfo);
1991 ThrowImageException;
1992}

◆ autoGamma()

void Magick::Image::autoGamma ( void )

Definition at line 2009 of file Image.cpp.

2010{
2011 modifyImage();
2012 GetPPException;
2013 (void) SyncImageSettings(imageInfo(),image(),exceptionInfo);
2014 (void) AutoGammaImage(image(),exceptionInfo);
2015 ThrowImageException;
2016}

◆ autoGammaChannel()

void Magick::Image::autoGammaChannel ( const ChannelType channel_)

Definition at line 2018 of file Image.cpp.

2019{
2020 modifyImage();
2021 GetPPException;
2022 GetAndSetPPChannelMask(channel_);
2023 (void) SyncImageSettings(imageInfo(),image(),exceptionInfo);
2024 (void) AutoGammaImage(image(),exceptionInfo);
2025 RestorePPChannelMask;
2026 ThrowImageException;
2027}

◆ autoLevel()

void Magick::Image::autoLevel ( void )

Definition at line 2029 of file Image.cpp.

2030{
2031 modifyImage();
2032 GetPPException;
2033 (void) AutoLevelImage(image(),exceptionInfo);
2034 ThrowImageException;
2035}

◆ autoLevelChannel()

void Magick::Image::autoLevelChannel ( const ChannelType channel_)

Definition at line 2037 of file Image.cpp.

2038{
2039 modifyImage();
2040 GetPPException;
2041 GetAndSetPPChannelMask(channel_);
2042 (void) AutoLevelImage(image(),exceptionInfo);
2043 RestorePPChannelMask;
2044 ThrowImageException;
2045}

◆ autoOrient()

void Magick::Image::autoOrient ( void )

Definition at line 2047 of file Image.cpp.

2048{
2049 MagickCore::Image
2050 *newImage;
2051
2052 if (image()->orientation == UndefinedOrientation ||
2053 image()->orientation == TopLeftOrientation)
2054 return;
2055
2056 GetPPException;
2057 newImage=AutoOrientImage(constImage(),image()->orientation,exceptionInfo);
2058 replaceImage(newImage);
2059 ThrowImageException;
2060}

◆ autoThreshold()

void Magick::Image::autoThreshold ( const AutoThresholdMethod method_)

Definition at line 2062 of file Image.cpp.

2063{
2064 modifyImage();
2065 GetPPException;
2066 AutoThresholdImage(image(),method_, exceptionInfo);
2067 ThrowImageException;
2068}

◆ backgroundColor() [1/2]

void Magick::Image::backgroundColor ( const Color & color_)

Definition at line 369 of file Image.cpp.

370{
371 modifyImage();
372
373 if (backgroundColor_.isValid())
374 image()->background_color=backgroundColor_;
375 else
376 image()->background_color=Color();
377
378 options()->backgroundColor(backgroundColor_);
379}

◆ backgroundColor() [2/2]

Magick::Color Magick::Image::backgroundColor ( void ) const

Definition at line 381 of file Image.cpp.

382{
383 return(constOptions()->backgroundColor());
384}

◆ backgroundTexture() [1/2]

void Magick::Image::backgroundTexture ( const std::string & backgroundTexture_)

Definition at line 386 of file Image.cpp.

387{
388 modifyImage();
389 options()->backgroundTexture(backgroundTexture_);
390}

◆ backgroundTexture() [2/2]

std::string Magick::Image::backgroundTexture ( void ) const

Definition at line 392 of file Image.cpp.

393{
394 return(constOptions()->backgroundTexture());
395}

◆ baseColumns()

size_t Magick::Image::baseColumns ( void ) const

Definition at line 397 of file Image.cpp.

398{
399 return(constImage()->magick_columns);
400}

◆ baseFilename()

std::string Magick::Image::baseFilename ( void ) const

Definition at line 402 of file Image.cpp.

403{
404 return(std::string(constImage()->magick_filename));
405}

◆ baseRows()

size_t Magick::Image::baseRows ( void ) const

Definition at line 407 of file Image.cpp.

408{
409 return(constImage()->magick_rows);
410}

◆ blackPointCompensation() [1/2]

void Magick::Image::blackPointCompensation ( const bool flag_)

Definition at line 412 of file Image.cpp.

413{
414 image()->black_point_compensation=(MagickBooleanType) flag_;
415}

◆ blackPointCompensation() [2/2]

bool Magick::Image::blackPointCompensation ( void ) const

Definition at line 417 of file Image.cpp.

418{
419 return(static_cast<bool>(constImage()->black_point_compensation));
420}

◆ blackThreshold()

void Magick::Image::blackThreshold ( const std::string & threshold_)

Definition at line 2070 of file Image.cpp.

2071{
2072 modifyImage();
2073 GetPPException;
2074 BlackThresholdImage(image(),threshold_.c_str(),exceptionInfo);
2075 ThrowImageException;
2076}

◆ blackThresholdChannel()

void Magick::Image::blackThresholdChannel ( const ChannelType channel_,
const std::string & threshold_ )

Definition at line 2078 of file Image.cpp.

2080{
2081 modifyImage();
2082 GetPPException;
2083 GetAndSetPPChannelMask(channel_);
2084 BlackThresholdImage(image(),threshold_.c_str(),exceptionInfo);
2085 RestorePPChannelMask;
2086 ThrowImageException;
2087}

◆ blueShift()

void Magick::Image::blueShift ( const double factor_ = 1.5)

Definition at line 2089 of file Image.cpp.

2090{
2091 MagickCore::Image
2092 *newImage;
2093
2094 GetPPException;
2095 newImage=BlueShiftImage(constImage(),factor_,exceptionInfo);
2096 replaceImage(newImage);
2097 ThrowImageException;
2098}

◆ blur()

void Magick::Image::blur ( const double radius_ = 0.0,
const double sigma_ = 1.0 )

Definition at line 2100 of file Image.cpp.

2101{
2102 MagickCore::Image
2103 *newImage;
2104
2105 GetPPException;
2106 newImage=BlurImage(constImage(),radius_,sigma_,exceptionInfo);
2107 replaceImage(newImage);
2108 ThrowImageException;
2109}

◆ blurChannel()

void Magick::Image::blurChannel ( const ChannelType channel_,
const double radius_ = 0.0,
const double sigma_ = 1.0 )

Definition at line 2111 of file Image.cpp.

2113{
2114 MagickCore::Image
2115 *newImage;
2116
2117 GetPPException;
2118 GetAndSetPPChannelMask(channel_);
2119 newImage=BlurImage(constImage(),radius_,sigma_,exceptionInfo);
2120 RestorePPChannelMask;
2121 replaceImage(newImage);
2122 ThrowImageException;
2123}

◆ border()

void Magick::Image::border ( const Geometry & geometry_ = borderGeometryDefault)

Definition at line 2125 of file Image.cpp.

2126{
2127 MagickCore::Image
2128 *newImage;
2129
2130 RectangleInfo
2131 borderInfo=geometry_;
2132
2133 GetPPException;
2134 newImage=BorderImage(constImage(),&borderInfo,image()->compose,
2135 exceptionInfo);
2136 replaceImage(newImage);
2137 ThrowImageException;
2138}

◆ borderColor() [1/2]

void Magick::Image::borderColor ( const Color & color_)

Definition at line 422 of file Image.cpp.

423{
424 modifyImage();
425
426 if (borderColor_.isValid())
427 image()->border_color=borderColor_;
428 else
429 image()->border_color=Color();
430
431 options()->borderColor(borderColor_);
432}

◆ borderColor() [2/2]

Magick::Color Magick::Image::borderColor ( void ) const

Definition at line 434 of file Image.cpp.

435{
436 return(constOptions()->borderColor());
437}

◆ boundingBox()

Magick::Geometry Magick::Image::boundingBox ( void ) const

Definition at line 439 of file Image.cpp.

440{
441 RectangleInfo
442 bbox;
443
444 GetPPException;
445 bbox=GetImageBoundingBox(constImage(),exceptionInfo);
446 ThrowImageException;
447 return(Geometry(bbox));
448}

◆ boxColor() [1/2]

void Magick::Image::boxColor ( const Color & boxColor_)

Definition at line 450 of file Image.cpp.

451{
452 modifyImage();
453 options()->boxColor(boxColor_);
454}

◆ boxColor() [2/2]

Magick::Color Magick::Image::boxColor ( void ) const

Definition at line 456 of file Image.cpp.

457{
458 return(constOptions()->boxColor());
459}

◆ brightnessContrast()

void Magick::Image::brightnessContrast ( const double brightness_ = 0.0,
const double contrast_ = 0.0 )

Definition at line 2140 of file Image.cpp.

2142{
2143 modifyImage();
2144 GetPPException;
2145 BrightnessContrastImage(image(),brightness_,contrast_,exceptionInfo);
2146 ThrowImageException;
2147}

◆ brightnessContrastChannel()

void Magick::Image::brightnessContrastChannel ( const ChannelType channel_,
const double brightness_ = 0.0,
const double contrast_ = 0.0 )

Definition at line 2149 of file Image.cpp.

2151{
2152 modifyImage();
2153 GetPPException;
2154 GetAndSetPPChannelMask(channel_);
2155 BrightnessContrastImage(image(),brightness_,contrast_,exceptionInfo);
2156 RestorePPChannelMask;
2157 ThrowImageException;
2158}

◆ cannyEdge()

void Magick::Image::cannyEdge ( const double radius_ = 0.0,
const double sigma_ = 1.0,
const double lowerPercent_ = 0.1,
const double upperPercent_ = 0.3 )

Definition at line 2160 of file Image.cpp.

2162{
2163 MagickCore::Image
2164 *newImage;
2165
2166 modifyImage();
2167 GetPPException;
2168 newImage=CannyEdgeImage(constImage(),radius_,sigma_,lowerPercent_,
2169 upperPercent_,exceptionInfo);
2170 replaceImage(newImage);
2171 ThrowImageException;
2172}

◆ cdl()

void Magick::Image::cdl ( const std::string & cdl_)

Definition at line 2174 of file Image.cpp.

2175{
2176 modifyImage();
2177 GetPPException;
2178 (void) ColorDecisionListImage(image(),cdl_.c_str(),exceptionInfo);
2179 ThrowImageException;
2180}

◆ channel()

void Magick::Image::channel ( const ChannelType channel_)

Definition at line 2182 of file Image.cpp.

2183{
2184 MagickCore::Image
2185 *newImage;
2186
2187 GetPPException;
2188 newImage=SeparateImage(constImage(),channel_,exceptionInfo);
2189 replaceImage(newImage);
2190 ThrowImageException;
2191}

◆ channelDepth() [1/2]

size_t Magick::Image::channelDepth ( const ChannelType channel_)

Definition at line 472 of file Image.cpp.

473{
474 size_t
475 channel_depth;
476
477 GetPPException;
478 GetAndSetPPChannelMask(channel_);
479 channel_depth=GetImageDepth(constImage(),exceptionInfo);
480 RestorePPChannelMask;
481 ThrowImageException;
482 return(channel_depth);
483}

◆ channelDepth() [2/2]

void Magick::Image::channelDepth ( const ChannelType channel_,
const size_t depth_ )

Definition at line 461 of file Image.cpp.

463{
464 modifyImage();
465 GetPPException;
466 GetAndSetPPChannelMask(channel_);
467 SetImageDepth(image(),depth_,exceptionInfo);
468 RestorePPChannelMask;
469 ThrowImageException;
470}

◆ channels()

size_t Magick::Image::channels ( ) const

Definition at line 485 of file Image.cpp.

486{
487 return(constImage()->number_channels);
488}

◆ charcoal()

void Magick::Image::charcoal ( const double radius_ = 0.0,
const double sigma_ = 1.0 )

Definition at line 2193 of file Image.cpp.

2194{
2195 MagickCore::Image
2196 *newImage;
2197
2198 GetPPException;
2199 newImage=CharcoalImage(image(),radius_,sigma_,exceptionInfo);
2200 replaceImage(newImage);
2201 ThrowImageException;
2202}

◆ charcoalChannel()

void Magick::Image::charcoalChannel ( const ChannelType channel_,
const double radius_ = 0.0,
const double sigma_ = 1.0 )

Definition at line 2204 of file Image.cpp.

2206{
2207 MagickCore::Image
2208 *newImage;
2209
2210 GetPPException;
2211 GetAndSetPPChannelMask(channel_);
2212 newImage=CharcoalImage(image(),radius_,sigma_,exceptionInfo);
2213 RestorePPChannelMask;
2214 replaceImage(newImage);
2215 ThrowImageException;
2216}

◆ chop()

void Magick::Image::chop ( const Geometry & geometry_)

Definition at line 2218 of file Image.cpp.

2219{
2220 MagickCore::Image
2221 *newImage;
2222
2223 RectangleInfo
2224 chopInfo=geometry_;
2225
2226 GetPPException;
2227 newImage=ChopImage(image(),&chopInfo,exceptionInfo);
2228 replaceImage(newImage);
2229 ThrowImageException;
2230}

◆ chromaBluePrimary() [1/2]

void Magick::Image::chromaBluePrimary ( const double x_,
const double y_,
const double z_ )

Definition at line 2232 of file Image.cpp.

2234{
2235 modifyImage();
2236 image()->chromaticity.blue_primary.x=x_;
2237 image()->chromaticity.blue_primary.y=y_;
2238 image()->chromaticity.blue_primary.z=z_;
2239}

◆ chromaBluePrimary() [2/2]

void Magick::Image::chromaBluePrimary ( double * x_,
double * y_,
double * z_ ) const

Definition at line 2241 of file Image.cpp.

2242{
2243 *x_=constImage()->chromaticity.blue_primary.x;
2244 *y_=constImage()->chromaticity.blue_primary.y;
2245 *z_=constImage()->chromaticity.blue_primary.z;
2246}

◆ chromaGreenPrimary() [1/2]

void Magick::Image::chromaGreenPrimary ( const double x_,
const double y_,
const double z_ )

Definition at line 2248 of file Image.cpp.

2250{
2251 modifyImage();
2252 image()->chromaticity.green_primary.x=x_;
2253 image()->chromaticity.green_primary.y=y_;
2254 image()->chromaticity.green_primary.z=z_;
2255}

◆ chromaGreenPrimary() [2/2]

void Magick::Image::chromaGreenPrimary ( double * x_,
double * y_,
double * z_ ) const

Definition at line 2257 of file Image.cpp.

2258{
2259 *x_=constImage()->chromaticity.green_primary.x;
2260 *y_=constImage()->chromaticity.green_primary.y;
2261 *z_=constImage()->chromaticity.green_primary.z;
2262}

◆ chromaRedPrimary() [1/2]

void Magick::Image::chromaRedPrimary ( const double x_,
const double y_,
const double z_ )

Definition at line 2264 of file Image.cpp.

2266{
2267 modifyImage();
2268 image()->chromaticity.red_primary.x=x_;
2269 image()->chromaticity.red_primary.y=y_;
2270 image()->chromaticity.red_primary.z=z_;
2271}

◆ chromaRedPrimary() [2/2]

void Magick::Image::chromaRedPrimary ( double * x_,
double * y_,
double * z_ ) const

Definition at line 2273 of file Image.cpp.

2274{
2275 *x_=constImage()->chromaticity.red_primary.x;
2276 *y_=constImage()->chromaticity.red_primary.y;
2277 *z_=constImage()->chromaticity.red_primary.z;
2278}

◆ chromaWhitePoint() [1/2]

void Magick::Image::chromaWhitePoint ( const double x_,
const double y_,
const double z_ )

Definition at line 2280 of file Image.cpp.

2282{
2283 modifyImage();
2284 image()->chromaticity.white_point.x=x_;
2285 image()->chromaticity.white_point.y=y_;
2286 image()->chromaticity.white_point.z=z_;
2287}

◆ chromaWhitePoint() [2/2]

void Magick::Image::chromaWhitePoint ( double * x_,
double * y_,
double * z_ ) const

Definition at line 2289 of file Image.cpp.

2290{
2291 *x_=constImage()->chromaticity.white_point.x;
2292 *y_=constImage()->chromaticity.white_point.y;
2293 *z_=constImage()->chromaticity.white_point.z;
2294}

◆ clamp()

void Magick::Image::clamp ( void )

Definition at line 2296 of file Image.cpp.

2297{
2298 modifyImage();
2299 GetPPException;
2300 ClampImage(image(),exceptionInfo);
2301 ThrowImageException;
2302}

◆ clampChannel()

void Magick::Image::clampChannel ( const ChannelType channel_)

Definition at line 2304 of file Image.cpp.

2305{
2306 modifyImage();
2307 GetPPException;
2308 GetAndSetPPChannelMask(channel_);
2309 ClampImage(image(),exceptionInfo);
2310 RestorePPChannelMask;
2311 ThrowImageException;
2312}

◆ classType() [1/2]

void Magick::Image::classType ( const ClassType class_)

Definition at line 490 of file Image.cpp.

491{
492 if (classType() == PseudoClass && class_ == DirectClass)
493 {
494 // Use SyncImage to synchronize the DirectClass pixels with the
495 // color map and then set to DirectClass type.
496 modifyImage();
497 GetPPException;
498 SyncImage(image(),exceptionInfo);
499 ThrowImageException;
500 image()->colormap=(PixelInfo *)RelinquishMagickMemory(image()->colormap);
501 image()->storage_class=static_cast<MagickCore::ClassType>(DirectClass);
502 return;
503 }
504
505 if (classType() == DirectClass && class_ == PseudoClass)
506 {
507 // Quantize to create PseudoClass color map
508 modifyImage();
509 quantizeColors(MaxColormapSize);
510 quantize();
511 image()->storage_class=static_cast<MagickCore::ClassType>(PseudoClass);
512 }
513}

◆ classType() [2/2]

Magick::ClassType Magick::Image::classType ( void ) const

Definition at line 515 of file Image.cpp.

516{
517 return static_cast<Magick::ClassType>(constImage()->storage_class);
518}

◆ clip()

void Magick::Image::clip ( void )

Definition at line 2314 of file Image.cpp.

2315{
2316 modifyImage();
2317 GetPPException;
2318 ClipImage(image(),exceptionInfo);
2319 ThrowImageException;
2320}

◆ clipPath()

void Magick::Image::clipPath ( const std::string pathname_,
const bool inside_ )

Definition at line 2322 of file Image.cpp.

2323{
2324 modifyImage();
2325 GetPPException;
2326 ClipImagePath(image(),pathname_.c_str(),(MagickBooleanType) inside_,
2327 exceptionInfo);
2328 ThrowImageException;
2329}

◆ clut()

void Magick::Image::clut ( const Image & clutImage_,
const PixelInterpolateMethod method )

Definition at line 2331 of file Image.cpp.

2333{
2334 modifyImage();
2335 GetPPException;
2336 ClutImage(image(),clutImage_.constImage(),method,exceptionInfo);
2337 ThrowImageException;
2338}

◆ clutChannel()

void Magick::Image::clutChannel ( const ChannelType channel_,
const Image & clutImage_,
const PixelInterpolateMethod method )

Definition at line 2340 of file Image.cpp.

2342{
2343 modifyImage();
2344 GetPPException;
2345 GetAndSetPPChannelMask(channel_);
2346 ClutImage(image(),clutImage_.constImage(),method,exceptionInfo);
2347 RestorePPChannelMask;
2348 ThrowImageException;
2349}

◆ colorFuzz() [1/2]

void Magick::Image::colorFuzz ( const double fuzz_)

Definition at line 520 of file Image.cpp.

521{
522 modifyImage();
523 image()->fuzz=fuzz_;
524 options()->colorFuzz(fuzz_);
525}

◆ colorFuzz() [2/2]

double Magick::Image::colorFuzz ( void ) const

Definition at line 527 of file Image.cpp.

528{
529 return(constOptions()->colorFuzz());
530}

◆ colorize() [1/2]

void Magick::Image::colorize ( const unsigned int alpha_,
const Color & penColor_ )

Definition at line 2351 of file Image.cpp.

2352{
2353 colorize(alpha_,alpha_,alpha_,penColor_);
2354}

◆ colorize() [2/2]

void Magick::Image::colorize ( const unsigned int alphaRed_,
const unsigned int alphaGreen_,
const unsigned int alphaBlue_,
const Color & penColor_ )

Definition at line 2356 of file Image.cpp.

2359{
2360 char
2361 blend[MagickPathExtent];
2362
2363 MagickCore::Image
2364 *newImage;
2365
2366 PixelInfo
2367 target;
2368
2369 if (!penColor_.isValid())
2370 throwExceptionExplicit(MagickCore::OptionError,
2371 "Pen color argument is invalid");
2372
2373 FormatLocaleString(blend,MagickPathExtent,"%u/%u/%u",alphaRed_,alphaGreen_,
2374 alphaBlue_);
2375
2376 target=static_cast<PixelInfo>(penColor_);
2377 GetPPException;
2378 newImage=ColorizeImage(image(),blend,&target,exceptionInfo);
2379 replaceImage(newImage);
2380 ThrowImageException;
2381}

◆ colorMap() [1/2]

Magick::Color Magick::Image::colorMap ( const size_t index_) const

Definition at line 2408 of file Image.cpp.

2409{
2410 if (!constImage()->colormap)
2411 {
2412 throwExceptionExplicit(MagickCore::OptionError,
2413 "Image does not contain a colormap");
2414 return(Color());
2415 }
2416
2417 if (index_ > constImage()->colors-1)
2418 throwExceptionExplicit(MagickCore::OptionError,"Index out of range");
2419
2420 return(Magick::Color((constImage()->colormap)[index_]));
2421}

◆ colorMap() [2/2]

void Magick::Image::colorMap ( const size_t index_,
const Color & color_ )

Definition at line 2383 of file Image.cpp.

2384{
2385 MagickCore::Image
2386 *imageptr;
2387
2388 imageptr=image();
2389
2390 if (index_ > (MaxColormapSize-1))
2391 throwExceptionExplicit(MagickCore::OptionError,
2392 "Colormap index must be less than MaxColormapSize");
2393
2394 if (!color_.isValid())
2395 throwExceptionExplicit(MagickCore::OptionError,
2396 "Color argument is invalid");
2397
2398 modifyImage();
2399
2400 // Ensure that colormap size is large enough
2401 if (colorMapSize() < (index_+1))
2402 colorMapSize(index_+1);
2403
2404 // Set color at index in colormap
2405 (imageptr->colormap)[index_]=color_;
2406}

◆ colorMapSize() [1/2]

void Magick::Image::colorMapSize ( const size_t entries_)

Definition at line 532 of file Image.cpp.

533{
534 if (entries_ >MaxColormapSize)
535 throwExceptionExplicit(MagickCore::OptionError,
536 "Colormap entries must not exceed MaxColormapSize");
537
538 modifyImage();
539 GetPPException;
540 (void) AcquireImageColormap(image(),entries_,exceptionInfo);
541 ThrowImageException;
542}

◆ colorMapSize() [2/2]

size_t Magick::Image::colorMapSize ( void ) const

Definition at line 544 of file Image.cpp.

545{
546 if (!constImage()->colormap)
547 throwExceptionExplicit(MagickCore::OptionError,
548 "Image does not contain a colormap");
549
550 return(constImage()->colors);
551}

◆ colorMatrix()

void Magick::Image::colorMatrix ( const size_t order_,
const double * color_matrix_ )

Definition at line 2423 of file Image.cpp.

2425{
2426 KernelInfo
2427 *kernel_info;
2428
2429 GetPPException;
2430 kernel_info=AcquireKernelInfo((const char *) NULL,exceptionInfo);
2431 if (kernel_info != (KernelInfo *) NULL)
2432 {
2433 kernel_info->width=order_;
2434 kernel_info->height=order_;
2435 kernel_info->values=(MagickRealType *) AcquireAlignedMemory(order_,
2436 order_*sizeof(*kernel_info->values));
2437 if (kernel_info->values != (MagickRealType *) NULL)
2438 {
2439 MagickCore::Image
2440 *newImage;
2441
2442 for (ssize_t i=0; i < (ssize_t) (order_*order_); i++)
2443 kernel_info->values[i]=color_matrix_[i];
2444 newImage=ColorMatrixImage(image(),kernel_info,exceptionInfo);
2445 replaceImage(newImage);
2446 }
2447 kernel_info=DestroyKernelInfo(kernel_info);
2448 }
2449 ThrowImageException;
2450}

◆ colorSpace() [1/2]

void Magick::Image::colorSpace ( const ColorspaceType colorSpace_)

Definition at line 553 of file Image.cpp.

554{
555 if (image()->colorspace == colorSpace_)
556 return;
557
558 modifyImage();
559 GetPPException;
560 TransformImageColorspace(image(),colorSpace_,exceptionInfo);
561 ThrowImageException;
562}

◆ colorSpace() [2/2]

Magick::ColorspaceType Magick::Image::colorSpace ( void ) const

Definition at line 564 of file Image.cpp.

565{
566 return (constImage()->colorspace);
567}

◆ colorSpaceType() [1/2]

void Magick::Image::colorSpaceType ( const ColorspaceType colorSpace_)

Definition at line 569 of file Image.cpp.

570{
571 modifyImage();
572 GetPPException;
573 SetImageColorspace(image(),colorSpace_,exceptionInfo);
574 ThrowImageException;
575 options()->colorspaceType(colorSpace_);
576}

◆ colorSpaceType() [2/2]

Magick::ColorspaceType Magick::Image::colorSpaceType ( void ) const

Definition at line 578 of file Image.cpp.

579{
580 return(constOptions()->colorspaceType());
581}

◆ columns()

size_t Magick::Image::columns ( void ) const

Definition at line 583 of file Image.cpp.

584{
585 return(constImage()->columns);
586}

◆ comment() [1/2]

void Magick::Image::comment ( const std::string & comment_)

Definition at line 588 of file Image.cpp.

589{
590 modifyImage();
591 GetPPException;
592 SetImageProperty(image(),"Comment",NULL,exceptionInfo);
593 if (comment_.length() > 0)
594 SetImageProperty(image(),"Comment",comment_.c_str(),exceptionInfo);
595 ThrowImageException;
596}

◆ comment() [2/2]

std::string Magick::Image::comment ( void ) const

Definition at line 598 of file Image.cpp.

599{
600 const char
601 *value;
602
603 GetPPException;
604 value=GetImageProperty(constImage(),"Comment",exceptionInfo);
605 ThrowImageException;
606
607 if (value)
608 return(std::string(value));
609
610 return(std::string()); // Intentionally no exception
611}

◆ compare() [1/3]

bool Magick::Image::compare ( const Image & reference_) const

Definition at line 2452 of file Image.cpp.

2453{
2454 bool
2455 status;
2456
2457 Image
2458 ref=reference_;
2459
2460 GetPPException;
2461 status=static_cast<bool>(IsImagesEqual(constImage(),ref.constImage(),
2462 exceptionInfo));
2463 ThrowImageException;
2464 return(status);
2465}

◆ compare() [2/3]

double Magick::Image::compare ( const Image & reference_,
const MetricType metric_ )

Definition at line 2467 of file Image.cpp.

2468{
2469 double
2470 distortion=0.0;
2471
2472 GetPPException;
2473 GetImageDistortion(image(),reference_.constImage(),metric_,&distortion,
2474 exceptionInfo);
2475 ThrowImageException;
2476 return(distortion);
2477}

◆ compare() [3/3]

Magick::Image Magick::Image::compare ( const Image & reference_,
const MetricType metric_,
double * distortion )

Definition at line 2494 of file Image.cpp.

2496{
2497 MagickCore::Image
2498 *newImage;
2499
2500 GetPPException;
2501 newImage=CompareImages(image(),reference_.constImage(),metric_,distortion,
2502 exceptionInfo);
2503 ThrowImageException;
2504 if (newImage == (MagickCore::Image *) NULL)
2505 return(Magick::Image());
2506 else
2507 return(Magick::Image(newImage));
2508}

◆ compareChannel() [1/2]

double Magick::Image::compareChannel ( const ChannelType channel_,
const Image & reference_,
const MetricType metric_ )

Definition at line 2479 of file Image.cpp.

2481{
2482 double
2483 distortion=0.0;
2484
2485 GetPPException;
2486 GetAndSetPPChannelMask(channel_);
2487 GetImageDistortion(image(),reference_.constImage(),metric_,&distortion,
2488 exceptionInfo);
2489 RestorePPChannelMask;
2490 ThrowImageException;
2491 return(distortion);
2492}

◆ compareChannel() [2/2]

Magick::Image Magick::Image::compareChannel ( const ChannelType channel_,
const Image & reference_,
const MetricType metric_,
double * distortion )

Definition at line 2510 of file Image.cpp.

2512{
2513 MagickCore::Image
2514 *newImage;
2515
2516 GetPPException;
2517 GetAndSetPPChannelMask(channel_);
2518 newImage=CompareImages(image(),reference_.constImage(),metric_,distortion,
2519 exceptionInfo);
2520 RestorePPChannelMask;
2521 ThrowImageException;
2522 if (newImage == (MagickCore::Image *) NULL)
2523 return(Magick::Image());
2524 else
2525 return(Magick::Image(newImage));
2526}

◆ compose() [1/2]

void Magick::Image::compose ( const CompositeOperator compose_)

Definition at line 613 of file Image.cpp.

614{
615 image()->compose=compose_;
616}

◆ compose() [2/2]

Magick::CompositeOperator Magick::Image::compose ( void ) const

Definition at line 618 of file Image.cpp.

619{
620 return(constImage()->compose);
621}

◆ composite() [1/2]

void Magick::Image::composite ( const Image & compositeImage_,
const Geometry & offset_,
const CompositeOperator compose_ = InCompositeOp )

Definition at line 2528 of file Image.cpp.

2530{
2531 size_t
2532 height=rows(),
2533 width=columns();
2534
2535 ssize_t
2536 x=offset_.xOff(),
2537 y=offset_.yOff();
2538
2539 ParseMetaGeometry(static_cast<std::string>(offset_).c_str(),&x,&y,&width,
2540 &height);
2541
2542 modifyImage();
2543 GetPPException;
2544 CompositeImage(image(),compositeImage_.constImage(),compose_,MagickTrue,
2545 x,y,exceptionInfo);
2546 ThrowImageException;
2547}

◆ composite() [2/2]

void Magick::Image::composite ( const Image & compositeImage_,
const GravityType gravity_,
const CompositeOperator compose_ = InCompositeOp )

Definition at line 2549 of file Image.cpp.

2551{
2552 RectangleInfo
2553 geometry;
2554
2555 modifyImage();
2556 SetGeometry(compositeImage_.constImage(),&geometry);
2557 GravityAdjustGeometry(columns(),rows(),gravity_,&geometry);
2558
2559 GetPPException;
2560 CompositeImage(image(),compositeImage_.constImage(),compose_,MagickTrue,
2561 geometry.x,geometry.y,exceptionInfo);
2562 ThrowImageException;
2563}

◆ compressType() [1/2]

void Magick::Image::compressType ( const CompressionType compressType_)

Definition at line 623 of file Image.cpp.

624{
625 modifyImage();
626 image()->compression=compressType_;
627 options()->compressType(compressType_);
628}

◆ compressType() [2/2]

Magick::CompressionType Magick::Image::compressType ( void ) const

Definition at line 630 of file Image.cpp.

631{
632 return(constImage()->compression);
633}

◆ connectedComponents()

void Magick::Image::connectedComponents ( const size_t connectivity_)

Definition at line 2578 of file Image.cpp.

2579{
2580 MagickCore::Image
2581 *newImage;
2582
2583 GetPPException;
2584 newImage=ConnectedComponentsImage(constImage(),connectivity_,
2585 (CCObjectInfo **) NULL,exceptionInfo);
2586 replaceImage(newImage);
2587 ThrowImageException;
2588}

◆ constImage()

const MagickCore::Image * Magick::Image::constImage ( void ) const

Definition at line 5026 of file Image.cpp.

5027{
5028 return(_imgRef->image());
5029}

◆ constImageInfo()

const MagickCore::ImageInfo * Magick::Image::constImageInfo ( void ) const

Definition at line 5036 of file Image.cpp.

5037{
5038 return(_imgRef->options()->imageInfo());
5039}

◆ constOptions()

const Magick::Options * Magick::Image::constOptions ( void ) const

Definition at line 5046 of file Image.cpp.

5047{
5048 return(_imgRef->options());
5049}

◆ constQuantizeInfo()

const MagickCore::QuantizeInfo * Magick::Image::constQuantizeInfo ( void ) const

Definition at line 5056 of file Image.cpp.

5057{
5058 return(_imgRef->options()->quantizeInfo());
5059}

◆ contrast()

void Magick::Image::contrast ( const bool sharpen_)

Definition at line 2590 of file Image.cpp.

2591{
2592 modifyImage();
2593 GetPPException;
2594 ContrastImage(image(),(MagickBooleanType) sharpen_,exceptionInfo);
2595 ThrowImageException;
2596}

◆ contrastStretch()

void Magick::Image::contrastStretch ( const double blackPoint_,
const double whitePoint_ )

Definition at line 2598 of file Image.cpp.

2600{
2601 modifyImage();
2602 GetPPException;
2603 ContrastStretchImage(image(),blackPoint_,whitePoint_,exceptionInfo);
2604 ThrowImageException;
2605}

◆ contrastStretchChannel()

void Magick::Image::contrastStretchChannel ( const ChannelType channel_,
const double blackPoint_,
const double whitePoint_ )

Definition at line 2607 of file Image.cpp.

2609{
2610 modifyImage();
2611 GetPPException;
2612 GetAndSetPPChannelMask(channel_);
2613 ContrastStretchImage(image(),blackPoint_,whitePoint_,exceptionInfo);
2614 RestorePPChannelMask;
2615 ThrowImageException;
2616}

◆ convolve()

void Magick::Image::convolve ( const size_t order_,
const double * kernel_ )

Definition at line 2618 of file Image.cpp.

2619{
2620 KernelInfo
2621 *kernel_info;
2622
2623 GetPPException;
2624 kernel_info=AcquireKernelInfo((const char *) NULL,exceptionInfo);
2625 kernel_info->width=order_;
2626 kernel_info->height=order_;
2627 kernel_info->x=(ssize_t) (order_-1)/2;
2628 kernel_info->y=(ssize_t) (order_-1)/2;
2629 kernel_info->values=(MagickRealType *) AcquireAlignedMemory(order_,
2630 order_*sizeof(*kernel_info->values));
2631 if (kernel_info->values != (MagickRealType *) NULL)
2632 {
2633 MagickCore::Image
2634 *newImage;
2635
2636 for (ssize_t i=0; i < (ssize_t) (order_*order_); i++)
2637 kernel_info->values[i]=kernel_[i];
2638 newImage=ConvolveImage(image(),kernel_info,exceptionInfo);
2639 replaceImage(newImage);
2640 }
2641 kernel_info=DestroyKernelInfo(kernel_info);
2642 ThrowImageException;
2643}

◆ copyPixels()

void Magick::Image::copyPixels ( const Image & source_,
const Geometry & geometry_,
const Offset & offset_ )

Definition at line 2645 of file Image.cpp.

2647{
2648 const OffsetInfo
2649 offset=offset_;
2650
2651 const RectangleInfo
2652 geometry=geometry_;
2653
2654 GetPPException;
2655 (void) CopyImagePixels(image(),source_.constImage(),&geometry,&offset,
2656 exceptionInfo);
2657 ThrowImageException;
2658}

◆ crop()

void Magick::Image::crop ( const Geometry & geometry_)

Definition at line 2660 of file Image.cpp.

2661{
2662 MagickCore::Image
2663 *newImage;
2664
2665 RectangleInfo
2666 cropInfo=geometry_;
2667
2668 GetPPException;
2669 newImage=CropImage(constImage(),&cropInfo,exceptionInfo);
2670 replaceImage(newImage);
2671 ThrowImageException;
2672}

◆ cycleColormap()

void Magick::Image::cycleColormap ( const ::ssize_t amount_)

Definition at line 2674 of file Image.cpp.

2675{
2676 modifyImage();
2677 GetPPException;
2678 CycleColormapImage(image(),amount_,exceptionInfo);
2679 ThrowImageException;
2680}

◆ debug() [1/2]

void Magick::Image::debug ( const bool flag_)

Definition at line 635 of file Image.cpp.

636{
637 modifyImage();
638 options()->debug(flag_);
639}

◆ debug() [2/2]

bool Magick::Image::debug ( void ) const

Definition at line 641 of file Image.cpp.

642{
643 return(constOptions()->debug());
644}

◆ decipher()

void Magick::Image::decipher ( const std::string & passphrase_)

Definition at line 2682 of file Image.cpp.

2683{
2684 modifyImage();
2685 GetPPException;
2686 DecipherImage(image(),passphrase_.c_str(),exceptionInfo);
2687 ThrowImageException;
2688}

◆ defineSet() [1/2]

bool Magick::Image::defineSet ( const std::string & magick_,
const std::string & key_ ) const

Definition at line 2704 of file Image.cpp.

2706{
2707 const char
2708 *option;
2709
2710 std::string
2711 key;
2712
2713 key=magick_ + ":" + key_;
2714 option=GetImageOption(constImageInfo(),key.c_str());
2715 if (option)
2716 return(true);
2717 return(false);
2718}

◆ defineSet() [2/2]

void Magick::Image::defineSet ( const std::string & magick_,
const std::string & key_,
bool flag_ )

Definition at line 2690 of file Image.cpp.

2692{
2693 std::string
2694 definition;
2695
2696 modifyImage();
2697 definition=magick_ + ":" + key_;
2698 if (flag_)
2699 (void) SetImageOption(imageInfo(),definition.c_str(),"");
2700 else
2701 DeleteImageOption(imageInfo(),definition.c_str());
2702}

◆ defineValue() [1/2]

std::string Magick::Image::defineValue ( const std::string & magick_,
const std::string & key_ ) const

Definition at line 2733 of file Image.cpp.

2735{
2736 const char
2737 *option;
2738
2739 std::string
2740 definition;
2741
2742 definition=magick_ + ":" + key_;
2743 option=GetImageOption(constImageInfo(),definition.c_str());
2744 if (option)
2745 return(std::string(option));
2746 return(std::string());
2747}

◆ defineValue() [2/2]

void Magick::Image::defineValue ( const std::string & magick_,
const std::string & key_,
const std::string & value_ )

Definition at line 2720 of file Image.cpp.

2722{
2723 std::string
2724 format,
2725 option;
2726
2727 modifyImage();
2728 format=magick_ + ":" + key_;
2729 option=value_;
2730 (void) SetImageOption(imageInfo(),format.c_str(),option.c_str());
2731}

◆ density() [1/2]

void Magick::Image::density ( const Point & density_)

Definition at line 646 of file Image.cpp.

647{
648 modifyImage();
649 options()->density(density_);
650 if (density_.isValid())
651 {
652 image()->resolution.x=density_.x();
653 if (density_.y() != 0.0)
654 image()->resolution.y=density_.y();
655 else
656 image()->resolution.y=density_.x();
657 }
658 else
659 {
660 // Reset to default
661 image()->resolution.x=0.0;
662 image()->resolution.y=0.0;
663 }
664}

◆ density() [2/2]

Magick::Point Magick::Image::density ( void ) const

Definition at line 666 of file Image.cpp.

667{
668 if (isValid())
669 {
670 double
671 x_resolution=72,
672 y_resolution=72;
673
674 if (constImage()->resolution.x > 0.0)
675 x_resolution=constImage()->resolution.x;
676
677 if (constImage()->resolution.y > 0.0)
678 y_resolution=constImage()->resolution.y;
679
680 return(Point(x_resolution, y_resolution));
681 }
682
683 return(constOptions()->density());
684}

◆ depth() [1/2]

void Magick::Image::depth ( const size_t depth_)

Definition at line 686 of file Image.cpp.

687{
688 modifyImage();
689 image()->depth=depth_;
690 options()->depth(depth_);
691}

◆ depth() [2/2]

size_t Magick::Image::depth ( void ) const

Definition at line 693 of file Image.cpp.

694{
695 return(constImage()->depth);
696}

◆ deskew()

void Magick::Image::deskew ( const double threshold_)

Definition at line 2749 of file Image.cpp.

2750{
2751 MagickCore::Image
2752 *newImage;
2753
2754 GetPPException;
2755 newImage=DeskewImage(constImage(),threshold_,exceptionInfo);
2756 replaceImage(newImage);
2757 ThrowImageException;
2758}

◆ despeckle()

void Magick::Image::despeckle ( void )

Definition at line 2760 of file Image.cpp.

2761{
2762 MagickCore::Image
2763 *newImage;
2764
2765 GetPPException;
2766 newImage=DespeckleImage(constImage(),exceptionInfo);
2767 replaceImage(newImage);
2768 ThrowImageException;
2769}

◆ directory()

std::string Magick::Image::directory ( void ) const

Definition at line 698 of file Image.cpp.

699{
700 if (constImage()->directory)
701 return(std::string(constImage()->directory));
702
703 if (!quiet())
704 throwExceptionExplicit(MagickCore::CorruptImageWarning,
705 "Image does not contain a directory");
706
707 return(std::string());
708}

◆ display()

void Magick::Image::display ( void )

Definition at line 2771 of file Image.cpp.

2772{
2773 GetPPException;
2774 DisplayImages(imageInfo(),image(),exceptionInfo);
2775 ThrowImageException;
2776}

◆ distort()

void Magick::Image::distort ( const DistortMethod method_,
const size_t numberArguments_,
const double * arguments_,
const bool bestfit_ = false )

Definition at line 2778 of file Image.cpp.

2780{
2781 MagickCore::Image
2782 *newImage;
2783
2784 GetPPException;
2785 newImage=DistortImage(constImage(), method_,numberArguments_,arguments_,
2786 bestfit_ == true ? MagickTrue : MagickFalse,exceptionInfo);
2787 replaceImage(newImage);
2788 ThrowImageException;
2789}

◆ draw() [1/2]

void Magick::Image::draw ( const Drawable & drawable_)

Definition at line 2791 of file Image.cpp.

2792{
2793 DrawingWand
2794 *wand;
2795
2796 modifyImage();
2797
2798 wand=AcquireDrawingWand(options()->drawInfo(),image());
2799
2800 if(wand)
2801 {
2802 drawable_.operator()(wand);
2803
2804 DrawRender(wand);
2805
2806 ClonePPDrawException(wand);
2807 wand=DestroyDrawingWand(wand);
2808 ThrowPPDrawException(quiet());
2809 }
2810}

◆ draw() [2/2]

void Magick::Image::draw ( const std::vector< Magick::Drawable > & drawable_)

Definition at line 2812 of file Image.cpp.

2813{
2814 DrawingWand
2815 *wand;
2816
2817 modifyImage();
2818
2819 wand= AcquireDrawingWand(options()->drawInfo(),image());
2820
2821 if(wand)
2822 {
2823 for (std::vector<Magick::Drawable>::const_iterator p = drawable_.begin();
2824 p != drawable_.end(); p++ )
2825 {
2826 p->operator()(wand);
2827 if (DrawGetExceptionType(wand) != MagickCore::UndefinedException)
2828 break;
2829 }
2830
2831 if (DrawGetExceptionType(wand) == MagickCore::UndefinedException)
2832 DrawRender(wand);
2833
2834 ClonePPDrawException(wand);
2835 wand=DestroyDrawingWand(wand);
2836 ThrowPPDrawException(quiet());
2837 }
2838}

◆ edge()

void Magick::Image::edge ( const double radius_ = 0.0)

Definition at line 2840 of file Image.cpp.

2841{
2842 MagickCore::Image
2843 *newImage;
2844
2845 GetPPException;
2846 newImage=EdgeImage(constImage(),radius_,exceptionInfo);
2847 replaceImage(newImage);
2848 ThrowImageException;
2849}

◆ emboss()

void Magick::Image::emboss ( const double radius_ = 0.0,
const double sigma_ = 1.0 )

Definition at line 2851 of file Image.cpp.

2852{
2853 MagickCore::Image
2854 *newImage;
2855
2856 GetPPException;
2857 newImage=EmbossImage(constImage(),radius_,sigma_,exceptionInfo);
2858 replaceImage(newImage);
2859 ThrowImageException;
2860}

◆ encipher()

void Magick::Image::encipher ( const std::string & passphrase_)

Definition at line 2862 of file Image.cpp.

2863{
2864 modifyImage();
2865 GetPPException;
2866 EncipherImage(image(),passphrase_.c_str(),exceptionInfo);
2867 ThrowImageException;
2868}

◆ endian()

Magick::EndianType Magick::Image::endian ( void ) const

Definition at line 717 of file Image.cpp.

718{
719 return(constImage()->endian);
720}

◆ enhance()

void Magick::Image::enhance ( void )

Definition at line 2870 of file Image.cpp.

2871{
2872 MagickCore::Image
2873 *newImage;
2874
2875 GetPPException;
2876 newImage=EnhanceImage(constImage(),exceptionInfo);
2877 replaceImage(newImage);
2878 ThrowImageException;
2879}

◆ equalize()

void Magick::Image::equalize ( void )

Definition at line 2881 of file Image.cpp.

2882{
2883 modifyImage();
2884 GetPPException;
2885 EqualizeImage(image(),exceptionInfo);
2886 ThrowImageException;
2887}

◆ erase()

void Magick::Image::erase ( void )

Definition at line 2889 of file Image.cpp.

2890{
2891 modifyImage();
2892 GetPPException;
2893 (void) SetImageBackgroundColor(image(),exceptionInfo);
2894 ThrowImageException;
2895}

◆ evaluate() [1/2]

void Magick::Image::evaluate ( const ChannelType channel_,
const MagickEvaluateOperator operator_,
double rvalue_ )

Definition at line 2897 of file Image.cpp.

2899{
2900 GetPPException;
2901 GetAndSetPPChannelMask(channel_);
2902 EvaluateImage(image(),operator_,rvalue_,exceptionInfo);
2903 RestorePPChannelMask;
2904 ThrowImageException;
2905}

◆ evaluate() [2/2]

void Magick::Image::evaluate ( const ChannelType channel_,
const MagickFunction function_,
const size_t number_parameters_,
const double * parameters_ )

Definition at line 2907 of file Image.cpp.

2910{
2911 GetPPException;
2912 GetAndSetPPChannelMask(channel_);
2913 FunctionImage(image(),function_,number_parameters_,parameters_,
2914 exceptionInfo);
2915 RestorePPChannelMask;
2916 ThrowImageException;
2917}

◆ exifProfile() [1/2]

void Magick::Image::exifProfile ( const Blob & exifProfile_)

Definition at line 722 of file Image.cpp.

723{
724 modifyImage();
725
726 if (exifProfile_.data() != 0)
727 {
728 StringInfo
729 *exif_profile;
730
731 exif_profile=AcquireStringInfo(exifProfile_.length());
732 SetStringInfoDatum(exif_profile,(unsigned char *) exifProfile_.data());
733 GetPPException;
734 (void) SetImageProfile(image(),"exif",exif_profile,exceptionInfo);
735 exif_profile=DestroyStringInfo(exif_profile);
736 ThrowImageException;
737 }
738}

◆ exifProfile() [2/2]

Magick::Blob Magick::Image::exifProfile ( void ) const

Definition at line 740 of file Image.cpp.

741{
742 const StringInfo
743 *exif_profile;
744
745 exif_profile=GetImageProfile(constImage(),"exif");
746 if (exif_profile == (StringInfo *) NULL)
747 return(Blob());
748 return(Blob(GetStringInfoDatum(exif_profile),
749 GetStringInfoLength(exif_profile)));
750}

◆ extent() [1/4]

void Magick::Image::extent ( const Geometry & geometry_)

Definition at line 2946 of file Image.cpp.

2947{
2948 MagickCore::Image
2949 *newImage;
2950
2951 RectangleInfo
2952 extentInfo=geometry_;
2953
2954 modifyImage();
2955 extentInfo.x=geometry_.xOff();
2956 extentInfo.y=geometry_.yOff();
2957 GetPPException;
2958 newImage=ExtentImage(image(),&extentInfo,exceptionInfo);
2959 replaceImage(newImage);
2960 ThrowImageException;
2961}

◆ extent() [2/4]

void Magick::Image::extent ( const Geometry & geometry_,
const Color & backgroundColor )

Definition at line 2963 of file Image.cpp.

2965{
2966 backgroundColor(backgroundColor_);
2967 extent(geometry_);
2968}

◆ extent() [3/4]

void Magick::Image::extent ( const Geometry & geometry_,
const Color & backgroundColor,
const GravityType gravity_ )

Definition at line 2970 of file Image.cpp.

2972{
2973 backgroundColor(backgroundColor_);
2974 extent(geometry_,gravity_);
2975}

◆ extent() [4/4]

void Magick::Image::extent ( const Geometry & geometry_,
const GravityType gravity_ )

Definition at line 2977 of file Image.cpp.

2979{
2980 RectangleInfo
2981 geometry;
2982
2983 SetGeometry(image(),&geometry);
2984 geometry.width=geometry_.width();
2985 geometry.height=geometry_.height();
2986 GravityAdjustGeometry(image()->columns,image()->rows,gravity_,&geometry);
2987 extent(geometry);
2988}

◆ fileName() [1/2]

void Magick::Image::fileName ( const std::string & fileName_)

Definition at line 752 of file Image.cpp.

753{
754 ssize_t
755 max_length;
756
757 modifyImage();
758
759 max_length=sizeof(image()->filename)-1;
760 fileName_.copy(image()->filename,(size_t) max_length);
761 if ((ssize_t) fileName_.length() > max_length)
762 image()->filename[max_length]=0;
763 else
764 image()->filename[fileName_.length()]=0;
765
766 options()->fileName(fileName_);
767}

◆ fileName() [2/2]

std::string Magick::Image::fileName ( void ) const

Definition at line 769 of file Image.cpp.

770{
771 return(constOptions()->fileName());
772}

◆ fileSize()

MagickCore::MagickSizeType Magick::Image::fileSize ( void ) const

Definition at line 774 of file Image.cpp.

775{
776 return(GetBlobSize(constImage()));
777}

◆ fillColor() [1/2]

void Magick::Image::fillColor ( const Color & fillColor_)

Definition at line 779 of file Image.cpp.

780{
781 modifyImage();
782 options()->fillColor(fillColor_);
783}

◆ fillColor() [2/2]

Magick::Color Magick::Image::fillColor ( void ) const

Definition at line 785 of file Image.cpp.

786{
787 return(constOptions()->fillColor());
788}

◆ fillPattern() [1/2]

void Magick::Image::fillPattern ( const Image & fillPattern_)

Definition at line 801 of file Image.cpp.

802{
803 modifyImage();
804 if (fillPattern_.isValid())
805 options()->fillPattern(fillPattern_.constImage());
806 else
807 options()->fillPattern(static_cast<MagickCore::Image*>(NULL));
808}

◆ fillPattern() [2/2]

Magick::Image Magick::Image::fillPattern ( void ) const

Definition at line 810 of file Image.cpp.

811{
812 // FIXME: This is inordinately inefficient
813 const MagickCore::Image
814 *tmpTexture;
815
816 Image
817 texture;
818
819 tmpTexture=constOptions()->fillPattern();
820
821 if (tmpTexture)
822 {
823 MagickCore::Image
824 *image;
825
826 GetPPException;
827 image=CloneImage(tmpTexture,0,0,MagickTrue,exceptionInfo);
828 texture.replaceImage(image);
829 ThrowImageException;
830 }
831 return(texture);
832}

◆ fillRule()

Magick::FillRule Magick::Image::fillRule ( void ) const

Definition at line 796 of file Image.cpp.

797{
798 return constOptions()->fillRule();
799}

◆ filterType()

Magick::FilterType Magick::Image::filterType ( void ) const

Definition at line 840 of file Image.cpp.

841{
842 return(constImage()->filter);
843}

◆ flip()

void Magick::Image::flip ( void )

Definition at line 2990 of file Image.cpp.

2991{
2992 MagickCore::Image
2993 *newImage;
2994
2995 GetPPException;
2996 newImage=FlipImage(constImage(),exceptionInfo);
2997 replaceImage(newImage);
2998 ThrowImageException;
2999}

◆ floodFill()

void Magick::Image::floodFill ( const ssize_t x_,
const ssize_t y_,
const Magick::Image * fillPattern_,
const Color & fill_,
const PixelInfo * target,
const bool invert_ )
private

Definition at line 5118 of file Image.cpp.

5121{
5122 Magick::Color
5123 fillColor;
5124
5125 MagickCore::Image
5126 *fillPattern;
5127
5128 // Set drawing fill pattern or fill color
5129 fillColor=options()->fillColor();
5130 fillPattern=(MagickCore::Image *)NULL;
5131 if (options()->fillPattern() != (MagickCore::Image *)NULL)
5132 {
5133 GetPPException;
5134 fillPattern=CloneImage(options()->fillPattern(),0,0,MagickTrue,
5135 exceptionInfo);
5136 ThrowImageException;
5137 }
5138
5139 if (fillPattern_ == (Magick::Image *)NULL)
5140 {
5141 options()->fillPattern((MagickCore::Image *)NULL);
5142 options()->fillColor(fill_);
5143 }
5144 else
5145 options()->fillPattern(fillPattern_->constImage());
5146
5147 GetPPException;
5148 (void) FloodfillPaintImage(image(),options()->drawInfo(),
5149 target_,static_cast<ssize_t>(x_),static_cast<ssize_t>(y_),
5150 (MagickBooleanType) invert_,exceptionInfo);
5151
5152 options()->fillColor(fillColor);
5153 options()->fillPattern(fillPattern);
5154 ThrowImageException;
5155}

◆ floodFillAlpha()

void Magick::Image::floodFillAlpha ( const ssize_t x_,
const ssize_t y_,
const unsigned int alpha_,
const Color & target_,
const bool invert_ = false )

Definition at line 3019 of file Image.cpp.

3021{
3022 PixelInfo
3023 target;
3024
3025 modifyImage();
3026
3027 target=static_cast<PixelInfo>(target_);
3028 target.alpha=alpha_;
3029 GetPPException;
3030 GetAndSetPPChannelMask(AlphaChannel);
3031 FloodfillPaintImage(image(),options()->drawInfo(),&target,x_,y_,
3032 (MagickBooleanType)invert_,exceptionInfo);
3033 RestorePPChannelMask;
3034 ThrowImageException;
3035}

◆ floodFillColor() [1/2]

void Magick::Image::floodFillColor ( const Geometry & point_,
const Color & fillColor_,
const bool invert_ = false )

Definition at line 3037 of file Image.cpp.

3039{
3040 floodFillColor(point_.xOff(),point_.yOff(),fillColor_,invert_);
3041}

◆ floodFillColor() [2/2]

void Magick::Image::floodFillColor ( const Geometry & point_,
const Color & fillColor_,
const Color & borderColor_,
const bool invert_ = false )

Definition at line 3055 of file Image.cpp.

3058{
3059 floodFillColor(point_.xOff(),point_.yOff(),fillColor_,borderColor_,invert_);
3060}

◆ floodFillTexture() [1/2]

void Magick::Image::floodFillTexture ( const Geometry & point_,
const Image & texture_,
const bool invert_ = false )

Definition at line 3075 of file Image.cpp.

3077{
3078 floodFillTexture(point_.xOff(),point_.yOff(),texture_,invert_);
3079}

◆ floodFillTexture() [2/2]

void Magick::Image::floodFillTexture ( const Geometry & point_,
const Image & texture_,
const Color & borderColor_,
const bool invert_ = false )

Definition at line 3093 of file Image.cpp.

3096{
3097 floodFillTexture(point_.xOff(),point_.yOff(),texture_,borderColor_,invert_);
3098}

◆ flop()

void Magick::Image::flop ( void )

Definition at line 3113 of file Image.cpp.

3114{
3115 MagickCore::Image
3116 *newImage;
3117
3118 GetPPException;
3119 newImage=FlopImage(constImage(),exceptionInfo);
3120 replaceImage(newImage);
3121 ThrowImageException;
3122}

◆ font() [1/2]

void Magick::Image::font ( const std::string & font_)

Definition at line 845 of file Image.cpp.

846{
847 modifyImage();
848 options()->font(font_);
849}

◆ font() [2/2]

std::string Magick::Image::font ( void ) const

Definition at line 851 of file Image.cpp.

852{
853 return(constOptions()->font());
854}

◆ fontFamily() [1/2]

void Magick::Image::fontFamily ( const std::string & family_)

Definition at line 856 of file Image.cpp.

857{
858 modifyImage();
859 options()->fontFamily(family_);
860}

◆ fontFamily() [2/2]

std::string Magick::Image::fontFamily ( void ) const

Definition at line 862 of file Image.cpp.

863{
864 return(constOptions()->fontFamily());
865}

◆ fontPointsize() [1/2]

void Magick::Image::fontPointsize ( const double pointSize_)

Definition at line 867 of file Image.cpp.

868{
869 modifyImage();
870 options()->fontPointsize(pointSize_);
871}

◆ fontPointsize() [2/2]

double Magick::Image::fontPointsize ( void ) const

Definition at line 873 of file Image.cpp.

874{
875 return(constOptions()->fontPointsize());
876}

◆ fontStyle() [1/2]

void Magick::Image::fontStyle ( const StyleType style_)

Definition at line 878 of file Image.cpp.

879{
880 modifyImage();
881 options()->fontStyle(pointSize_);
882}

◆ fontStyle() [2/2]

Magick::StyleType Magick::Image::fontStyle ( void ) const

Definition at line 884 of file Image.cpp.

885{
886 return(constOptions()->fontStyle());
887}

◆ fontTypeMetrics()

void Magick::Image::fontTypeMetrics ( const std::string & text_,
TypeMetric * metrics )

Definition at line 3124 of file Image.cpp.

3126{
3127 DrawInfo
3128 *drawInfo;
3129
3130 drawInfo=options()->drawInfo();
3131 drawInfo->text=DestroyString(drawInfo->text);
3132 drawInfo->text=const_cast<char *>(text_.c_str());
3133 GetPPException;
3134 GetTypeMetrics(image(),drawInfo,&(metrics->_typeMetric),exceptionInfo);
3135 drawInfo->text=(char *) NULL;
3136 ThrowImageException;
3137}

◆ fontTypeMetricsMultiline()

void Magick::Image::fontTypeMetricsMultiline ( const std::string & text_,
TypeMetric * metrics )

Definition at line 3139 of file Image.cpp.

3141{
3142 DrawInfo
3143 *drawInfo;
3144
3145 drawInfo=options()->drawInfo();
3146 drawInfo->text=DestroyString(drawInfo->text);
3147 drawInfo->text=const_cast<char *>(text_.c_str());
3148 GetPPException;
3149 (void) GetMultilineTypeMetrics(image(),drawInfo,&(metrics->_typeMetric),
3150 exceptionInfo);
3151 drawInfo->text=(char *) NULL;
3152 ThrowImageException;
3153}

◆ fontWeight() [1/2]

void Magick::Image::fontWeight ( const size_t weight_)

Definition at line 889 of file Image.cpp.

890{
891 modifyImage();
892 options()->fontWeight(weight_);
893}

◆ fontWeight() [2/2]

size_t Magick::Image::fontWeight ( void ) const

Definition at line 895 of file Image.cpp.

896{
897 return(constOptions()->fontWeight());
898}

◆ format()

std::string Magick::Image::format ( void ) const

Definition at line 900 of file Image.cpp.

901{
902 const MagickInfo
903 *magick_info;
904
905 GetPPException;
906 magick_info=GetMagickInfo(constImage()->magick,exceptionInfo);
907 ThrowImageException;
908
909 if ((magick_info != 0) && (*magick_info->description != '\0'))
910 return(std::string(magick_info->description));
911
912 if (!quiet())
913 throwExceptionExplicit(MagickCore::CorruptImageWarning,
914 "Unrecognized image magick type");
915
916 return(std::string());
917}

◆ formatExpression()

std::string Magick::Image::formatExpression ( const std::string expression)

Definition at line 919 of file Image.cpp.

920{
921 char
922 *text;
923
924 std::string
925 text_string;
926
927 GetPPException;
928 modifyImage();
929 text=InterpretImageProperties(imageInfo(),image(),expression.c_str(),
930 exceptionInfo);
931 if (text != (char *) NULL)
932 {
933 text_string=std::string(text);
934 text=DestroyString(text);
935 }
936 ThrowImageException;
937 return(text_string);
938}

◆ frame()

void Magick::Image::frame ( const Geometry & geometry_ = frameGeometryDefault)

Definition at line 3155 of file Image.cpp.

3156{
3157 FrameInfo
3158 info;
3159
3160 MagickCore::Image
3161 *newImage;
3162
3163 info.x=static_cast<ssize_t>(geometry_.width());
3164 info.y=static_cast<ssize_t>(geometry_.height());
3165 info.width=columns() + (static_cast<size_t>(info.x) << 1);
3166 info.height=rows() + (static_cast<size_t>(info.y) << 1);
3167 info.outer_bevel=geometry_.xOff();
3168 info.inner_bevel=geometry_.yOff();
3169
3170 GetPPException;
3171 newImage=FrameImage(constImage(),&info,image()->compose,exceptionInfo);
3172 replaceImage(newImage);
3173 ThrowImageException;
3174}

◆ fx() [1/2]

void Magick::Image::fx ( const std::string expression_)

Definition at line 3198 of file Image.cpp.

3199{
3200 MagickCore::Image
3201 *newImage;
3202
3203 GetPPException;
3204 newImage=FxImage(constImage(),expression_.c_str(),exceptionInfo);
3205 replaceImage(newImage);
3206 ThrowImageException;
3207}

◆ fx() [2/2]

void Magick::Image::fx ( const std::string expression_,
const Magick::ChannelType channel_ )

Definition at line 3209 of file Image.cpp.

3211{
3212 MagickCore::Image
3213 *newImage;
3214
3215 GetPPException;
3216 GetAndSetPPChannelMask(channel_);
3217 newImage=FxImage(constImage(),expression_.c_str(),exceptionInfo);
3218 RestorePPChannelMask;
3219 replaceImage(newImage);
3220 ThrowImageException;
3221}

◆ gamma() [1/3]

void Magick::Image::gamma ( const double gamma_)

Definition at line 3223 of file Image.cpp.

3224{
3225 modifyImage();
3226 GetPPException;
3227 GammaImage(image(),gamma_,exceptionInfo);
3228 ThrowImageException;
3229}

◆ gamma() [2/3]

void Magick::Image::gamma ( const double gammaRed_,
const double gammaGreen_,
const double gammaBlue_ )

Definition at line 3231 of file Image.cpp.

3233{
3234 modifyImage();
3235 GetPPException;
3236 GetAndSetPPChannelMask(RedChannel);
3237 (void) GammaImage(image(),gammaRed_,exceptionInfo);
3238 SetPPChannelMask(GreenChannel);
3239 (void) GammaImage(image(),gammaGreen_,exceptionInfo);
3240 SetPPChannelMask(BlueChannel);
3241 (void) GammaImage(image(),gammaBlue_,exceptionInfo);
3242 RestorePPChannelMask;
3243 ThrowImageException;
3244}

◆ gamma() [3/3]

double Magick::Image::gamma ( void ) const

Definition at line 940 of file Image.cpp.

941{
942 return(constImage()->gamma);
943}

◆ gaussianBlur()

void Magick::Image::gaussianBlur ( const double radius_,
const double sigma_ )

Definition at line 3246 of file Image.cpp.

3247{
3248 MagickCore::Image
3249 *newImage;
3250
3251 GetPPException;
3252 newImage=GaussianBlurImage(constImage(),radius_,sigma_,exceptionInfo);
3253 replaceImage(newImage);
3254 ThrowImageException;
3255}

◆ gaussianBlurChannel()

void Magick::Image::gaussianBlurChannel ( const ChannelType channel_,
const double radius_,
const double sigma_ )

Definition at line 3257 of file Image.cpp.

3259{
3260 MagickCore::Image
3261 *newImage;
3262
3263 GetPPException;
3264 GetAndSetPPChannelMask(channel_);
3265 newImage=GaussianBlurImage(constImage(),radius_,sigma_,exceptionInfo);
3266 RestorePPChannelMask;
3267 replaceImage(newImage);
3268 ThrowImageException;
3269}

◆ geometry()

Magick::Geometry Magick::Image::geometry ( void ) const

Definition at line 945 of file Image.cpp.

946{
947 if (constImage()->geometry)
948 return Geometry(constImage()->geometry);
949
950 if (!quiet())
951 throwExceptionExplicit(MagickCore::OptionWarning,
952 "Image does not contain a geometry");
953
954 return(Geometry());
955}

◆ getConstMetacontent()

const void * Magick::Image::getConstMetacontent ( void ) const

Definition at line 3283 of file Image.cpp.

3284{
3285 const void
3286 *result;
3287
3288 result=GetVirtualMetacontent(constImage());
3289
3290 if(!result)
3291 throwExceptionExplicit(MagickCore::OptionError,
3292 "Unable to retrieve meta content.");
3293
3294 return(result);
3295}

◆ getConstPixels()

const Magick::Quantum * Magick::Image::getConstPixels ( const ::ssize_t x_,
const ::ssize_t y_,
const size_t columns_,
const size_t rows_ ) const

Definition at line 3271 of file Image.cpp.

3273{
3274 const Quantum
3275 *p;
3276
3277 GetPPException;
3278 p=GetVirtualPixels(constImage(),x_, y_,columns_, rows_,exceptionInfo);
3279 ThrowImageException;
3280 return(p);
3281}

◆ getMetacontent()

void * Magick::Image::getMetacontent ( void )

Definition at line 3297 of file Image.cpp.

3298{
3299 void
3300 *result;
3301
3302 result=GetAuthenticMetacontent(image());
3303
3304 if(!result)
3305 throwExceptionExplicit(MagickCore::OptionError,
3306 "Unable to retrieve meta content.");
3307
3308 return(result);
3309}

◆ getPixels()

Magick::Quantum * Magick::Image::getPixels ( const ::ssize_t x_,
const ::ssize_t y_,
const size_t columns_,
const size_t rows_ )

Definition at line 3311 of file Image.cpp.

3313{
3314 Quantum
3315 *result;
3316
3317 modifyImage();
3318 GetPPException;
3319 result=GetAuthenticPixels(image(),x_, y_,columns_,rows_,exceptionInfo);
3320 ThrowImageException;
3321
3322 return(result);
3323}

◆ gifDisposeMethod()

MagickCore::DisposeType Magick::Image::gifDisposeMethod ( void ) const

Definition at line 964 of file Image.cpp.

965{
966 return(constImage()->dispose);
967}

◆ grayscale()

void Magick::Image::grayscale ( const PixelIntensityMethod method_)

Definition at line 3325 of file Image.cpp.

3326{
3327 modifyImage();
3328 GetPPException;
3329 (void) GrayscaleImage(image(),method_,exceptionInfo);
3330 ThrowImageException;
3331}

◆ haldClut()

void Magick::Image::haldClut ( const Image & clutImage_)

Definition at line 3333 of file Image.cpp.

3334{
3335 modifyImage();
3336 GetPPException;
3337 (void) HaldClutImage(image(),clutImage_.constImage(),exceptionInfo);
3338 ThrowImageException;
3339}

◆ hasChannel()

bool Magick::Image::hasChannel ( const PixelChannel channel) const

Definition at line 969 of file Image.cpp.

970{
971 if (GetPixelChannelTraits(constImage(),channel) == UndefinedPixelTrait)
972 return(false);
973
974 if (channel == GreenPixelChannel || channel == BluePixelChannel)
975 return (GetPixelChannelOffset(constImage(),channel) == (ssize_t)channel);
976
977 return(true);
978}

◆ highlightColor()

void Magick::Image::highlightColor ( const Color color_)

Definition at line 980 of file Image.cpp.

981{
982 std::string
983 value;
984
985 value=color_;
986 artifact("compare:highlight-color",value);
987}

◆ houghLine()

void Magick::Image::houghLine ( const size_t width_,
const size_t height_,
const size_t threshold_ = 40 )

Definition at line 3341 of file Image.cpp.

3343{
3344 MagickCore::Image
3345 *newImage;
3346
3347 GetPPException;
3348 newImage=HoughLineImage(constImage(),width_,height_,threshold_,
3349 exceptionInfo);
3350 replaceImage(newImage);
3351 ThrowImageException;
3352}

◆ iccColorProfile() [1/2]

void Magick::Image::iccColorProfile ( const Blob & colorProfile_)

Definition at line 989 of file Image.cpp.

990{
991 profile("icc",colorProfile_);
992}

◆ iccColorProfile() [2/2]

Magick::Blob Magick::Image::iccColorProfile ( void ) const

Definition at line 994 of file Image.cpp.

995{
996 const StringInfo
997 *color_profile;
998
999 color_profile=GetImageProfile(constImage(),"icc");
1000 if (color_profile == (StringInfo *) NULL)
1001 return(Blob());
1002 return(Blob(GetStringInfoDatum(color_profile),GetStringInfoLength(
1003 color_profile)));
1004}

◆ identifyType()

Magick::ImageType Magick::Image::identifyType ( void ) const

Definition at line 3354 of file Image.cpp.

3355{
3356 ImageType
3357 image_type;
3358
3359 GetPPException;
3360 image_type=IdentifyImageType(constImage(),exceptionInfo);
3361 ThrowImageException;
3362 return(image_type);
3363}

◆ image()

MagickCore::Image *& Magick::Image::image ( void )

Definition at line 5021 of file Image.cpp.

5022{
5023 return(_imgRef->image());
5024}

◆ imageInfo()

MagickCore::ImageInfo * Magick::Image::imageInfo ( void )

Definition at line 5031 of file Image.cpp.

5032{
5033 return(_imgRef->options()->imageInfo());
5034}

◆ implode()

void Magick::Image::implode ( const double factor_)

Definition at line 3365 of file Image.cpp.

3366{
3367 MagickCore::Image
3368 *newImage;
3369
3370 GetPPException;
3371 newImage=ImplodeImage(constImage(),factor_,image()->interpolate,
3372 exceptionInfo);
3373 replaceImage(newImage);
3374 ThrowImageException;
3375}

◆ interlaceType()

Magick::InterlaceType Magick::Image::interlaceType ( void ) const

Definition at line 1013 of file Image.cpp.

1014{
1015 return(constImage()->interlace);
1016}

◆ interpolate() [1/2]

void Magick::Image::interpolate ( const PixelInterpolateMethod interpolate_)

Definition at line 1018 of file Image.cpp.

1019{
1020 modifyImage();
1021 image()->interpolate=interpolate_;
1022}

◆ interpolate() [2/2]

Magick::PixelInterpolateMethod Magick::Image::interpolate ( void ) const

Definition at line 1024 of file Image.cpp.

1025{
1026 return constImage()->interpolate;
1027}

◆ inverseFourierTransform() [1/2]

void Magick::Image::inverseFourierTransform ( const Image & phase_)

Definition at line 3377 of file Image.cpp.

3378{
3379 inverseFourierTransform(phase_,true);
3380}

◆ inverseFourierTransform() [2/2]

void Magick::Image::inverseFourierTransform ( const Image & phase_,
const bool magnitude_ )

Definition at line 3382 of file Image.cpp.

3384{
3385 MagickCore::Image
3386 *newImage;
3387
3388 GetPPException;
3389 newImage=InverseFourierTransformImage(constImage(),phase_.constImage(),
3390 magnitude_ == true ? MagickTrue : MagickFalse,exceptionInfo);
3391 replaceImage(newImage);
3392 ThrowImageException;
3393}

◆ iptcProfile() [1/2]

void Magick::Image::iptcProfile ( const Blob & iptcProfile_)

Definition at line 1029 of file Image.cpp.

1030{
1031 modifyImage();
1032 if (iptcProfile_.data() != 0)
1033 {
1034 StringInfo
1035 *iptc_profile;
1036
1037 iptc_profile=AcquireStringInfo(iptcProfile_.length());
1038 SetStringInfoDatum(iptc_profile,(unsigned char *) iptcProfile_.data());
1039 GetPPException;
1040 (void) SetImageProfile(image(),"iptc",iptc_profile,exceptionInfo);
1041 iptc_profile=DestroyStringInfo(iptc_profile);
1042 ThrowImageException;
1043 }
1044}

◆ iptcProfile() [2/2]

Magick::Blob Magick::Image::iptcProfile ( void ) const

Definition at line 1046 of file Image.cpp.

1047{
1048 const StringInfo
1049 *iptc_profile;
1050
1051 iptc_profile=GetImageProfile(constImage(),"iptc");
1052 if (iptc_profile == (StringInfo *) NULL)
1053 return(Blob());
1054 return(Blob(GetStringInfoDatum(iptc_profile),GetStringInfoLength(
1055 iptc_profile)));
1056}

◆ isOpaque()

bool Magick::Image::isOpaque ( void ) const

Definition at line 1058 of file Image.cpp.

1059{
1060 MagickBooleanType
1061 result;
1062
1063 GetPPException;
1064 result=IsImageOpaque(constImage(),exceptionInfo);
1065 ThrowImageException;
1066 return(result != MagickFalse ? true : false);
1067}

◆ isValid() [1/2]

void Magick::Image::isValid ( const bool isValid_)

Definition at line 1069 of file Image.cpp.

1070{
1071 if (!isValid_)
1072 {
1073 delete _imgRef;
1074 _imgRef=new ImageRef;
1075 }
1076 else if (!isValid())
1077 {
1078 // Construct with single-pixel black image to make
1079 // image valid. This is an obvious hack.
1080 size(Geometry(1,1));
1081 read("xc:black");
1082 }
1083}

◆ isValid() [2/2]

bool Magick::Image::isValid ( void ) const

Definition at line 1085 of file Image.cpp.

1086{
1087 return rows() && columns();
1088}

◆ kuwahara()

void Magick::Image::kuwahara ( const double radius_ = 0.0,
const double sigma_ = 1.0 )

Definition at line 3395 of file Image.cpp.

3396{
3397 MagickCore::Image
3398 *newImage;
3399
3400 GetPPException;
3401 newImage=KuwaharaImage(constImage(),radius_,sigma_,exceptionInfo);
3402 replaceImage(newImage);
3403 ThrowImageException;
3404}

◆ kuwaharaChannel()

void Magick::Image::kuwaharaChannel ( const ChannelType channel_,
const double radius_ = 0.0,
const double sigma_ = 1.0 )

Definition at line 3406 of file Image.cpp.

3408{
3409 MagickCore::Image
3410 *newImage;
3411
3412 GetPPException;
3413 GetAndSetPPChannelMask(channel_);
3414 newImage=KuwaharaImage(constImage(),radius_,sigma_,exceptionInfo);
3415 replaceImage(newImage);
3416 RestorePPChannelMask;
3417 ThrowImageException;
3418}

◆ label() [1/2]

void Magick::Image::label ( const std::string & label_)

Definition at line 1090 of file Image.cpp.

1091{
1092 modifyImage();
1093 GetPPException;
1094 (void) SetImageProperty(image(),"Label",NULL,exceptionInfo);
1095 if (label_.length() > 0)
1096 (void) SetImageProperty(image(),"Label",label_.c_str(),exceptionInfo);
1097 ThrowImageException;
1098}

◆ label() [2/2]

std::string Magick::Image::label ( void ) const

Definition at line 1100 of file Image.cpp.

1101{
1102 const char
1103 *value;
1104
1105 GetPPException;
1106 value=GetImageProperty(constImage(),"Label",exceptionInfo);
1107 ThrowImageException;
1108
1109 if (value)
1110 return(std::string(value));
1111
1112 return(std::string());
1113}

◆ level()

void Magick::Image::level ( const double blackPoint_,
const double whitePoint_,
const double gamma_ = 1.0 )

Definition at line 3420 of file Image.cpp.

3422{
3423 modifyImage();
3424 GetPPException;
3425 (void) LevelImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
3426 ThrowImageException;
3427}

◆ levelChannel()

void Magick::Image::levelChannel ( const ChannelType channel_,
const double blackPoint_,
const double whitePoint_,
const double gamma_ = 1.0 )

Definition at line 3429 of file Image.cpp.

3431{
3432 modifyImage();
3433 GetPPException;
3434 GetAndSetPPChannelMask(channel_);
3435 (void) LevelImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
3436 RestorePPChannelMask;
3437 ThrowImageException;
3438}

◆ levelColors()

void Magick::Image::levelColors ( const Color & blackColor_,
const Color & whiteColor_,
const bool invert_ = true )

Definition at line 3440 of file Image.cpp.

3442{
3443 PixelInfo
3444 black,
3445 white;
3446
3447 modifyImage();
3448
3449 black=static_cast<PixelInfo>(blackColor_);
3450 white=static_cast<PixelInfo>(whiteColor_);
3451 GetPPException;
3452 (void) LevelImageColors(image(),&black,&white,invert_ == true ?
3453 MagickTrue : MagickFalse,exceptionInfo);
3454 ThrowImageException;
3455}

◆ levelColorsChannel()

void Magick::Image::levelColorsChannel ( const ChannelType channel_,
const Color & blackColor_,
const Color & whiteColor_,
const bool invert_ = true )

Definition at line 3457 of file Image.cpp.

3459{
3460 PixelInfo
3461 black,
3462 white;
3463
3464 modifyImage();
3465
3466 black=static_cast<PixelInfo>(blackColor_);
3467 white=static_cast<PixelInfo>(whiteColor_);
3468 GetPPException;
3469 GetAndSetPPChannelMask(channel_);
3470 (void) LevelImageColors(image(),&black,&white,invert_ == true ?
3471 MagickTrue : MagickFalse,exceptionInfo);
3472 RestorePPChannelMask;
3473 ThrowImageException;
3474}

◆ levelize()

void Magick::Image::levelize ( const double blackPoint_,
const double whitePoint_,
const double gamma_ = 1.0 )

Definition at line 3476 of file Image.cpp.

3478{
3479 modifyImage();
3480 GetPPException;
3481 (void) LevelizeImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
3482 ThrowImageException;
3483}

◆ levelizeChannel()

void Magick::Image::levelizeChannel ( const ChannelType channel_,
const double blackPoint_,
const double whitePoint_,
const double gamma_ = 1.0 )

Definition at line 3485 of file Image.cpp.

3487{
3488 modifyImage();
3489 GetPPException;
3490 GetAndSetPPChannelMask(channel_);
3491 (void) LevelizeImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
3492 RestorePPChannelMask;
3493 ThrowImageException;
3494}

◆ linearStretch()

void Magick::Image::linearStretch ( const double blackPoint_,
const double whitePoint_ )

Definition at line 3496 of file Image.cpp.

3498{
3499 modifyImage();
3500 GetPPException;
3501 LinearStretchImage(image(),blackPoint_,whitePoint_,exceptionInfo);
3502 ThrowImageException;
3503}

◆ liquidRescale()

void Magick::Image::liquidRescale ( const Geometry & geometry_)

Definition at line 3505 of file Image.cpp.

3506{
3507 MagickCore::Image
3508 *newImage;
3509
3510 size_t
3511 height=rows(),
3512 width=columns();
3513
3514 ssize_t
3515 x=0,
3516 y=0;
3517
3518 ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
3519 &height);
3520
3521 GetPPException;
3522 newImage=LiquidRescaleImage(image(),width,height,(double) x,(double) y,exceptionInfo);
3523 replaceImage(newImage);
3524 ThrowImageException;
3525}

◆ localContrast()

void Magick::Image::localContrast ( const double radius_,
const double strength_ )

Definition at line 3527 of file Image.cpp.

3528{
3529 MagickCore::Image
3530 *newImage;
3531
3532 GetPPException;
3533 newImage=LocalContrastImage(constImage(),radius_,strength_,exceptionInfo);
3534 replaceImage(newImage);
3535 ThrowImageException;
3536}

◆ localContrastChannel()

void Magick::Image::localContrastChannel ( const ChannelType channel_,
const double radius_,
const double strength_ )

Definition at line 3538 of file Image.cpp.

3540{
3541 MagickCore::Image
3542 *newImage;
3543
3544 GetPPException;
3545 GetAndSetPPChannelMask(channel_);
3546 newImage=LocalContrastImage(constImage(),radius_,strength_,exceptionInfo);
3547 RestorePPChannelMask;
3548 replaceImage(newImage);
3549 ThrowImageException;
3550}

◆ lowlightColor()

void Magick::Image::lowlightColor ( const Color color_)

Definition at line 1115 of file Image.cpp.

1116{
1117 std::string
1118 value;
1119
1120 value=color_;
1121 artifact("compare:lowlight-color",value);
1122}

◆ magick() [1/2]

void Magick::Image::magick ( const std::string & magick_)

Definition at line 1124 of file Image.cpp.

1125{
1126 size_t
1127 length;
1128
1129 modifyImage();
1130
1131 length=sizeof(image()->magick)-1;
1132 if (magick_.length() < length)
1133 length=magick_.length();
1134
1135 if (!magick_.empty())
1136 magick_.copy(image()->magick,length);
1137 image()->magick[length]=0;
1138
1139 options()->magick(magick_);
1140}

◆ magick() [2/2]

std::string Magick::Image::magick ( void ) const

Definition at line 1142 of file Image.cpp.

1143{
1144 if (*(constImage()->magick) != '\0')
1145 return(std::string(constImage()->magick));
1146
1147 return(constOptions()->magick());
1148}

◆ magnify()

void Magick::Image::magnify ( void )

Definition at line 3552 of file Image.cpp.

3553{
3554 MagickCore::Image
3555 *newImage;
3556
3557 GetPPException;
3558 newImage=MagnifyImage(constImage(),exceptionInfo);
3559 replaceImage(newImage);
3560 ThrowImageException;
3561}

◆ map() [1/2]

void Magick::Image::map ( const Image & mapImage_,
const bool dither_ = false )

Definition at line 3563 of file Image.cpp.

3564{
3565 map(mapImage_, dither_ ? RiemersmaDitherMethod : NoDitherMethod);
3566}

◆ map() [2/2]

void Magick::Image::map ( const Image & mapImage_,
const DitherMethod ditherMethod_ )

Definition at line 3568 of file Image.cpp.

3569{
3570 modifyImage();
3571 GetPPException;
3572 options()->quantizeDither(ditherMethod_);
3573 RemapImage(options()->quantizeInfo(),image(),mapImage_.constImage(),
3574 exceptionInfo);
3575 ThrowImageException;
3576}

◆ mask() [1/2]

void Magick::Image::mask ( const Image & mask_,
const PixelMask type )
private

Definition at line 5157 of file Image.cpp.

5158{
5159 modifyImage();
5160
5161 GetPPException;
5162 if (mask_.isValid())
5163 SetImageMask(image(),type,mask_.constImage(),exceptionInfo);
5164 else
5165 SetImageMask(image(),type,(MagickCore::Image *) NULL,exceptionInfo);
5166 ThrowImageException;
5167}

◆ mask() [2/2]

Magick::Image Magick::Image::mask ( const PixelMask type) const
private

Definition at line 5169 of file Image.cpp.

5170{
5171 MagickCore::Image
5172 *image;
5173
5174 GetPPException;
5175 image = GetImageMask(constImage(),type,exceptionInfo);
5176 ThrowImageException;
5177
5178 if (image == (MagickCore::Image *) NULL)
5179 return(Magick::Image());
5180 else
5181 return(Magick::Image(image));
5182}

◆ masklightColor()

void Magick::Image::masklightColor ( const Color color_)

Definition at line 1150 of file Image.cpp.

1151{
1152 std::string
1153 value;
1154
1155 value=color_;
1156 artifact("compare:masklight-color",value);
1157}

◆ matteColor() [1/2]

void Magick::Image::matteColor ( const Color & matteColor_)

Definition at line 324 of file Image.cpp.

325{
326 modifyImage();
327
328 if (matteColor_.isValid())
329 {
330 image()->matte_color=matteColor_;
331 options()->matteColor(matteColor_);
332 }
333 else
334 {
335 // Set to default matte color
336 Color tmpColor("#BDBDBD");
337 image()->matte_color=tmpColor;
338 options()->matteColor(tmpColor);
339 }
340}

◆ matteColor() [2/2]

Magick::Color Magick::Image::matteColor ( void ) const

Definition at line 342 of file Image.cpp.

343{
344 return(Color(constImage()->matte_color));
345}

◆ meanErrorPerPixel()

double Magick::Image::meanErrorPerPixel ( void ) const

Definition at line 1159 of file Image.cpp.

1160{
1161 return(constImage()->error.mean_error_per_pixel);
1162}

◆ meanShift()

void Magick::Image::meanShift ( const size_t width_,
const size_t height_,
const double color_distance_ )

Definition at line 3578 of file Image.cpp.

3580{
3581 MagickCore::Image
3582 *newImage;
3583
3584 GetPPException;
3585 newImage=MeanShiftImage(constImage(),width_,height_,color_distance_,
3586 exceptionInfo);
3587 replaceImage(newImage);
3588 ThrowImageException;
3589}

◆ medianFilter()

void Magick::Image::medianFilter ( const double radius_ = 0.0)

Definition at line 3591 of file Image.cpp.

3592{
3593 MagickCore::Image
3594 *newImage;
3595
3596 GetPPException;
3597 newImage=StatisticImage(image(),MedianStatistic,(size_t) radius_,
3598 (size_t) radius_,exceptionInfo);
3599 replaceImage(newImage);
3600 ThrowImageException;
3601}

◆ minify()

void Magick::Image::minify ( void )

Definition at line 3603 of file Image.cpp.

3604{
3605 MagickCore::Image
3606 *newImage;
3607
3608 GetPPException;
3609 newImage=MinifyImage(constImage(),exceptionInfo);
3610 replaceImage(newImage);
3611 ThrowImageException;
3612}

◆ modifyImage()

void Magick::Image::modifyImage ( void )

Definition at line 5061 of file Image.cpp.

5062{
5063 if (!_imgRef->isShared())
5064 return;
5065
5066 GetPPException;
5067 replaceImage(CloneImage(image(),0,0,MagickTrue,exceptionInfo));
5068 ThrowImageException;
5069}

◆ modulate()

void Magick::Image::modulate ( const double brightness_,
const double saturation_,
const double hue_ )

Definition at line 3614 of file Image.cpp.

3616{
3617 char
3618 modulate[MagickPathExtent + 1];
3619
3620 FormatLocaleString(modulate,MagickPathExtent,"%3.6f,%3.6f,%3.6f",brightness_,
3621 saturation_,hue_);
3622
3623 modifyImage();
3624 GetPPException;
3625 ModulateImage(image(),modulate,exceptionInfo);
3626 ThrowImageException;
3627}

◆ modulusDepth() [1/2]

void Magick::Image::modulusDepth ( const size_t modulusDepth_)

Definition at line 1164 of file Image.cpp.

1165{
1166 modifyImage();
1167 GetPPException;
1168 SetImageDepth(image(),depth_,exceptionInfo);
1169 ThrowImageException;
1170 options()->depth(depth_);
1171}

◆ modulusDepth() [2/2]

size_t Magick::Image::modulusDepth ( void ) const

Definition at line 1173 of file Image.cpp.

1174{
1175 size_t
1176 depth;
1177
1178 GetPPException;
1179 depth=GetImageDepth(constImage(),exceptionInfo);
1180 ThrowImageException;
1181 return(depth);
1182}

◆ moments()

Magick::ImageMoments Magick::Image::moments ( void ) const

Definition at line 3629 of file Image.cpp.

3630{
3631 return(ImageMoments(*this));
3632}

◆ monochrome() [1/2]

void Magick::Image::monochrome ( const bool monochromeFlag_)

Definition at line 1184 of file Image.cpp.

1185{
1186 modifyImage();
1187 options()->monochrome(monochromeFlag_);
1188}

◆ monochrome() [2/2]

bool Magick::Image::monochrome ( void ) const

Definition at line 1190 of file Image.cpp.

1191{
1192 return(constOptions()->monochrome());
1193}

◆ montageGeometry()

Magick::Geometry Magick::Image::montageGeometry ( void ) const

Definition at line 1195 of file Image.cpp.

1196{
1197 if (constImage()->montage)
1198 return Magick::Geometry(constImage()->montage);
1199
1200 if (!quiet())
1201 throwExceptionExplicit(MagickCore::CorruptImageWarning,
1202 "Image does not contain a montage");
1203
1204 return(Magick::Geometry());
1205}

◆ morphology() [1/2]

void Magick::Image::morphology ( const MorphologyMethod method_,
const KernelInfoType kernel_,
const std::string arguments_,
const ssize_t iterations_ = 1 )

Definition at line 3654 of file Image.cpp.

3657{
3658 const char
3659 *option;
3660
3661 std::string
3662 kernel;
3663
3664 option=CommandOptionToMnemonic(MagickKernelOptions,kernel_);
3665 if (option == (const char *)NULL)
3666 {
3667 throwExceptionExplicit(MagickCore::OptionError,
3668 "Unable to determine kernel type.");
3669 return;
3670 }
3671 kernel=std::string(option);
3672 if (!arguments_.empty())
3673 kernel+=":"+arguments_;
3674
3675 morphology(method_,kernel,iterations_);
3676}

◆ morphology() [2/2]

void Magick::Image::morphology ( const MorphologyMethod method_,
const std::string kernel_,
const ssize_t iterations_ = 1 )

Definition at line 3634 of file Image.cpp.

3636{
3637 KernelInfo
3638 *kernel;
3639
3640 MagickCore::Image
3641 *newImage;
3642
3643 GetPPException;
3644 kernel=AcquireKernelInfo(kernel_.c_str(),exceptionInfo);
3645 if (kernel == (KernelInfo *) NULL)
3646 throwExceptionExplicit(MagickCore::OptionError,"Unable to parse kernel.");
3647 newImage=MorphologyImage(constImage(),method_,iterations_,kernel,
3648 exceptionInfo);
3649 replaceImage(newImage);
3650 kernel=DestroyKernelInfo(kernel);
3651 ThrowImageException;
3652}

◆ morphologyChannel() [1/2]

void Magick::Image::morphologyChannel ( const ChannelType channel_,
const MorphologyMethod method_,
const KernelInfoType kernel_,
const std::string arguments_,
const ssize_t iterations_ = 1 )

Definition at line 3706 of file Image.cpp.

3709{
3710 const char
3711 *option;
3712
3713 std::string
3714 kernel;
3715
3716 option=CommandOptionToMnemonic(MagickKernelOptions,kernel_);
3717 if (option == (const char *)NULL)
3718 {
3719 throwExceptionExplicit(MagickCore::OptionError,
3720 "Unable to determine kernel type.");
3721 return;
3722 }
3723
3724 kernel=std::string(option);
3725 if (!arguments_.empty())
3726 kernel+=":"+arguments_;
3727
3728 morphologyChannel(channel_,method_,kernel,iterations_);
3729}

◆ morphologyChannel() [2/2]

void Magick::Image::morphologyChannel ( const ChannelType channel_,
const MorphologyMethod method_,
const std::string kernel_,
const ssize_t iterations_ = 1 )

Definition at line 3678 of file Image.cpp.

3681{
3682 KernelInfo
3683 *kernel;
3684
3685 MagickCore::Image
3686 *newImage;
3687
3688
3689 GetPPException;
3690 kernel=AcquireKernelInfo(kernel_.c_str(),exceptionInfo);
3691 if (kernel == (KernelInfo *)NULL)
3692 {
3693 throwExceptionExplicit(MagickCore::OptionError,
3694 "Unable to parse kernel.");
3695 return;
3696 }
3697 GetAndSetPPChannelMask(channel_);
3698 newImage=MorphologyImage(constImage(),method_,iterations_,kernel,
3699 exceptionInfo);
3700 RestorePPChannelMask;
3701 replaceImage(newImage);
3702 kernel=DestroyKernelInfo(kernel);
3703 ThrowImageException;
3704}

◆ motionBlur()

void Magick::Image::motionBlur ( const double radius_,
const double sigma_,
const double angle_ )

Definition at line 3731 of file Image.cpp.

3733{
3734 MagickCore::Image
3735 *newImage;
3736
3737 GetPPException;
3738 newImage=MotionBlurImage(constImage(),radius_,sigma_,angle_,exceptionInfo);
3739 replaceImage(newImage);
3740 ThrowImageException;
3741}

◆ negate()

void Magick::Image::negate ( const bool grayscale_ = false)

Definition at line 3743 of file Image.cpp.

3744{
3745 modifyImage();
3746 GetPPException;
3747 NegateImage(image(),(MagickBooleanType) grayscale_,exceptionInfo);
3748 ThrowImageException;
3749}

◆ negateChannel()

void Magick::Image::negateChannel ( const ChannelType channel_,
const bool grayscale_ = false )

Definition at line 3751 of file Image.cpp.

3753{
3754 modifyImage();
3755 GetPPException;
3756 GetAndSetPPChannelMask(channel_);
3757 NegateImage(image(),(MagickBooleanType) grayscale_,exceptionInfo);
3758 RestorePPChannelMask;
3759 ThrowImageException;
3760}

◆ normalize()

void Magick::Image::normalize ( void )

Definition at line 3762 of file Image.cpp.

3763{
3764 modifyImage();
3765 GetPPException;
3766 NormalizeImage(image(),exceptionInfo);
3767 ThrowImageException;
3768}

◆ normalizedMaxError()

double Magick::Image::normalizedMaxError ( void ) const

Definition at line 1207 of file Image.cpp.

1208{
1209 return(constImage()->error.normalized_maximum_error);
1210}

◆ normalizedMeanError()

double Magick::Image::normalizedMeanError ( void ) const

Definition at line 1212 of file Image.cpp.

1213{
1214 return(constImage()->error.normalized_mean_error);
1215}

◆ oilPaint()

void Magick::Image::oilPaint ( const double radius_ = 0.0,
const double sigma = 1.0 )

Definition at line 3770 of file Image.cpp.

3771{
3772 MagickCore::Image
3773 *newImage;
3774
3775 GetPPException;
3776 newImage=OilPaintImage(constImage(),radius_,sigma_,exceptionInfo);
3777 replaceImage(newImage);
3778 ThrowImageException;
3779}

◆ opaque()

void Magick::Image::opaque ( const Color & opaqueColor_,
const Color & penColor_,
const bool invert_ = false )

Definition at line 3781 of file Image.cpp.

3783{
3784 std::string
3785 opaqueColor,
3786 penColor;
3787
3788 PixelInfo
3789 opaque,
3790 pen;
3791
3792 if (!opaqueColor_.isValid())
3793 throwExceptionExplicit(MagickCore::OptionError,
3794 "Opaque color argument is invalid");
3795
3796 if (!penColor_.isValid())
3797 throwExceptionExplicit(MagickCore::OptionError,
3798 "Pen color argument is invalid");
3799
3800 modifyImage();
3801 opaqueColor=opaqueColor_;
3802 penColor=penColor_;
3803
3804 GetPPException;
3805 (void) QueryColorCompliance(opaqueColor.c_str(),AllCompliance,&opaque,
3806 exceptionInfo);
3807 (void) QueryColorCompliance(penColor.c_str(),AllCompliance,&pen,
3808 exceptionInfo);
3809 OpaquePaintImage(image(),&opaque,&pen,invert_ ? MagickTrue : MagickFalse,
3810 exceptionInfo);
3811 ThrowImageException;
3812}

◆ operator=()

Magick::Image & Magick::Image::operator= ( const Image & image_)

Definition at line 275 of file Image.cpp.

276{
277 if (this != &image_)
278 {
279 image_._imgRef->increase();
280 if (_imgRef->decrease() == 0)
281 delete _imgRef;
282
283 // Use new image reference
284 _imgRef=image_._imgRef;
285 }
286 return(*this);
287}

◆ options()

Magick::Options * Magick::Image::options ( void )

Definition at line 5041 of file Image.cpp.

5042{
5043 return(_imgRef->options());
5044}

◆ orderedDither()

void Magick::Image::orderedDither ( std::string thresholdMap_)

Definition at line 3814 of file Image.cpp.

3815{
3816 modifyImage();
3817 GetPPException;
3818 (void) OrderedDitherImage(image(),thresholdMap_.c_str(),exceptionInfo);
3819 ThrowImageException;
3820}

◆ orderedDitherChannel()

void Magick::Image::orderedDitherChannel ( const ChannelType channel_,
std::string thresholdMap_ )

Definition at line 3822 of file Image.cpp.

3824{
3825 modifyImage();
3826 GetPPException;
3827 GetAndSetPPChannelMask(channel_);
3828 (void)OrderedDitherImage(image(),thresholdMap_.c_str(),exceptionInfo);
3829 RestorePPChannelMask;
3830 ThrowImageException;
3831}

◆ orientation()

Magick::OrientationType Magick::Image::orientation ( void ) const

Definition at line 1223 of file Image.cpp.

1224{
1225 return(constImage()->orientation);
1226}

◆ page() [1/2]

void Magick::Image::page ( const Geometry & pageSize_)

Definition at line 1228 of file Image.cpp.

1229{
1230 modifyImage();
1231 options()->page(pageSize_);
1232 image()->page=pageSize_;
1233}

◆ page() [2/2]

Magick::Geometry Magick::Image::page ( void ) const

Definition at line 1235 of file Image.cpp.

1236{
1237 return(Geometry(constImage()->page.width,constImage()->page.height,
1238 constImage()->page.x,constImage()->page.y));
1239}

◆ perceptible()

void Magick::Image::perceptible ( const double epsilon_)

Definition at line 3833 of file Image.cpp.

3834{
3835 modifyImage();
3836 GetPPException;
3837 PerceptibleImage(image(),epsilon_,exceptionInfo);
3838 ThrowImageException;
3839}

◆ perceptibleChannel()

void Magick::Image::perceptibleChannel ( const ChannelType channel_,
const double epsilon_ )

Definition at line 3841 of file Image.cpp.

3843{
3844 modifyImage();
3845 GetPPException;
3846 GetAndSetPPChannelMask(channel_);
3847 PerceptibleImage(image(),epsilon_,exceptionInfo);
3848 RestorePPChannelMask;
3849 ThrowImageException;
3850}

◆ perceptualHash()

Magick::ImagePerceptualHash Magick::Image::perceptualHash ( ) const

Definition at line 3852 of file Image.cpp.

3853{
3854 return(ImagePerceptualHash(*this));
3855}

◆ ping() [1/2]

void Magick::Image::ping ( const Blob & blob_)

Definition at line 3868 of file Image.cpp.

3869{
3870 MagickCore::Image
3871 *newImage;
3872
3873 GetPPException;
3874 newImage=PingBlob(imageInfo(),blob_.data(),blob_.length(),exceptionInfo);
3875 read(newImage,exceptionInfo);
3876}

◆ ping() [2/2]

void Magick::Image::ping ( const std::string & imageSpec_)

Definition at line 3857 of file Image.cpp.

3858{
3859 MagickCore::Image
3860 *newImage;
3861
3862 GetPPException;
3863 options()->fileName(imageSpec_);
3864 newImage=PingImage(imageInfo(),exceptionInfo);
3865 read(newImage,exceptionInfo);
3866}

◆ polaroid()

void Magick::Image::polaroid ( const std::string & caption_,
const double angle_,
const PixelInterpolateMethod method_ )

Definition at line 3926 of file Image.cpp.

3928{
3929 MagickCore::Image
3930 *newImage;
3931
3932 GetPPException;
3933 newImage=PolaroidImage(constImage(),options()->drawInfo(),caption_.c_str(),
3934 angle_,method_,exceptionInfo);
3935 replaceImage(newImage);
3936 ThrowImageException;
3937}

◆ posterize()

void Magick::Image::posterize ( const size_t levels_,
const DitherMethod method_ )

Definition at line 3939 of file Image.cpp.

3940{
3941 modifyImage();
3942 GetPPException;
3943 PosterizeImage(image(),levels_,method_,exceptionInfo);
3944 ThrowImageException;
3945}

◆ posterizeChannel()

void Magick::Image::posterizeChannel ( const ChannelType channel_,
const size_t levels_,
const DitherMethod method_ )

Definition at line 3947 of file Image.cpp.

3949{
3950 modifyImage();
3951 GetPPException;
3952 GetAndSetPPChannelMask(channel_);
3953 PosterizeImage(image(),levels_,method_,exceptionInfo);
3954 RestorePPChannelMask;
3955 ThrowImageException;
3956}

◆ process()

void Magick::Image::process ( std::string name_,
const ::ssize_t argc_,
const char ** argv_ )

Definition at line 3958 of file Image.cpp.

3960{
3961 modifyImage();
3962
3963 GetPPException;
3964 (void) InvokeDynamicImageFilter(name_.c_str(),&image(),(int) argc,argv,
3965 exceptionInfo);
3966 ThrowImageException;
3967}

◆ profile() [1/2]

Magick::Blob Magick::Image::profile ( const std::string name_) const

Definition at line 3979 of file Image.cpp.

3980{
3981 const StringInfo
3982 *profile;
3983
3984 profile=GetImageProfile(constImage(),name_.c_str());
3985
3986 if (profile == (StringInfo *) NULL)
3987 return(Blob());
3988 return(Blob((void*) GetStringInfoDatum(profile),GetStringInfoLength(
3989 profile)));
3990}

◆ profile() [2/2]

void Magick::Image::profile ( const std::string name_,
const Blob & colorProfile_ )

Definition at line 3969 of file Image.cpp.

3971{
3972 modifyImage();
3973 GetPPException;
3974 (void) ProfileImage(image(),name_.c_str(),(unsigned char *)profile_.data(),
3975 profile_.length(),exceptionInfo);
3976 ThrowImageException;
3977}

◆ quality() [1/2]

void Magick::Image::quality ( const size_t quality_)

Definition at line 1241 of file Image.cpp.

1242{
1243 modifyImage();
1244 image()->quality=quality_;
1245 options()->quality(quality_);
1246}

◆ quality() [2/2]

size_t Magick::Image::quality ( void ) const

Definition at line 1248 of file Image.cpp.

1249{
1250 return(constImage()->quality);
1251}

◆ quantize()

void Magick::Image::quantize ( const bool measureError_ = false)

Definition at line 3992 of file Image.cpp.

3993{
3994 modifyImage();
3995
3996 if (measureError_)
3997 options()->quantizeInfo()->measure_error=MagickTrue;
3998 else
3999 options()->quantizeInfo()->measure_error=MagickFalse;
4000
4001 GetPPException;
4002 QuantizeImage(options()->quantizeInfo(),image(),exceptionInfo);
4003 ThrowImageException;
4004}

◆ quantizeColors() [1/2]

void Magick::Image::quantizeColors ( const size_t colors_)

Definition at line 1253 of file Image.cpp.

1254{
1255 modifyImage();
1256 options()->quantizeColors(colors_);
1257}

◆ quantizeColors() [2/2]

size_t Magick::Image::quantizeColors ( void ) const

Definition at line 1259 of file Image.cpp.

1260{
1261 return(constOptions()->quantizeColors());
1262}

◆ quantizeColorSpace()

Magick::ColorspaceType Magick::Image::quantizeColorSpace ( void ) const

Definition at line 1271 of file Image.cpp.

1272{
1273 return(constOptions()->quantizeColorSpace());
1274}

◆ quantizeDither() [1/2]

void Magick::Image::quantizeDither ( const bool ditherFlag_)

Definition at line 1276 of file Image.cpp.

1277{
1278 modifyImage();
1279 options()->quantizeDither(ditherFlag_);
1280}

◆ quantizeDither() [2/2]

bool Magick::Image::quantizeDither ( void ) const

Definition at line 1282 of file Image.cpp.

1283{
1284 return(constOptions()->quantizeDither());
1285}

◆ quantizeDitherMethod() [1/2]

void Magick::Image::quantizeDitherMethod ( const DitherMethod ditherMethod_)

Definition at line 1287 of file Image.cpp.

1288{
1289 modifyImage();
1290 options()->quantizeDitherMethod(ditherMethod_);
1291}

◆ quantizeDitherMethod() [2/2]

MagickCore::DitherMethod Magick::Image::quantizeDitherMethod ( void ) const

Definition at line 1293 of file Image.cpp.

1294{
1295 return(constOptions()->quantizeDitherMethod());
1296}

◆ quantizeInfo()

MagickCore::QuantizeInfo * Magick::Image::quantizeInfo ( void )

Definition at line 5051 of file Image.cpp.

5052{
5053 return(_imgRef->options()->quantizeInfo());
5054}

◆ quantizeTreeDepth() [1/2]

void Magick::Image::quantizeTreeDepth ( const size_t treeDepth_)

Definition at line 1298 of file Image.cpp.

1299{
1300 modifyImage();
1301 options()->quantizeTreeDepth(treeDepth_);
1302}

◆ quantizeTreeDepth() [2/2]

size_t Magick::Image::quantizeTreeDepth ( void ) const

Definition at line 1304 of file Image.cpp.

1305{
1306 return(constOptions()->quantizeTreeDepth());
1307}

◆ quiet() [1/2]

void Magick::Image::quiet ( const bool quiet_)

Definition at line 1309 of file Image.cpp.

1310{
1311 modifyImage();
1312 options()->quiet(quiet_);
1313}

◆ quiet() [2/2]

bool Magick::Image::quiet ( void ) const

Definition at line 1315 of file Image.cpp.

1316{
1317 return(constOptions()->quiet());
1318}

◆ raise()

void Magick::Image::raise ( const Geometry & geometry_ = raiseGeometryDefault,
const bool raisedFlag_ = false )

Definition at line 4006 of file Image.cpp.

4007{
4008 RectangleInfo
4009 raiseInfo=geometry_;
4010
4011 GetPPException;
4012 modifyImage();
4013 RaiseImage(image(),&raiseInfo,raisedFlag_ == true ? MagickTrue : MagickFalse,
4014 exceptionInfo);
4015 ThrowImageException;
4016}

◆ randomThreshold()

void Magick::Image::randomThreshold ( const double low_,
const double high_ )

Definition at line 4018 of file Image.cpp.

4019{
4020 GetPPException;
4021 (void) RandomThresholdImage(image(),low_,high_,exceptionInfo);
4022 ThrowImageException;
4023}

◆ randomThresholdChannel()

void Magick::Image::randomThresholdChannel ( const ChannelType channel_,
const double low_,
const double high_ )

Definition at line 4025 of file Image.cpp.

4027{
4028 modifyImage();
4029 GetPPException;
4030 GetAndSetPPChannelMask(channel_);
4031 (void) RandomThresholdImage(image(),low_,high_,exceptionInfo);
4032 RestorePPChannelMask;
4033 ThrowImageException;
4034}

◆ read() [1/9]

void Magick::Image::read ( const Blob & blob_)

Definition at line 4036 of file Image.cpp.

4037{
4038 MagickCore::Image
4039 *newImage;
4040
4041 GetPPException;
4042 newImage=BlobToImage(imageInfo(),static_cast<const void *>(blob_.data()),
4043 blob_.length(),exceptionInfo);
4044 read(newImage,exceptionInfo);
4045}

◆ read() [2/9]

void Magick::Image::read ( const Blob & blob_,
const Geometry & size_ )

Definition at line 4047 of file Image.cpp.

4048{
4049 size(size_);
4050 read(blob_);
4051}

◆ read() [3/9]

void Magick::Image::read ( const Blob & blob_,
const Geometry & size_,
const size_t depth_ )

Definition at line 4053 of file Image.cpp.

4055{
4056 size(size_);
4057 depth(depth_);
4058 read(blob_);
4059}

◆ read() [4/9]

void Magick::Image::read ( const Blob & blob_,
const Geometry & size_,
const size_t depth_,
const std::string & magick_ )

Definition at line 4061 of file Image.cpp.

4063{
4064 size(size_);
4065 depth(depth_);
4066 magick(magick_);
4067 // Set explicit image format
4068 fileName(magick_ + ':');
4069 read(blob_);
4070}

◆ read() [5/9]

void Magick::Image::read ( const Blob & blob_,
const Geometry & size_,
const std::string & magick_ )

Definition at line 4072 of file Image.cpp.

4074{
4075 size(size_);
4076 magick(magick_);
4077 // Set explicit image format
4078 fileName(magick_ + ':');
4079 read(blob_);
4080}

◆ read() [6/9]

void Magick::Image::read ( const Geometry & size_,
const std::string & imageSpec_ )

Definition at line 4082 of file Image.cpp.

4083{
4084 size(size_);
4085 read(imageSpec_);
4086}

◆ read() [7/9]

void Magick::Image::read ( const size_t width_,
const size_t height_,
const std::string & map_,
const StorageType type_,
const void * pixels_ )

Definition at line 4088 of file Image.cpp.

4090{
4091 MagickCore::Image
4092 *newImage;
4093
4094 GetPPException;
4095 newImage=ConstituteImage(width_,height_,map_.c_str(),type_, pixels_,
4096 exceptionInfo);
4097 replaceImage(newImage);
4098 ThrowImageException;
4099}

◆ read() [8/9]

void Magick::Image::read ( const std::string & imageSpec_)

Definition at line 4101 of file Image.cpp.

4102{
4103 MagickCore::Image
4104 *newImage;
4105
4106 GetPPException;
4107 options()->fileName(imageSpec_);
4108 newImage=ReadImage(imageInfo(),exceptionInfo);
4109 read(newImage,exceptionInfo);
4110}

◆ read() [9/9]

void Magick::Image::read ( MagickCore::Image * image,
MagickCore::ExceptionInfo * exceptionInfo )
private

Definition at line 5089 of file Image.cpp.

5091{
5092 // Ensure that multiple image frames were not read.
5093 if (image != (MagickCore::Image *) NULL &&
5094 image->next != (MagickCore::Image *) NULL)
5095 {
5096 MagickCore::Image
5097 *next;
5098
5099 // Destroy any extra image frames
5100 next=image->next;
5101 image->next=(MagickCore::Image *) NULL;
5102 next->previous=(MagickCore::Image *) NULL;
5103 DestroyImageList(next);
5104 }
5105 replaceImage(image);
5106 if (exceptionInfo->severity == MagickCore::UndefinedException &&
5107 image == (MagickCore::Image *) NULL)
5108 {
5109 (void) MagickCore::DestroyExceptionInfo(exceptionInfo);
5110 if (!quiet())
5111 throwExceptionExplicit(MagickCore::ImageWarning,
5112 "No image was loaded.");
5113 return;
5114 }
5115 ThrowImageException;
5116}

◆ readMask() [1/2]

void Magick::Image::readMask ( const Image & mask_)

Definition at line 4112 of file Image.cpp.

4113{
4114 mask(mask_,ReadPixelMask);
4115}

◆ readMask() [2/2]

Magick::Image Magick::Image::readMask ( void ) const

Definition at line 4117 of file Image.cpp.

4118{
4119 return(mask(ReadPixelMask));
4120}

◆ readPixels()

void Magick::Image::readPixels ( const QuantumType quantum_,
const unsigned char * source_ )

Definition at line 4122 of file Image.cpp.

4124{
4125 QuantumInfo
4126 *quantum_info;
4127
4128 quantum_info=AcquireQuantumInfo(imageInfo(),image());
4129 GetPPException;
4130 ImportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
4131 quantum_,source_,exceptionInfo);
4132 quantum_info=DestroyQuantumInfo(quantum_info);
4133 ThrowImageException;
4134}

◆ reduceNoise() [1/2]

void Magick::Image::reduceNoise ( const size_t order_)

Definition at line 4141 of file Image.cpp.

4142{
4143 MagickCore::Image
4144 *newImage;
4145
4146 GetPPException;
4147 newImage=StatisticImage(constImage(),NonpeakStatistic,order_,
4148 order_,exceptionInfo);
4149 replaceImage(newImage);
4150 ThrowImageException;
4151}

◆ reduceNoise() [2/2]

void Magick::Image::reduceNoise ( void )

Definition at line 4136 of file Image.cpp.

4137{
4138 reduceNoise(3);
4139}

◆ renderingIntent()

Magick::RenderingIntent Magick::Image::renderingIntent ( void ) const

Definition at line 1327 of file Image.cpp.

1328{
1329 return(static_cast<Magick::RenderingIntent>(constImage()->rendering_intent));
1330}

◆ repage()

void Magick::Image::repage ( )

Definition at line 4153 of file Image.cpp.

4154{
4155 modifyImage();
4156 options()->page(Geometry());
4157 image()->page.width = 0;
4158 image()->page.height = 0;
4159 image()->page.x = 0;
4160 image()->page.y = 0;
4161}

◆ replaceImage()

MagickCore::Image * Magick::Image::replaceImage ( MagickCore::Image * replacement_)

Definition at line 5071 of file Image.cpp.

5072{
5073 MagickCore::Image
5074 *image;
5075
5076 if (replacement_)
5077 image=replacement_;
5078 else
5079 {
5080 GetPPException;
5081 image=AcquireImage(constImageInfo(),exceptionInfo);
5082 ThrowImageException;
5083 }
5084
5085 _imgRef=ImageRef::replaceImage(_imgRef,image);
5086 return(image);
5087}

◆ resample()

void Magick::Image::resample ( const Point & density_)

Definition at line 4163 of file Image.cpp.

4164{
4165 MagickCore::Image
4166 *newImage;
4167
4168 GetPPException;
4169 newImage=ResampleImage(constImage(),density_.x(),density_.y(),
4170 image()->filter,exceptionInfo);
4171 replaceImage(newImage);
4172 ThrowImageException;
4173}

◆ resize()

void Magick::Image::resize ( const Geometry & geometry_)

Definition at line 4175 of file Image.cpp.

4176{
4177 MagickCore::Image
4178 *newImage;
4179
4180 size_t
4181 height=rows(),
4182 width=columns();
4183
4184 ssize_t
4185 x=0,
4186 y=0;
4187
4188 // Calculate new size. This code should be supported using binary arguments
4189 // in the ImageMagick library.
4190 ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
4191 &height);
4192
4193 GetPPException;
4194 newImage=ResizeImage(constImage(),width,height,image()->filter,
4195 exceptionInfo);
4196 replaceImage(newImage);
4197 ThrowImageException;
4198}

◆ resolutionUnits()

Magick::ResolutionType Magick::Image::resolutionUnits ( void ) const

Definition at line 1340 of file Image.cpp.

1341{
1342 return(static_cast<Magick::ResolutionType>(constImage()->units));
1343}

◆ roll() [1/2]

void Magick::Image::roll ( const Geometry & roll_)

Definition at line 4200 of file Image.cpp.

4201{
4202 MagickCore::Image
4203 *newImage;
4204
4205 GetPPException;
4206 newImage=RollImage(constImage(),roll_.xOff(),roll_.yOff(),exceptionInfo);
4207 replaceImage(newImage);
4208 ThrowImageException;
4209}

◆ roll() [2/2]

void Magick::Image::roll ( const ssize_t columns_,
const ssize_t rows_ )

Definition at line 4211 of file Image.cpp.

4212{
4213 MagickCore::Image
4214 *newImage;
4215
4216 GetPPException;
4217 newImage=RollImage(constImage(),columns_, rows_,exceptionInfo);
4218 replaceImage(newImage);
4219 ThrowImageException;
4220}

◆ rotate()

void Magick::Image::rotate ( const double degrees_)

Definition at line 4222 of file Image.cpp.

4223{
4224 MagickCore::Image
4225 *newImage;
4226
4227 GetPPException;
4228 newImage=RotateImage(constImage(),degrees_,exceptionInfo);
4229 replaceImage(newImage);
4230 ThrowImageException;
4231}

◆ rotationalBlur()

void Magick::Image::rotationalBlur ( const double angle_)

Definition at line 4233 of file Image.cpp.

4234{
4235 MagickCore::Image
4236 *newImage;
4237
4238 GetPPException;
4239 newImage=RotationalBlurImage(constImage(),angle_,exceptionInfo);
4240 replaceImage(newImage);
4241 ThrowImageException;
4242}

◆ rotationalBlurChannel()

void Magick::Image::rotationalBlurChannel ( const ChannelType channel_,
const double angle_ )

Definition at line 4244 of file Image.cpp.

4246{
4247 MagickCore::Image
4248 *newImage;
4249
4250 GetPPException;
4251 GetAndSetPPChannelMask(channel_);
4252 newImage=RotationalBlurImage(constImage(),angle_,exceptionInfo);
4253 RestorePPChannelMask;
4254 replaceImage(newImage);
4255 ThrowImageException;
4256}

◆ rows()

size_t Magick::Image::rows ( void ) const

Definition at line 1345 of file Image.cpp.

1346{
1347 return(constImage()->rows);
1348}

◆ sample()

void Magick::Image::sample ( const Geometry & geometry_)

Definition at line 4258 of file Image.cpp.

4259{
4260 MagickCore::Image
4261 *newImage;
4262
4263 size_t
4264 height=rows(),
4265 width=columns();
4266
4267 ssize_t
4268 x=0,
4269 y=0;
4270
4271 ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
4272 &height);
4273
4274 GetPPException;
4275 newImage=SampleImage(constImage(),width,height,exceptionInfo);
4276 replaceImage(newImage);
4277 ThrowImageException;
4278}

◆ samplingFactor() [1/2]

void Magick::Image::samplingFactor ( const std::string & samplingFactor_)

Definition at line 1350 of file Image.cpp.

1351{
1352 modifyImage();
1353 options()->samplingFactor(samplingFactor_);
1354}

◆ samplingFactor() [2/2]

std::string Magick::Image::samplingFactor ( void ) const

Definition at line 1356 of file Image.cpp.

1357{
1358 return(constOptions()->samplingFactor());
1359}

◆ scale()

void Magick::Image::scale ( const Geometry & geometry_)

Definition at line 4280 of file Image.cpp.

4281{
4282 MagickCore::Image
4283 *newImage;
4284
4285 size_t
4286 height=rows(),
4287 width=columns();
4288
4289 ssize_t
4290 x=0,
4291 y=0;
4292
4293 ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
4294 &height);
4295
4296 GetPPException;
4297 newImage=ScaleImage(constImage(),width,height,exceptionInfo);
4298 replaceImage(newImage);
4299 ThrowImageException;
4300}

◆ scene() [1/2]

void Magick::Image::scene ( const size_t scene_)

Definition at line 1361 of file Image.cpp.

1362{
1363 modifyImage();
1364 image()->scene=scene_;
1365}

◆ scene() [2/2]

size_t Magick::Image::scene ( void ) const

Definition at line 1367 of file Image.cpp.

1368{
1369 return(constImage()->scene);
1370}

◆ segment()

void Magick::Image::segment ( const double clusterThreshold_ = 1.0,
const double smoothingThreshold_ = 1.5 )

Definition at line 4302 of file Image.cpp.

4304{
4305 modifyImage();
4306 GetPPException;
4307 SegmentImage(image(),options()->quantizeColorSpace(),
4308 (MagickBooleanType) options()->verbose(),clusterThreshold_,
4309 smoothingThreshold_,exceptionInfo);
4310 SyncImage(image(),exceptionInfo);
4311 ThrowImageException;
4312}

◆ selectiveBlur()

void Magick::Image::selectiveBlur ( const double radius_,
const double sigma_,
const double threshold_ )

Definition at line 4314 of file Image.cpp.

4316{
4317 MagickCore::Image
4318 *newImage;
4319
4320 GetPPException;
4321 newImage=SelectiveBlurImage(constImage(),radius_,sigma_,threshold_,
4322 exceptionInfo);
4323 replaceImage(newImage);
4324 ThrowImageException;
4325}

◆ selectiveBlurChannel()

void Magick::Image::selectiveBlurChannel ( const ChannelType channel_,
const double radius_,
const double sigma_,
const double threshold_ )

Definition at line 4327 of file Image.cpp.

4329{
4330 MagickCore::Image
4331 *newImage;
4332
4333 GetPPException;
4334 GetAndSetPPChannelMask(channel_);
4335 newImage=SelectiveBlurImage(constImage(),radius_,sigma_,threshold_,
4336 exceptionInfo);
4337 RestorePPChannelMask;
4338 replaceImage(newImage);
4339 ThrowImageException;
4340}

◆ separate()

Magick::Image Magick::Image::separate ( const ChannelType channel_) const

Definition at line 4342 of file Image.cpp.

4343{
4344 MagickCore::Image
4345 *image;
4346
4347 GetPPException;
4348 image=SeparateImage(constImage(),channel_,exceptionInfo);
4349 ThrowImageException;
4350 if (image == (MagickCore::Image *) NULL)
4351 return(Magick::Image());
4352 else
4353 return(Magick::Image(image));
4354}

◆ sepiaTone()

void Magick::Image::sepiaTone ( const double threshold_)

Definition at line 4356 of file Image.cpp.

4357{
4358 MagickCore::Image
4359 *newImage;
4360
4361 GetPPException;
4362 newImage=SepiaToneImage(constImage(),threshold_,exceptionInfo);
4363 replaceImage(newImage);
4364 ThrowImageException;
4365}

◆ setColorMetric()

bool Magick::Image::setColorMetric ( const Image & reference_)

Definition at line 4367 of file Image.cpp.

4368{
4369 bool
4370 status;
4371
4372 Image
4373 ref=reference_;
4374
4375 GetPPException;
4376 modifyImage();
4377 status=static_cast<bool>(SetImageColorMetric(image(),ref.constImage(),
4378 exceptionInfo));
4379 ThrowImageException;
4380 return(status);
4381}

◆ setPixels()

Magick::Quantum * Magick::Image::setPixels ( const ::ssize_t x_,
const ::ssize_t y_,
const size_t columns_,
const size_t rows_ )

Definition at line 4383 of file Image.cpp.

4385{
4386 Quantum
4387 *result;
4388
4389 modifyImage();
4390 GetPPException;
4391 result=QueueAuthenticPixels(image(),x_,y_,columns_,rows_,exceptionInfo);
4392 ThrowImageException;
4393 return(result);
4394}

◆ shade()

void Magick::Image::shade ( const double azimuth_ = 30,
const double elevation_ = 30,
const bool colorShading_ = false )

Definition at line 4396 of file Image.cpp.

4398{
4399 MagickCore::Image
4400 *newImage;
4401
4402 GetPPException;
4403 newImage=ShadeImage(constImage(),colorShading_ == true ?
4404 MagickTrue : MagickFalse,azimuth_,elevation_,exceptionInfo);
4405 replaceImage(newImage);
4406 ThrowImageException;
4407}

◆ shadow()

void Magick::Image::shadow ( const double percentAlpha_ = 80.0,
const double sigma_ = 0.5,
const ssize_t x_ = 5,
const ssize_t y_ = 5 )

Definition at line 4409 of file Image.cpp.

4411{
4412 MagickCore::Image
4413 *newImage;
4414
4415 GetPPException;
4416 newImage=ShadowImage(constImage(),percent_opacity_, sigma_,x_, y_,
4417 exceptionInfo);
4418 replaceImage(newImage);
4419 ThrowImageException;
4420}

◆ sharpen()

void Magick::Image::sharpen ( const double radius_ = 0.0,
const double sigma_ = 1.0 )

Definition at line 4422 of file Image.cpp.

4423{
4424 MagickCore::Image
4425 *newImage;
4426
4427 GetPPException;
4428 newImage=SharpenImage(constImage(),radius_,sigma_,exceptionInfo);
4429 replaceImage(newImage);
4430 ThrowImageException;
4431}

◆ sharpenChannel()

void Magick::Image::sharpenChannel ( const ChannelType channel_,
const double radius_ = 0.0,
const double sigma_ = 1.0 )

Definition at line 4433 of file Image.cpp.

4435{
4436 MagickCore::Image
4437 *newImage;
4438
4439 GetPPException;
4440 GetAndSetPPChannelMask(channel_);
4441 newImage=SharpenImage(constImage(),radius_,sigma_,exceptionInfo);
4442 RestorePPChannelMask;
4443 replaceImage(newImage);
4444 ThrowImageException;
4445}

◆ shave()

void Magick::Image::shave ( const Geometry & geometry_)

Definition at line 4447 of file Image.cpp.

4448{
4449 MagickCore::Image
4450 *newImage;
4451
4452 RectangleInfo
4453 shaveInfo=geometry_;
4454
4455 GetPPException;
4456 newImage=ShaveImage(constImage(),&shaveInfo,exceptionInfo);
4457 replaceImage(newImage);
4458 ThrowImageException;
4459}

◆ shear()

void Magick::Image::shear ( const double xShearAngle_,
const double yShearAngle_ )

Definition at line 4461 of file Image.cpp.

4462{
4463 MagickCore::Image
4464 *newImage;
4465
4466 GetPPException;
4467 newImage=ShearImage(constImage(),xShearAngle_,yShearAngle_,exceptionInfo);
4468 replaceImage(newImage);
4469 ThrowImageException;
4470}

◆ sigmoidalContrast()

void Magick::Image::sigmoidalContrast ( const bool sharpen_,
const double contrast,
const double midpoint = (double) QuantumRange/2.0 )

Definition at line 4472 of file Image.cpp.

4474{
4475 modifyImage();
4476 GetPPException;
4477 (void) SigmoidalContrastImage(image(),(MagickBooleanType) sharpen_,contrast,
4478 midpoint,exceptionInfo);
4479 ThrowImageException;
4480}

◆ signature()

std::string Magick::Image::signature ( const bool force_ = false) const

Definition at line 4482 of file Image.cpp.

4483{
4484 return(_imgRef->signature(force_));
4485}

◆ size() [1/2]

void Magick::Image::size ( const Geometry & geometry_)

Definition at line 1372 of file Image.cpp.

1373{
1374 modifyImage();
1375 options()->size(geometry_);
1376 image()->rows=geometry_.height();
1377 image()->columns=geometry_.width();
1378}

◆ size() [2/2]

Magick::Geometry Magick::Image::size ( void ) const

Definition at line 1380 of file Image.cpp.

1381{
1382 return(Magick::Geometry(constImage()->columns,constImage()->rows));
1383}

◆ sketch()

void Magick::Image::sketch ( const double radius_ = 0.0,
const double sigma_ = 1.0,
const double angle_ = 0.0 )

Definition at line 4487 of file Image.cpp.

4489{
4490 MagickCore::Image
4491 *newImage;
4492
4493 GetPPException;
4494 newImage=SketchImage(constImage(),radius_,sigma_,angle_,exceptionInfo);
4495 replaceImage(newImage);
4496 ThrowImageException;
4497}

◆ solarize()

void Magick::Image::solarize ( const double factor_ = 50.0)

Definition at line 4499 of file Image.cpp.

4500{
4501 modifyImage();
4502 GetPPException;
4503 SolarizeImage(image(),factor_,exceptionInfo);
4504 ThrowImageException;
4505}

◆ sparseColor()

void Magick::Image::sparseColor ( const ChannelType channel_,
const SparseColorMethod method_,
const size_t numberArguments_,
const double * arguments_ )

Definition at line 4507 of file Image.cpp.

4510{
4511 MagickCore::Image
4512 *newImage;
4513
4514 GetPPException;
4515 GetAndSetPPChannelMask(channel_);
4516 newImage=SparseColorImage(constImage(),method_,numberArguments_,arguments_,
4517 exceptionInfo);
4518 RestorePPChannelMask;
4519 replaceImage(newImage);
4520 ThrowImageException;
4521}

◆ splice() [1/3]

void Magick::Image::splice ( const Geometry & geometry_)

Definition at line 4523 of file Image.cpp.

4524{
4525 MagickCore::Image
4526 *newImage;
4527
4528 RectangleInfo
4529 spliceInfo=geometry_;
4530
4531 GetPPException;
4532 newImage=SpliceImage(constImage(),&spliceInfo,exceptionInfo);
4533 replaceImage(newImage);
4534 ThrowImageException;
4535}

◆ splice() [2/3]

void Magick::Image::splice ( const Geometry & geometry_,
const Color & backgroundColor_ )

Definition at line 4537 of file Image.cpp.

4539{
4540 backgroundColor(backgroundColor_);
4541 splice(geometry_);
4542}

◆ splice() [3/3]

void Magick::Image::splice ( const Geometry & geometry_,
const Color & backgroundColor_,
const GravityType gravity_ )

Definition at line 4544 of file Image.cpp.

4546{
4547 backgroundColor(backgroundColor_);
4548 image()->gravity=gravity_;
4549 splice(geometry_);
4550}

◆ spread()

void Magick::Image::spread ( const double amount_ = 3.0)

Definition at line 4552 of file Image.cpp.

4553{
4554 MagickCore::Image
4555 *newImage;
4556
4557 GetPPException;
4558 newImage=SpreadImage(constImage(),image()->interpolate,amount_,exceptionInfo);
4559 replaceImage(newImage);
4560 ThrowImageException;
4561}

◆ statistics()

Magick::ImageStatistics Magick::Image::statistics ( ) const

Definition at line 4563 of file Image.cpp.

4564{
4565 return(ImageStatistics(*this));
4566}

◆ stegano()

void Magick::Image::stegano ( const Image & watermark_)

Definition at line 4568 of file Image.cpp.

4569{
4570 MagickCore::Image
4571 *newImage;
4572
4573 GetPPException;
4574 newImage=SteganoImage(constImage(),watermark_.constImage(),exceptionInfo);
4575 replaceImage(newImage);
4576 ThrowImageException;
4577}

◆ stereo()

void Magick::Image::stereo ( const Image & rightImage_)

Definition at line 4579 of file Image.cpp.

4580{
4581 MagickCore::Image
4582 *newImage;
4583
4584 GetPPException;
4585 newImage=StereoImage(constImage(),rightImage_.constImage(),exceptionInfo);
4586 replaceImage(newImage);
4587 ThrowImageException;
4588}

◆ strip()

void Magick::Image::strip ( void )

Definition at line 4590 of file Image.cpp.

4591{
4592 modifyImage();
4593 GetPPException;
4594 StripImage(image(),exceptionInfo);
4595 ThrowImageException;
4596}

◆ strokeAntiAlias() [1/2]

void Magick::Image::strokeAntiAlias ( const bool flag_)

Definition at line 1385 of file Image.cpp.

1386{
1387 modifyImage();
1388 options()->strokeAntiAlias(flag_);
1389}

◆ strokeAntiAlias() [2/2]

bool Magick::Image::strokeAntiAlias ( void ) const

Definition at line 1391 of file Image.cpp.

1392{
1393 return(constOptions()->strokeAntiAlias());
1394}

◆ strokeColor() [1/2]

void Magick::Image::strokeColor ( const Color & strokeColor_)

Definition at line 1396 of file Image.cpp.

1397{
1398 std::string
1399 value;
1400
1401 modifyImage();
1402 options()->strokeColor(strokeColor_);
1403 value=strokeColor_;
1404 artifact("stroke",value);
1405}

◆ strokeColor() [2/2]

Magick::Color Magick::Image::strokeColor ( void ) const

Definition at line 1407 of file Image.cpp.

1408{
1409 return(constOptions()->strokeColor());
1410}

◆ strokeDashArray() [1/2]

void Magick::Image::strokeDashArray ( const double * strokeDashArray_)

Definition at line 1412 of file Image.cpp.

1413{
1414 modifyImage();
1415 options()->strokeDashArray(strokeDashArray_);
1416}

◆ strokeDashArray() [2/2]

const double * Magick::Image::strokeDashArray ( void ) const

Definition at line 1418 of file Image.cpp.

1419{
1420 return(constOptions()->strokeDashArray());
1421}

◆ strokeDashOffset() [1/2]

void Magick::Image::strokeDashOffset ( const double strokeDashOffset_)

Definition at line 1423 of file Image.cpp.

1424{
1425 modifyImage();
1426 options()->strokeDashOffset(strokeDashOffset_);
1427}

◆ strokeDashOffset() [2/2]

double Magick::Image::strokeDashOffset ( void ) const

Definition at line 1429 of file Image.cpp.

1430{
1431 return(constOptions()->strokeDashOffset());
1432}

◆ strokeLineCap()

Magick::LineCap Magick::Image::strokeLineCap ( void ) const

Definition at line 1440 of file Image.cpp.

1441{
1442 return(constOptions()->strokeLineCap());
1443}

◆ strokeLineJoin()

Magick::LineJoin Magick::Image::strokeLineJoin ( void ) const

Definition at line 1451 of file Image.cpp.

1452{
1453 return(constOptions()->strokeLineJoin());
1454}

◆ strokeMiterLimit() [1/2]

void Magick::Image::strokeMiterLimit ( const size_t miterLimit_)

Definition at line 1456 of file Image.cpp.

1457{
1458 modifyImage();
1459 options()->strokeMiterLimit(strokeMiterLimit_);
1460}

◆ strokeMiterLimit() [2/2]

size_t Magick::Image::strokeMiterLimit ( void ) const

Definition at line 1462 of file Image.cpp.

1463{
1464 return(constOptions()->strokeMiterLimit());
1465}

◆ strokePattern() [1/2]

void Magick::Image::strokePattern ( const Image & strokePattern_)

Definition at line 1467 of file Image.cpp.

1468{
1469 modifyImage();
1470 if(strokePattern_.isValid())
1471 options()->strokePattern(strokePattern_.constImage());
1472 else
1473 options()->strokePattern(static_cast<MagickCore::Image*>(NULL));
1474}

◆ strokePattern() [2/2]

Magick::Image Magick::Image::strokePattern ( void ) const

Definition at line 1476 of file Image.cpp.

1477{
1478 // FIXME: This is inordinately inefficient
1479 const MagickCore::Image
1480 *tmpTexture;
1481
1482 Image
1483 texture;
1484
1485 tmpTexture=constOptions()->strokePattern();
1486
1487 if (tmpTexture)
1488 {
1489 MagickCore::Image
1490 *image;
1491
1492 GetPPException;
1493 image=CloneImage(tmpTexture,0,0,MagickTrue,exceptionInfo);
1494 texture.replaceImage(image);
1495 ThrowImageException;
1496 }
1497 return(texture);
1498}

◆ strokeWidth() [1/2]

void Magick::Image::strokeWidth ( const double strokeWidth_)

Definition at line 1500 of file Image.cpp.

1501{
1502 char
1503 value[MagickPathExtent];
1504
1505 modifyImage();
1506 options()->strokeWidth(strokeWidth_);
1507 FormatLocaleString(value,MagickPathExtent,"%.17g",strokeWidth_);
1508 (void) SetImageArtifact(image(),"strokewidth",value);
1509}

◆ strokeWidth() [2/2]

double Magick::Image::strokeWidth ( void ) const

Definition at line 1511 of file Image.cpp.

1512{
1513 return(constOptions()->strokeWidth());
1514}

◆ subImage() [1/2]

void Magick::Image::subImage ( const size_t subImage_)

Definition at line 1516 of file Image.cpp.

1517{
1518 modifyImage();
1519 options()->subImage(subImage_);
1520}

◆ subImage() [2/2]

size_t Magick::Image::subImage ( void ) const

Definition at line 1522 of file Image.cpp.

1523{
1524 return(constOptions()->subImage());
1525}

◆ subImageSearch()

Magick::Image Magick::Image::subImageSearch ( const Image & reference_,
const MetricType metric_,
Geometry * offset_,
double * similarityMetric_,
const double similarityThreshold = (-1.0) )

Definition at line 4598 of file Image.cpp.

4601{
4602 MagickCore::Image
4603 *newImage;
4604
4605 RectangleInfo
4606 offset;
4607
4608 GetPPException;
4609 newImage=SimilarityImage(image(),reference_.constImage(),metric_,
4610 similarityThreshold,&offset,similarityMetric_,exceptionInfo);
4611 ThrowImageException;
4612 if (offset_ != (Geometry *) NULL)
4613 *offset_=offset;
4614 if (newImage == (MagickCore::Image *) NULL)
4615 return(Magick::Image());
4616 else
4617 return(Magick::Image(newImage));
4618}

◆ subRange() [1/2]

void Magick::Image::subRange ( const size_t subRange_)

Definition at line 1527 of file Image.cpp.

1528{
1529 modifyImage();
1530 options()->subRange(subRange_);
1531}

◆ subRange() [2/2]

size_t Magick::Image::subRange ( void ) const

Definition at line 1533 of file Image.cpp.

1534{
1535 return(constOptions()->subRange());
1536}

◆ swirl()

void Magick::Image::swirl ( const double degrees_)

Definition at line 4620 of file Image.cpp.

4621{
4622 MagickCore::Image
4623 *newImage;
4624
4625 GetPPException;
4626 newImage=SwirlImage(constImage(),degrees_,image()->interpolate,
4627 exceptionInfo);
4628 replaceImage(newImage);
4629 ThrowImageException;
4630}

◆ syncPixels()

void Magick::Image::syncPixels ( void )

Definition at line 4632 of file Image.cpp.

4633{
4634 GetPPException;
4635 (void) SyncAuthenticPixels(image(),exceptionInfo);
4636 ThrowImageException;
4637}

◆ textAntiAlias() [1/2]

void Magick::Image::textAntiAlias ( const bool flag_)

Definition at line 1538 of file Image.cpp.

1539{
1540 modifyImage();
1541 options()->textAntiAlias(flag_);
1542}

◆ textAntiAlias() [2/2]

bool Magick::Image::textAntiAlias ( void ) const

Definition at line 1544 of file Image.cpp.

1545{
1546 return(constOptions()->textAntiAlias());
1547}

◆ textDirection() [1/2]

Magick::DirectionType Magick::Image::textDirection ( void ) const

Definition at line 1555 of file Image.cpp.

1556{
1557 return(constOptions()->textDirection());
1558}

◆ textDirection() [2/2]

void Magick::Image::textDirection ( DirectionType direction_)

Definition at line 1549 of file Image.cpp.

1550{
1551 modifyImage();
1552 options()->textDirection(direction_);
1553}

◆ textEncoding() [1/2]

void Magick::Image::textEncoding ( const std::string & encoding_)

Definition at line 1560 of file Image.cpp.

1561{
1562 modifyImage();
1563 options()->textEncoding(encoding_);
1564}

◆ textEncoding() [2/2]

std::string Magick::Image::textEncoding ( void ) const

Definition at line 1566 of file Image.cpp.

1567{
1568 return(constOptions()->textEncoding());
1569}

◆ textGravity() [1/2]

Magick::GravityType Magick::Image::textGravity ( void ) const

Definition at line 1577 of file Image.cpp.

1578{
1579 return(constOptions()->textGravity());
1580}

◆ textGravity() [2/2]

void Magick::Image::textGravity ( GravityType gravity_)

Definition at line 1571 of file Image.cpp.

1572{
1573 modifyImage();
1574 options()->textGravity(gravity_);
1575}

◆ textInterlineSpacing() [1/2]

void Magick::Image::textInterlineSpacing ( double spacing_)

Definition at line 1582 of file Image.cpp.

1583{
1584 modifyImage();
1585 options()->textInterlineSpacing(spacing_);
1586}

◆ textInterlineSpacing() [2/2]

double Magick::Image::textInterlineSpacing ( void ) const

Definition at line 1588 of file Image.cpp.

1589{
1590 return(constOptions()->textInterlineSpacing());
1591}

◆ textInterwordSpacing() [1/2]

void Magick::Image::textInterwordSpacing ( double spacing_)

Definition at line 1593 of file Image.cpp.

1594{
1595 modifyImage();
1596 options()->textInterwordSpacing(spacing_);
1597}

◆ textInterwordSpacing() [2/2]

double Magick::Image::textInterwordSpacing ( void ) const

Definition at line 1599 of file Image.cpp.

1600{
1601 return(constOptions()->textInterwordSpacing());
1602}

◆ textKerning() [1/2]

void Magick::Image::textKerning ( double kerning_)

Definition at line 1604 of file Image.cpp.

1605{
1606 modifyImage();
1607 options()->textKerning(kerning_);
1608}

◆ textKerning() [2/2]

double Magick::Image::textKerning ( void ) const

Definition at line 1610 of file Image.cpp.

1611{
1612 return(constOptions()->textKerning());
1613}

◆ textUnderColor() [1/2]

void Magick::Image::textUnderColor ( const Color & underColor_)

Definition at line 1615 of file Image.cpp.

1616{
1617 modifyImage();
1618 options()->textUnderColor(underColor_);
1619}

◆ textUnderColor() [2/2]

Magick::Color Magick::Image::textUnderColor ( void ) const

Definition at line 1621 of file Image.cpp.

1622{
1623 return(constOptions()->textUnderColor());
1624}

◆ texture()

void Magick::Image::texture ( const Image & texture_)

Definition at line 4639 of file Image.cpp.

4640{
4641 modifyImage();
4642 GetPPException;
4643 TextureImage(image(),texture_.constImage(),exceptionInfo);
4644 ThrowImageException;
4645}

◆ threshold()

void Magick::Image::threshold ( const double threshold_)

Definition at line 4647 of file Image.cpp.

4648{
4649 modifyImage();
4650 GetPPException;
4651 BilevelImage(image(),threshold_,exceptionInfo);
4652 ThrowImageException;
4653}

◆ thumbnail()

void Magick::Image::thumbnail ( const Geometry & geometry_)

Definition at line 4655 of file Image.cpp.

4656{
4657 MagickCore::Image
4658 *newImage;
4659
4660 size_t
4661 height=rows(),
4662 width=columns();
4663
4664 ssize_t
4665 x=0,
4666 y=0;
4667
4668 ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
4669 &height);
4670
4671 GetPPException;
4672 newImage=ThumbnailImage(constImage(),width,height,exceptionInfo);
4673 replaceImage(newImage);
4674 ThrowImageException;
4675}

◆ tint()

void Magick::Image::tint ( const std::string opacity_)

Definition at line 4677 of file Image.cpp.

4678{
4679 MagickCore::Image
4680 *newImage;
4681
4682 PixelInfo
4683 color;
4684
4685 GetPPException;
4686 color=static_cast<PixelInfo>(constOptions()->fillColor());
4687 newImage=TintImage(constImage(),opacity_.c_str(),&color,exceptionInfo);
4688 replaceImage(newImage);
4689 ThrowImageException;
4690}

◆ totalColors()

size_t Magick::Image::totalColors ( void ) const

Definition at line 1626 of file Image.cpp.

1627{
1628 size_t
1629 colors;
1630
1631 GetPPException;
1632 colors=GetNumberColors(constImage(),(FILE *) NULL,exceptionInfo);
1633 ThrowImageException;
1634 return colors;
1635}

◆ transformOrigin()

void Magick::Image::transformOrigin ( const double x_,
const double y_ )

Definition at line 4692 of file Image.cpp.

4693{
4694 modifyImage();
4695 options()->transformOrigin(x_,y_);
4696}

◆ transformReset()

void Magick::Image::transformReset ( void )

Definition at line 4698 of file Image.cpp.

4699{
4700 modifyImage();
4701 options()->transformReset();
4702}

◆ transformRotation()

void Magick::Image::transformRotation ( const double angle_)

Definition at line 1637 of file Image.cpp.

1638{
1639 modifyImage();
1640 options()->transformRotation(angle_);
1641}

◆ transformScale()

void Magick::Image::transformScale ( const double sx_,
const double sy_ )

Definition at line 4704 of file Image.cpp.

4705{
4706 modifyImage();
4707 options()->transformScale(sx_,sy_);
4708}

◆ transformSkewX()

void Magick::Image::transformSkewX ( const double skewx_)

Definition at line 1643 of file Image.cpp.

1644{
1645 modifyImage();
1646 options()->transformSkewX(skewx_);
1647}

◆ transformSkewY()

void Magick::Image::transformSkewY ( const double skewy_)

Definition at line 1649 of file Image.cpp.

1650{
1651 modifyImage();
1652 options()->transformSkewY(skewy_);
1653}

◆ transparent()

void Magick::Image::transparent ( const Color & color_,
const bool inverse_ = false )

Definition at line 4710 of file Image.cpp.

4711{
4712 PixelInfo
4713 target;
4714
4715 std::string
4716 color;
4717
4718 if (!color_.isValid())
4719 throwExceptionExplicit(MagickCore::OptionError,
4720 "Color argument is invalid");
4721
4722 color=color_;
4723 GetPPException;
4724 (void) QueryColorCompliance(color.c_str(),AllCompliance,&target,
4725 exceptionInfo);
4726 modifyImage();
4727 TransparentPaintImage(image(),&target,TransparentAlpha,
4728 inverse_ == true ? MagickTrue : MagickFalse,exceptionInfo);
4729 ThrowImageException;
4730}

◆ transparentChroma()

void Magick::Image::transparentChroma ( const Color & colorLow_,
const Color & colorHigh_ )

Definition at line 4732 of file Image.cpp.

4734{
4735 std::string
4736 colorHigh,
4737 colorLow;
4738
4739 PixelInfo
4740 targetHigh,
4741 targetLow;
4742
4743 if (!colorLow_.isValid() || !colorHigh_.isValid())
4744 throwExceptionExplicit(MagickCore::OptionError,
4745 "Color argument is invalid");
4746
4747 colorLow=colorLow_;
4748 colorHigh=colorHigh_;
4749
4750 GetPPException;
4751 (void) QueryColorCompliance(colorLow.c_str(),AllCompliance,&targetLow,
4752 exceptionInfo);
4753 (void) QueryColorCompliance(colorHigh.c_str(),AllCompliance,&targetHigh,
4754 exceptionInfo);
4755 modifyImage();
4756 TransparentPaintImageChroma(image(),&targetLow,&targetHigh,TransparentAlpha,
4757 MagickFalse,exceptionInfo);
4758 ThrowImageException;
4759}

◆ transpose()

void Magick::Image::transpose ( void )

Definition at line 4761 of file Image.cpp.

4762{
4763 MagickCore::Image
4764 *newImage;
4765
4766 GetPPException;
4767 newImage=TransposeImage(constImage(),exceptionInfo);
4768 replaceImage(newImage);
4769 ThrowImageException;
4770}

◆ transverse()

void Magick::Image::transverse ( void )

Definition at line 4772 of file Image.cpp.

4773{
4774 MagickCore::Image
4775 *newImage;
4776
4777 GetPPException;
4778 newImage=TransverseImage(constImage(),exceptionInfo);
4779 replaceImage(newImage);
4780 ThrowImageException;
4781}

◆ trim()

void Magick::Image::trim ( void )

Definition at line 4783 of file Image.cpp.

4784{
4785 MagickCore::Image
4786 *newImage;
4787
4788 GetPPException;
4789 newImage=TrimImage(constImage(),exceptionInfo);
4790 replaceImage(newImage);
4791 ThrowImageException;
4792}

◆ type()

Magick::ImageType Magick::Image::type ( void ) const

Definition at line 1655 of file Image.cpp.

1656{
1657 if (constOptions()->type() != UndefinedType)
1658 return(constOptions()->type());
1659 return(GetImageType(constImage()));
1660}

◆ uniqueColors()

Magick::Image Magick::Image::uniqueColors ( void ) const

Definition at line 4794 of file Image.cpp.

4795{
4796 MagickCore::Image
4797 *image;
4798
4799 GetPPException;
4800 image=UniqueImageColors(constImage(),exceptionInfo);
4801 ThrowImageException;
4802 if (image == (MagickCore::Image *) NULL)
4803 return(Magick::Image());
4804 else
4805 return(Magick::Image(image));
4806}

◆ unsharpmask()

void Magick::Image::unsharpmask ( const double radius_,
const double sigma_,
const double amount_,
const double threshold_ )

Definition at line 4808 of file Image.cpp.

4810{
4811 MagickCore::Image
4812 *newImage;
4813
4814 GetPPException;
4815 newImage=UnsharpMaskImage(constImage(),radius_,sigma_,amount_,threshold_,
4816 exceptionInfo);
4817 replaceImage(newImage);
4818 ThrowImageException;
4819}

◆ unsharpmaskChannel()

void Magick::Image::unsharpmaskChannel ( const ChannelType channel_,
const double radius_,
const double sigma_,
const double amount_,
const double threshold_ )

Definition at line 4821 of file Image.cpp.

4824{
4825 MagickCore::Image
4826 *newImage;
4827
4828 GetPPException;
4829 GetAndSetPPChannelMask(channel_);
4830 newImage=UnsharpMaskImage(constImage(),radius_,sigma_,amount_,threshold_,
4831 exceptionInfo);
4832 RestorePPChannelMask;
4833 replaceImage(newImage);
4834 ThrowImageException;
4835}

◆ verbose() [1/2]

void Magick::Image::verbose ( const bool verboseFlag_)

Definition at line 1671 of file Image.cpp.

1672{
1673 modifyImage();
1674 options()->verbose(verboseFlag_);
1675}

◆ verbose() [2/2]

bool Magick::Image::verbose ( void ) const

Definition at line 1677 of file Image.cpp.

1678{
1679 return(constOptions()->verbose());
1680}

◆ vignette()

void Magick::Image::vignette ( const double radius_ = 0.0,
const double sigma_ = 1.0,
const ssize_t x_ = 0,
const ssize_t y_ = 0 )

Definition at line 4837 of file Image.cpp.

4839{
4840 MagickCore::Image
4841 *newImage;
4842
4843 GetPPException;
4844 newImage=VignetteImage(constImage(),radius_,sigma_,x_,y_,exceptionInfo);
4845 replaceImage(newImage);
4846 ThrowImageException;
4847}

◆ virtualPixelMethod() [1/2]

void Magick::Image::virtualPixelMethod ( const VirtualPixelMethod virtualPixelMethod_)

Definition at line 1682 of file Image.cpp.

1684{
1685 modifyImage();
1686 GetPPException;
1687 SetImageVirtualPixelMethod(image(),virtualPixelMethod_,exceptionInfo);
1688 ThrowImageException;
1689}

◆ virtualPixelMethod() [2/2]

Magick::VirtualPixelMethod Magick::Image::virtualPixelMethod ( void ) const

Definition at line 1691 of file Image.cpp.

1692{
1693 return(GetImageVirtualPixelMethod(constImage()));
1694}

◆ wave()

void Magick::Image::wave ( const double amplitude_ = 25.0,
const double wavelength_ = 150.0 )

Definition at line 4849 of file Image.cpp.

4850{
4851 MagickCore::Image
4852 *newImage;
4853
4854 GetPPException;
4855 newImage=WaveImage(constImage(),amplitude_,wavelength_,image()->interpolate,
4856 exceptionInfo);
4857 replaceImage(newImage);
4858 ThrowImageException;
4859}

◆ waveletDenoise()

void Magick::Image::waveletDenoise ( const double threshold_,
const double softness_ )

Definition at line 4861 of file Image.cpp.

4863{
4864 MagickCore::Image
4865 *newImage;
4866
4867 GetPPException;
4868 newImage=WaveletDenoiseImage(constImage(),threshold_,softness_,
4869 exceptionInfo);
4870 replaceImage(newImage);
4871 ThrowImageException;
4872}

◆ whiteThreshold()

void Magick::Image::whiteThreshold ( const std::string & threshold_)

Definition at line 4874 of file Image.cpp.

4875{
4876 modifyImage();
4877 GetPPException;
4878 WhiteThresholdImage(image(),threshold_.c_str(),exceptionInfo);
4879 ThrowImageException;
4880}

◆ whiteThresholdChannel()

void Magick::Image::whiteThresholdChannel ( const ChannelType channel_,
const std::string & threshold_ )

Definition at line 4882 of file Image.cpp.

4884{
4885 modifyImage();
4886 GetPPException;
4887 GetAndSetPPChannelMask(channel_);
4888 WhiteThresholdImage(image(),threshold_.c_str(),exceptionInfo);
4889 RestorePPChannelMask;
4890 ThrowImageException;
4891}

◆ write() [1/4]

void Magick::Image::write ( Blob * blob_)

Definition at line 4893 of file Image.cpp.

4894{
4895 size_t
4896 length=0;
4897
4898 void
4899 *data;
4900
4901 modifyImage();
4902 GetPPException;
4903 data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
4904 if (length > 0)
4905 blob_->updateNoCopy(data,length,Blob::MallocAllocator);
4906 else
4907 data=RelinquishMagickMemory(data);
4908 ThrowImageException;
4909}

◆ write() [2/4]

void Magick::Image::write ( Blob * blob_,
const std::string & magick_ )

Definition at line 4911 of file Image.cpp.

4912{
4913 size_t
4914 length=0;
4915
4916 void
4917 *data;
4918
4919 modifyImage();
4920 magick(magick_);
4921 GetPPException;
4922 data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
4923 if (length > 0)
4924 blob_->updateNoCopy(data,length,Blob::MallocAllocator);
4925 else
4926 data=RelinquishMagickMemory(data);
4927 ThrowImageException;
4928}

◆ write() [3/4]

void Magick::Image::write ( Blob * blob_,
const std::string & magick_,
const size_t depth_ )

Definition at line 4930 of file Image.cpp.

4932{
4933 size_t
4934 length=0;
4935
4936 void
4937 *data;
4938
4939 modifyImage();
4940 magick(magick_);
4941 depth(depth_);
4942 GetPPException;
4943 data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
4944 if (length > 0)
4945 blob_->updateNoCopy(data,length,Blob::MallocAllocator);
4946 else
4947 data=RelinquishMagickMemory(data);
4948 ThrowImageException;
4949}

◆ write() [4/4]

void Magick::Image::write ( const std::string & imageSpec_)

Definition at line 4961 of file Image.cpp.

4962{
4963 modifyImage();
4964 fileName(imageSpec_);
4965 GetPPException;
4966 WriteImage(constImageInfo(),image(),exceptionInfo);
4967 ThrowImageException;
4968}

◆ writeMask() [1/2]

void Magick::Image::writeMask ( const Image & mask_)

Definition at line 4970 of file Image.cpp.

4971{
4972 mask(mask_,WritePixelMask);
4973}

◆ writeMask() [2/2]

Magick::Image Magick::Image::writeMask ( void ) const

Definition at line 4975 of file Image.cpp.

4976{
4977 return(mask(WritePixelMask));
4978}

◆ writePixels()

void Magick::Image::writePixels ( const QuantumType quantum_,
unsigned char * destination_ )

Definition at line 4980 of file Image.cpp.

4982{
4983 QuantumInfo
4984 *quantum_info;
4985
4986 quantum_info=AcquireQuantumInfo(imageInfo(),image());
4987 GetPPException;
4988 ExportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
4989 quantum_,destination_, exceptionInfo);
4990 quantum_info=DestroyQuantumInfo(quantum_info);
4991 ThrowImageException;
4992}

◆ x11Display() [1/2]

void Magick::Image::x11Display ( const std::string & display_)

Definition at line 1696 of file Image.cpp.

1697{
1698 modifyImage();
1699 options()->x11Display(display_);
1700}

◆ x11Display() [2/2]

std::string Magick::Image::x11Display ( void ) const

Definition at line 1702 of file Image.cpp.

1703{
1704 return(constOptions()->x11Display());
1705}

◆ xResolution()

double Magick::Image::xResolution ( void ) const

Definition at line 1707 of file Image.cpp.

1708{
1709 return(constImage()->resolution.x);
1710}

◆ yResolution()

double Magick::Image::yResolution ( void ) const

Definition at line 1712 of file Image.cpp.

1713{
1714 return(constImage()->resolution.y);
1715}

◆ zoom()

void Magick::Image::zoom ( const Geometry & geometry_)

Definition at line 4994 of file Image.cpp.

4995{
4996 MagickCore::Image
4997 *newImage;
4998
4999 size_t
5000 height=rows(),
5001 width=columns();
5002
5003 ssize_t
5004 x=0,
5005 y=0;
5006
5007 ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
5008 &height);
5009
5010 GetPPException;
5011 newImage=ResizeImage(constImage(),width,height,image()->filter,exceptionInfo);
5012 replaceImage(newImage);
5013 ThrowImageException;
5014}

Field Documentation

◆ _imgRef

ImageRef* Magick::Image::_imgRef
private

Definition at line 1560 of file Image.h.

The documentation for this class was generated from the following files:
  • /home/cristy/Attic/Build/ImageMagick-7.1.2/rpmbuild/BUILD/ImageMagick-7.1.2-build/ImageMagick-7.1.2-32/Magick++/lib/Magick++/Image.h
  • /home/cristy/Attic/Build/ImageMagick-7.1.2/rpmbuild/BUILD/ImageMagick-7.1.2-build/ImageMagick-7.1.2-32/Magick++/lib/Image.cpp