Magick++ 7.1.1
Loading...
Searching...
No Matches
Magick::Image Class Reference
Collaboration diagram for Magick::Image:

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_)
 
Imageoperator= (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 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
 
Optionsoptions (void)
 
const OptionsconstOptions (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 79 of file Image.cpp.

80 : _imgRef(new ImageRef)
81{
82}

◆ Image() [2/12]

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

Definition at line 84 of file Image.cpp.

85 : _imgRef(new ImageRef)
86{
87 try
88 {
89 // Initialize, Allocate and Read images
90 quiet(true);
91 read(blob_);
92 quiet(false);
93 }
94 catch (const Error&)
95 {
96 // Release resources
97 delete _imgRef;
98 throw;
99 }
100}

◆ Image() [3/12]

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

Definition at line 102 of file Image.cpp.

103 : _imgRef(new ImageRef)
104{
105 try
106 {
107 // Read from Blob
108 quiet(true);
109 read(blob_, size_);
110 quiet(false);
111 }
112 catch(const Error&)
113 {
114 // Release resources
115 delete _imgRef;
116 throw;
117 }
118}

◆ Image() [4/12]

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

Definition at line 120 of file Image.cpp.

122 : _imgRef(new ImageRef)
123{
124 try
125 {
126 // Read from Blob
127 quiet(true);
128 read(blob_,size_,depth_);
129 quiet(false);
130 }
131 catch(const Error&)
132 {
133 // Release resources
134 delete _imgRef;
135 throw;
136 }
137}

◆ Image() [5/12]

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

Definition at line 139 of file Image.cpp.

141 : _imgRef(new ImageRef)
142{
143 try
144 {
145 // Read from Blob
146 quiet(true);
147 read(blob_,size_,depth_,magick_);
148 quiet(false);
149 }
150 catch(const Error&)
151 {
152 // Release resources
153 delete _imgRef;
154 throw;
155 }
156}

◆ Image() [6/12]

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

Definition at line 158 of file Image.cpp.

160 : _imgRef(new ImageRef)
161{
162 try
163 {
164 // Read from Blob
165 quiet(true);
166 read(blob_,size_,magick_);
167 quiet(false);
168 }
169 catch(const Error&)
170 {
171 // Release resources
172 delete _imgRef;
173 throw;
174 }
175}

◆ Image() [7/12]

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

Definition at line 177 of file Image.cpp.

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

◆ Image() [8/12]

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

Definition at line 202 of file Image.cpp.

203 : _imgRef(image_._imgRef)
204{
205 _imgRef->increase();
206}

◆ Image() [9/12]

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

Definition at line 208 of file Image.cpp.

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

◆ 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 232 of file Image.cpp.

234 : _imgRef(new ImageRef)
235{
236 try
237 {
238 quiet(true);
239 read(width_,height_,map_.c_str(),type_,pixels_);
240 quiet(false);
241 }
242 catch(const Error&)
243 {
244 // Release resources
245 delete _imgRef;
246 throw;
247 }
248}

◆ Image() [11/12]

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

Definition at line 250 of file Image.cpp.

251 : _imgRef(new ImageRef)
252{
253 try
254 {
255 // Initialize, Allocate and Read images
256 quiet(true);
257 read(imageSpec_);
258 quiet(false);
259 }
260 catch(const Error&)
261 {
262 // Release resources
263 delete _imgRef;
264 throw;
265 }
266}

◆ ~Image()

Magick::Image::~Image ( )
virtual

Definition at line 268 of file Image.cpp.

269{
270 try
271 {
272 if (_imgRef->decrease() == 0)
273 delete _imgRef;
274 }
275 catch(Magick::Exception&)
276 {
277 }
278
279 _imgRef=(Magick::ImageRef *) NULL;
280}

◆ Image() [12/12]

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

Definition at line 5018 of file Image.cpp.

5019 : _imgRef(new ImageRef(image_))
5020{
5021}

Member Function Documentation

◆ adaptiveBlur()

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

Definition at line 1724 of file Image.cpp.

1725{
1726 MagickCore::Image
1727 *newImage;
1728
1729 GetPPException;
1730 newImage=AdaptiveBlurImage(constImage(),radius_,sigma_,exceptionInfo);
1731 replaceImage(newImage);
1732 ThrowImageException;
1733}

◆ adaptiveResize()

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

Definition at line 1735 of file Image.cpp.

1736{
1737 MagickCore::Image
1738 *newImage;
1739
1740 size_t
1741 height=rows(),
1742 width=columns();
1743
1744 ssize_t
1745 x=0,
1746 y=0;
1747
1748 ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
1749 &height);
1750
1751 GetPPException;
1752 newImage=AdaptiveResizeImage(constImage(),width,height,exceptionInfo);
1753 replaceImage(newImage);
1754 ThrowImageException;
1755}

◆ adaptiveSharpen()

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

Definition at line 1757 of file Image.cpp.

1758{
1759 MagickCore::Image
1760 *newImage;
1761
1762 GetPPException;
1763 newImage=AdaptiveSharpenImage(constImage(),radius_,sigma_,exceptionInfo);
1764 replaceImage(newImage);
1765 ThrowImageException;
1766}

◆ adaptiveSharpenChannel()

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

Definition at line 1768 of file Image.cpp.

1770{
1771 MagickCore::Image
1772 *newImage;
1773
1774 GetPPException;
1775 GetAndSetPPChannelMask(channel_);
1776 newImage=AdaptiveSharpenImage(constImage(),radius_,sigma_,exceptionInfo);
1777 RestorePPChannelMask;
1778 replaceImage(newImage);
1779 ThrowImageException;
1780}

◆ adaptiveThreshold()

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

Definition at line 1782 of file Image.cpp.

1784{
1785
1786 MagickCore::Image
1787 *newImage;
1788
1789 GetPPException;
1790 newImage=AdaptiveThresholdImage(constImage(),width_,height_,bias_,
1791 exceptionInfo);
1792 replaceImage(newImage);
1793 ThrowImageException;
1794}

◆ addNoise()

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

Definition at line 1796 of file Image.cpp.

1797{
1798 MagickCore::Image
1799 *newImage;
1800
1801 GetPPException;
1802 newImage=AddNoiseImage(constImage(),noiseType_,attenuate_,exceptionInfo);
1803 replaceImage(newImage);
1804 ThrowImageException;
1805}

◆ addNoiseChannel()

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

Definition at line 1807 of file Image.cpp.

1809{
1810 MagickCore::Image
1811 *newImage;
1812
1813 GetPPException;
1814 GetAndSetPPChannelMask(channel_);
1815 newImage=AddNoiseImage(constImage(),noiseType_,attenuate_,exceptionInfo);
1816 RestorePPChannelMask;
1817 replaceImage(newImage);
1818 ThrowImageException;
1819}

◆ adjoin() [1/2]

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

Definition at line 296 of file Image.cpp.

297{
298 modifyImage();
299 options()->adjoin(flag_);
300}

◆ adjoin() [2/2]

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

Definition at line 302 of file Image.cpp.

303{
304 return(constOptions()->adjoin());
305}

◆ affineTransform()

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

Definition at line 1821 of file Image.cpp.

1822{
1823 AffineMatrix
1824 _affine;
1825
1826 MagickCore::Image
1827 *newImage;
1828
1829 _affine.sx=affine_.sx();
1830 _affine.sy=affine_.sy();
1831 _affine.rx=affine_.rx();
1832 _affine.ry=affine_.ry();
1833 _affine.tx=affine_.tx();
1834 _affine.ty=affine_.ty();
1835
1836 GetPPException;
1837 newImage=AffineTransformImage(constImage(),&_affine,exceptionInfo);
1838 replaceImage(newImage);
1839 ThrowImageException;
1840}

◆ alpha() [1/3]

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

Definition at line 307 of file Image.cpp.

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

◆ alpha() [2/3]

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

Definition at line 1842 of file Image.cpp.

1843{
1844 modifyImage();
1845 GetPPException;
1846 SetImageAlpha(image(),alpha_,exceptionInfo);
1847 ThrowImageException;
1848}

◆ alpha() [3/3]

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

Definition at line 323 of file Image.cpp.

324{
325 if (constImage()->alpha_trait == BlendPixelTrait)
326 return(true);
327 else
328 return(false);
329}

◆ alphaChannel()

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

Definition at line 1850 of file Image.cpp.

1851{
1852 modifyImage();
1853 GetPPException;
1854 SetImageAlphaChannel(image(),alphaOption_,exceptionInfo);
1855 ThrowImageException;
1856}

◆ animationDelay() [1/2]

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

Definition at line 354 of file Image.cpp.

355{
356 modifyImage();
357 image()->delay=delay_;
358}

◆ animationDelay() [2/2]

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

Definition at line 360 of file Image.cpp.

361{
362 return(constImage()->delay);
363}

◆ animationIterations() [1/2]

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

Definition at line 365 of file Image.cpp.

366{
367 modifyImage();
368 image()->iterations=iterations_;
369}

◆ animationIterations() [2/2]

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

Definition at line 371 of file Image.cpp.

372{
373 return(constImage()->iterations);
374}

◆ annotate() [1/4]

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

Definition at line 1864 of file Image.cpp.

1866{
1867 annotate(text_,boundingArea_,gravity_,0.0);
1868}

◆ annotate() [2/4]

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

Definition at line 1870 of file Image.cpp.

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

◆ annotate() [3/4]

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

Definition at line 1858 of file Image.cpp.

1860{
1861 annotate(text_,location_,NorthWestGravity,0.0);
1862}

◆ annotate() [4/4]

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

Definition at line 1946 of file Image.cpp.

1948{
1949 DrawInfo
1950 *drawInfo;
1951
1952 modifyImage();
1953
1954 drawInfo=options()->drawInfo();
1955 drawInfo->text=DestroyString(drawInfo->text);
1956 drawInfo->text=const_cast<char *>(text_.c_str());
1957 drawInfo->gravity=gravity_;
1958
1959 GetPPException;
1960 AnnotateImage(image(),drawInfo,exceptionInfo);
1961
1962 drawInfo->gravity=NorthWestGravity;
1963 drawInfo->text=(char *) NULL;
1964
1965 ThrowImageException;
1966}

◆ artifact() [1/2]

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

Definition at line 1974 of file Image.cpp.

1975{
1976 const char
1977 *value;
1978
1979 value=GetImageArtifact(constImage(),name_.c_str());
1980 if (value)
1981 return(std::string(value));
1982 return(std::string());
1983}

◆ artifact() [2/2]

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

Definition at line 1968 of file Image.cpp.

1969{
1970 modifyImage();
1971 (void) SetImageArtifact(image(),name_.c_str(),value_.c_str());
1972}

◆ attribute() [1/3]

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

Definition at line 2001 of file Image.cpp.

2002{
2003 const char
2004 *value;
2005
2006 GetPPException;
2007 value=GetImageProperty(constImage(),name_.c_str(),exceptionInfo);
2008 ThrowImageException;
2009
2010 if (value)
2011 return(std::string(value));
2012
2013 return(std::string()); // Intentionally no exception
2014}

◆ attribute() [2/3]

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

Definition at line 1985 of file Image.cpp.

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

◆ attribute() [3/3]

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

Definition at line 1993 of file Image.cpp.

1994{
1995 modifyImage();
1996 GetPPException;
1997 SetImageProperty(image(),name_.c_str(),value_.c_str(),exceptionInfo);
1998 ThrowImageException;
1999}

◆ autoGamma()

void Magick::Image::autoGamma ( void  )

Definition at line 2016 of file Image.cpp.

2017{
2018 modifyImage();
2019 GetPPException;
2020 (void) SyncImageSettings(imageInfo(),image(),exceptionInfo);
2021 (void) AutoGammaImage(image(),exceptionInfo);
2022 ThrowImageException;
2023}

◆ autoGammaChannel()

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

Definition at line 2025 of file Image.cpp.

2026{
2027 modifyImage();
2028 GetPPException;
2029 GetAndSetPPChannelMask(channel_);
2030 (void) SyncImageSettings(imageInfo(),image(),exceptionInfo);
2031 (void) AutoGammaImage(image(),exceptionInfo);
2032 RestorePPChannelMask;
2033 ThrowImageException;
2034}

◆ autoLevel()

void Magick::Image::autoLevel ( void  )

Definition at line 2036 of file Image.cpp.

2037{
2038 modifyImage();
2039 GetPPException;
2040 (void) AutoLevelImage(image(),exceptionInfo);
2041 ThrowImageException;
2042}

◆ autoLevelChannel()

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

Definition at line 2044 of file Image.cpp.

2045{
2046 modifyImage();
2047 GetPPException;
2048 GetAndSetPPChannelMask(channel_);
2049 (void) AutoLevelImage(image(),exceptionInfo);
2050 RestorePPChannelMask;
2051 ThrowImageException;
2052}

◆ autoOrient()

void Magick::Image::autoOrient ( void  )

Definition at line 2054 of file Image.cpp.

2055{
2056 MagickCore::Image
2057 *newImage;
2058
2059 if (image()->orientation == UndefinedOrientation ||
2060 image()->orientation == TopLeftOrientation)
2061 return;
2062
2063 GetPPException;
2064 newImage=AutoOrientImage(constImage(),image()->orientation,exceptionInfo);
2065 replaceImage(newImage);
2066 ThrowImageException;
2067}

◆ autoThreshold()

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

Definition at line 2069 of file Image.cpp.

2070{
2071 modifyImage();
2072 GetPPException;
2073 AutoThresholdImage(image(),method_, exceptionInfo);
2074 ThrowImageException;
2075}

◆ backgroundColor() [1/2]

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

Definition at line 376 of file Image.cpp.

377{
378 modifyImage();
379
380 if (backgroundColor_.isValid())
381 image()->background_color=backgroundColor_;
382 else
383 image()->background_color=Color();
384
385 options()->backgroundColor(backgroundColor_);
386}

◆ backgroundColor() [2/2]

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

Definition at line 388 of file Image.cpp.

389{
390 return(constOptions()->backgroundColor());
391}

◆ backgroundTexture() [1/2]

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

Definition at line 393 of file Image.cpp.

394{
395 modifyImage();
396 options()->backgroundTexture(backgroundTexture_);
397}

◆ backgroundTexture() [2/2]

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

Definition at line 399 of file Image.cpp.

400{
401 return(constOptions()->backgroundTexture());
402}

◆ baseColumns()

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

Definition at line 404 of file Image.cpp.

405{
406 return(constImage()->magick_columns);
407}

◆ baseFilename()

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

Definition at line 409 of file Image.cpp.

410{
411 return(std::string(constImage()->magick_filename));
412}

◆ baseRows()

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

Definition at line 414 of file Image.cpp.

415{
416 return(constImage()->magick_rows);
417}

◆ blackPointCompensation() [1/2]

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

Definition at line 419 of file Image.cpp.

420{
421 image()->black_point_compensation=(MagickBooleanType) flag_;
422}

◆ blackPointCompensation() [2/2]

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

Definition at line 424 of file Image.cpp.

425{
426 return(static_cast<bool>(constImage()->black_point_compensation));
427}

◆ blackThreshold()

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

Definition at line 2077 of file Image.cpp.

2078{
2079 modifyImage();
2080 GetPPException;
2081 BlackThresholdImage(image(),threshold_.c_str(),exceptionInfo);
2082 ThrowImageException;
2083}

◆ blackThresholdChannel()

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

Definition at line 2085 of file Image.cpp.

2087{
2088 modifyImage();
2089 GetPPException;
2090 GetAndSetPPChannelMask(channel_);
2091 BlackThresholdImage(image(),threshold_.c_str(),exceptionInfo);
2092 RestorePPChannelMask;
2093 ThrowImageException;
2094}

◆ blueShift()

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

Definition at line 2096 of file Image.cpp.

2097{
2098 MagickCore::Image
2099 *newImage;
2100
2101 GetPPException;
2102 newImage=BlueShiftImage(constImage(),factor_,exceptionInfo);
2103 replaceImage(newImage);
2104 ThrowImageException;
2105}

◆ blur()

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

Definition at line 2107 of file Image.cpp.

2108{
2109 MagickCore::Image
2110 *newImage;
2111
2112 GetPPException;
2113 newImage=BlurImage(constImage(),radius_,sigma_,exceptionInfo);
2114 replaceImage(newImage);
2115 ThrowImageException;
2116}

◆ blurChannel()

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

Definition at line 2118 of file Image.cpp.

2120{
2121 MagickCore::Image
2122 *newImage;
2123
2124 GetPPException;
2125 GetAndSetPPChannelMask(channel_);
2126 newImage=BlurImage(constImage(),radius_,sigma_,exceptionInfo);
2127 RestorePPChannelMask;
2128 replaceImage(newImage);
2129 ThrowImageException;
2130}

◆ border()

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

Definition at line 2132 of file Image.cpp.

2133{
2134 MagickCore::Image
2135 *newImage;
2136
2137 RectangleInfo
2138 borderInfo=geometry_;
2139
2140 GetPPException;
2141 newImage=BorderImage(constImage(),&borderInfo,image()->compose,
2142 exceptionInfo);
2143 replaceImage(newImage);
2144 ThrowImageException;
2145}

◆ borderColor() [1/2]

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

Definition at line 429 of file Image.cpp.

430{
431 modifyImage();
432
433 if (borderColor_.isValid())
434 image()->border_color=borderColor_;
435 else
436 image()->border_color=Color();
437
438 options()->borderColor(borderColor_);
439}

◆ borderColor() [2/2]

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

Definition at line 441 of file Image.cpp.

442{
443 return(constOptions()->borderColor());
444}

◆ boundingBox()

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

Definition at line 446 of file Image.cpp.

447{
448 RectangleInfo
449 bbox;
450
451 GetPPException;
452 bbox=GetImageBoundingBox(constImage(),exceptionInfo);
453 ThrowImageException;
454 return(Geometry(bbox));
455}

◆ boxColor() [1/2]

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

Definition at line 457 of file Image.cpp.

458{
459 modifyImage();
460 options()->boxColor(boxColor_);
461}

◆ boxColor() [2/2]

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

Definition at line 463 of file Image.cpp.

464{
465 return(constOptions()->boxColor());
466}

◆ brightnessContrast()

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

Definition at line 2147 of file Image.cpp.

2149{
2150 modifyImage();
2151 GetPPException;
2152 BrightnessContrastImage(image(),brightness_,contrast_,exceptionInfo);
2153 ThrowImageException;
2154}

◆ brightnessContrastChannel()

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

Definition at line 2156 of file Image.cpp.

2158{
2159 modifyImage();
2160 GetPPException;
2161 GetAndSetPPChannelMask(channel_);
2162 BrightnessContrastImage(image(),brightness_,contrast_,exceptionInfo);
2163 RestorePPChannelMask;
2164 ThrowImageException;
2165}

◆ 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 2167 of file Image.cpp.

2169{
2170 MagickCore::Image
2171 *newImage;
2172
2173 modifyImage();
2174 GetPPException;
2175 newImage=CannyEdgeImage(constImage(),radius_,sigma_,lowerPercent_,
2176 upperPercent_,exceptionInfo);
2177 replaceImage(newImage);
2178 ThrowImageException;
2179}

◆ cdl()

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

Definition at line 2181 of file Image.cpp.

2182{
2183 modifyImage();
2184 GetPPException;
2185 (void) ColorDecisionListImage(image(),cdl_.c_str(),exceptionInfo);
2186 ThrowImageException;
2187}

◆ channel()

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

Definition at line 2189 of file Image.cpp.

2190{
2191 MagickCore::Image
2192 *newImage;
2193
2194 GetPPException;
2195 newImage=SeparateImage(constImage(),channel_,exceptionInfo);
2196 replaceImage(newImage);
2197 ThrowImageException;
2198}

◆ channelDepth() [1/2]

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

Definition at line 479 of file Image.cpp.

480{
481 size_t
482 channel_depth;
483
484 GetPPException;
485 GetAndSetPPChannelMask(channel_);
486 channel_depth=GetImageDepth(constImage(),exceptionInfo);
487 RestorePPChannelMask;
488 ThrowImageException;
489 return(channel_depth);
490}

◆ channelDepth() [2/2]

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

Definition at line 468 of file Image.cpp.

470{
471 modifyImage();
472 GetPPException;
473 GetAndSetPPChannelMask(channel_);
474 SetImageDepth(image(),depth_,exceptionInfo);
475 RestorePPChannelMask;
476 ThrowImageException;
477}

◆ channels()

size_t Magick::Image::channels ( ) const

Definition at line 492 of file Image.cpp.

493{
494 return(constImage()->number_channels);
495}

◆ charcoal()

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

Definition at line 2200 of file Image.cpp.

2201{
2202 MagickCore::Image
2203 *newImage;
2204
2205 GetPPException;
2206 newImage=CharcoalImage(image(),radius_,sigma_,exceptionInfo);
2207 replaceImage(newImage);
2208 ThrowImageException;
2209}

◆ charcoalChannel()

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

Definition at line 2211 of file Image.cpp.

2213{
2214 MagickCore::Image
2215 *newImage;
2216
2217 GetPPException;
2218 GetAndSetPPChannelMask(channel_);
2219 newImage=CharcoalImage(image(),radius_,sigma_,exceptionInfo);
2220 RestorePPChannelMask;
2221 replaceImage(newImage);
2222 ThrowImageException;
2223}

◆ chop()

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

Definition at line 2225 of file Image.cpp.

2226{
2227 MagickCore::Image
2228 *newImage;
2229
2230 RectangleInfo
2231 chopInfo=geometry_;
2232
2233 GetPPException;
2234 newImage=ChopImage(image(),&chopInfo,exceptionInfo);
2235 replaceImage(newImage);
2236 ThrowImageException;
2237}

◆ chromaBluePrimary() [1/2]

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

Definition at line 2239 of file Image.cpp.

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

◆ chromaBluePrimary() [2/2]

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

Definition at line 2248 of file Image.cpp.

2249{
2250 *x_=constImage()->chromaticity.blue_primary.x;
2251 *y_=constImage()->chromaticity.blue_primary.y;
2252 *z_=constImage()->chromaticity.blue_primary.z;
2253}

◆ chromaGreenPrimary() [1/2]

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

Definition at line 2255 of file Image.cpp.

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

◆ chromaGreenPrimary() [2/2]

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

Definition at line 2264 of file Image.cpp.

2265{
2266 *x_=constImage()->chromaticity.green_primary.x;
2267 *y_=constImage()->chromaticity.green_primary.y;
2268 *z_=constImage()->chromaticity.green_primary.z;
2269}

◆ chromaRedPrimary() [1/2]

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

Definition at line 2271 of file Image.cpp.

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

◆ chromaRedPrimary() [2/2]

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

Definition at line 2280 of file Image.cpp.

2281{
2282 *x_=constImage()->chromaticity.red_primary.x;
2283 *y_=constImage()->chromaticity.red_primary.y;
2284 *z_=constImage()->chromaticity.red_primary.z;
2285}

◆ chromaWhitePoint() [1/2]

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

Definition at line 2287 of file Image.cpp.

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

◆ chromaWhitePoint() [2/2]

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

Definition at line 2296 of file Image.cpp.

2297{
2298 *x_=constImage()->chromaticity.white_point.x;
2299 *y_=constImage()->chromaticity.white_point.y;
2300 *z_=constImage()->chromaticity.white_point.z;
2301}

◆ clamp()

void Magick::Image::clamp ( void  )

Definition at line 2303 of file Image.cpp.

2304{
2305 modifyImage();
2306 GetPPException;
2307 ClampImage(image(),exceptionInfo);
2308 ThrowImageException;
2309}

◆ clampChannel()

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

Definition at line 2311 of file Image.cpp.

2312{
2313 modifyImage();
2314 GetPPException;
2315 GetAndSetPPChannelMask(channel_);
2316 ClampImage(image(),exceptionInfo);
2317 RestorePPChannelMask;
2318 ThrowImageException;
2319}

◆ classType() [1/2]

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

Definition at line 497 of file Image.cpp.

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

◆ classType() [2/2]

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

Definition at line 522 of file Image.cpp.

523{
524 return static_cast<Magick::ClassType>(constImage()->storage_class);
525}

◆ clip()

void Magick::Image::clip ( void  )

Definition at line 2321 of file Image.cpp.

2322{
2323 modifyImage();
2324 GetPPException;
2325 ClipImage(image(),exceptionInfo);
2326 ThrowImageException;
2327}

◆ clipPath()

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

Definition at line 2329 of file Image.cpp.

2330{
2331 modifyImage();
2332 GetPPException;
2333 ClipImagePath(image(),pathname_.c_str(),(MagickBooleanType) inside_,
2334 exceptionInfo);
2335 ThrowImageException;
2336}

◆ clut()

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

Definition at line 2338 of file Image.cpp.

2340{
2341 modifyImage();
2342 GetPPException;
2343 ClutImage(image(),clutImage_.constImage(),method,exceptionInfo);
2344 ThrowImageException;
2345}

◆ clutChannel()

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

Definition at line 2347 of file Image.cpp.

2349{
2350 modifyImage();
2351 GetPPException;
2352 GetAndSetPPChannelMask(channel_);
2353 ClutImage(image(),clutImage_.constImage(),method,exceptionInfo);
2354 RestorePPChannelMask;
2355 ThrowImageException;
2356}

◆ colorFuzz() [1/2]

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

Definition at line 527 of file Image.cpp.

528{
529 modifyImage();
530 image()->fuzz=fuzz_;
531 options()->colorFuzz(fuzz_);
532}

◆ colorFuzz() [2/2]

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

Definition at line 534 of file Image.cpp.

535{
536 return(constOptions()->colorFuzz());
537}

◆ colorize() [1/2]

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

Definition at line 2358 of file Image.cpp.

2359{
2360 colorize(alpha_,alpha_,alpha_,penColor_);
2361}

◆ 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 2363 of file Image.cpp.

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

◆ colorMap() [1/2]

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

Definition at line 2415 of file Image.cpp.

2416{
2417 if (!constImage()->colormap)
2418 {
2419 throwExceptionExplicit(MagickCore::OptionError,
2420 "Image does not contain a colormap");
2421 return(Color());
2422 }
2423
2424 if (index_ > constImage()->colors-1)
2425 throwExceptionExplicit(MagickCore::OptionError,"Index out of range");
2426
2427 return(Magick::Color((constImage()->colormap)[index_]));
2428}

◆ colorMap() [2/2]

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

Definition at line 2390 of file Image.cpp.

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

◆ colorMapSize() [1/2]

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

Definition at line 539 of file Image.cpp.

540{
541 if (entries_ >MaxColormapSize)
542 throwExceptionExplicit(MagickCore::OptionError,
543 "Colormap entries must not exceed MaxColormapSize");
544
545 modifyImage();
546 GetPPException;
547 (void) AcquireImageColormap(image(),entries_,exceptionInfo);
548 ThrowImageException;
549}

◆ colorMapSize() [2/2]

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

Definition at line 551 of file Image.cpp.

552{
553 if (!constImage()->colormap)
554 throwExceptionExplicit(MagickCore::OptionError,
555 "Image does not contain a colormap");
556
557 return(constImage()->colors);
558}

◆ colorMatrix()

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

Definition at line 2430 of file Image.cpp.

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

◆ colorSpace() [1/2]

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

Definition at line 560 of file Image.cpp.

561{
562 if (image()->colorspace == colorSpace_)
563 return;
564
565 modifyImage();
566 GetPPException;
567 TransformImageColorspace(image(),colorSpace_,exceptionInfo);
568 ThrowImageException;
569}

◆ colorSpace() [2/2]

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

Definition at line 571 of file Image.cpp.

572{
573 return (constImage()->colorspace);
574}

◆ colorSpaceType() [1/2]

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

Definition at line 576 of file Image.cpp.

577{
578 modifyImage();
579 GetPPException;
580 SetImageColorspace(image(),colorSpace_,exceptionInfo);
581 ThrowImageException;
582 options()->colorspaceType(colorSpace_);
583}

◆ colorSpaceType() [2/2]

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

Definition at line 585 of file Image.cpp.

586{
587 return(constOptions()->colorspaceType());
588}

◆ columns()

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

Definition at line 590 of file Image.cpp.

591{
592 return(constImage()->columns);
593}

◆ comment() [1/2]

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

Definition at line 595 of file Image.cpp.

596{
597 modifyImage();
598 GetPPException;
599 SetImageProperty(image(),"Comment",NULL,exceptionInfo);
600 if (comment_.length() > 0)
601 SetImageProperty(image(),"Comment",comment_.c_str(),exceptionInfo);
602 ThrowImageException;
603}

◆ comment() [2/2]

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

Definition at line 605 of file Image.cpp.

606{
607 const char
608 *value;
609
610 GetPPException;
611 value=GetImageProperty(constImage(),"Comment",exceptionInfo);
612 ThrowImageException;
613
614 if (value)
615 return(std::string(value));
616
617 return(std::string()); // Intentionally no exception
618}

◆ compare() [1/3]

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

Definition at line 2459 of file Image.cpp.

2460{
2461 bool
2462 status;
2463
2464 Image
2465 ref=reference_;
2466
2467 GetPPException;
2468 status=static_cast<bool>(IsImagesEqual(constImage(),ref.constImage(),
2469 exceptionInfo));
2470 ThrowImageException;
2471 return(status);
2472}

◆ compare() [2/3]

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

Definition at line 2474 of file Image.cpp.

2475{
2476 double
2477 distortion=0.0;
2478
2479 GetPPException;
2480 GetImageDistortion(image(),reference_.constImage(),metric_,&distortion,
2481 exceptionInfo);
2482 ThrowImageException;
2483 return(distortion);
2484}

◆ compare() [3/3]

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

Definition at line 2501 of file Image.cpp.

2503{
2504 MagickCore::Image
2505 *newImage;
2506
2507 GetPPException;
2508 newImage=CompareImages(image(),reference_.constImage(),metric_,distortion,
2509 exceptionInfo);
2510 ThrowImageException;
2511 if (newImage == (MagickCore::Image *) NULL)
2512 return(Magick::Image());
2513 else
2514 return(Magick::Image(newImage));
2515}

◆ compareChannel() [1/2]

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

Definition at line 2486 of file Image.cpp.

2488{
2489 double
2490 distortion=0.0;
2491
2492 GetPPException;
2493 GetAndSetPPChannelMask(channel_);
2494 GetImageDistortion(image(),reference_.constImage(),metric_,&distortion,
2495 exceptionInfo);
2496 RestorePPChannelMask;
2497 ThrowImageException;
2498 return(distortion);
2499}

◆ compareChannel() [2/2]

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

Definition at line 2517 of file Image.cpp.

2519{
2520 MagickCore::Image
2521 *newImage;
2522
2523 GetPPException;
2524 GetAndSetPPChannelMask(channel_);
2525 newImage=CompareImages(image(),reference_.constImage(),metric_,distortion,
2526 exceptionInfo);
2527 RestorePPChannelMask;
2528 ThrowImageException;
2529 if (newImage == (MagickCore::Image *) NULL)
2530 return(Magick::Image());
2531 else
2532 return(Magick::Image(newImage));
2533}

◆ compose() [1/2]

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

Definition at line 620 of file Image.cpp.

621{
622 image()->compose=compose_;
623}

◆ compose() [2/2]

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

Definition at line 625 of file Image.cpp.

626{
627 return(constImage()->compose);
628}

◆ composite() [1/2]

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

Definition at line 2535 of file Image.cpp.

2537{
2538 size_t
2539 height=rows(),
2540 width=columns();
2541
2542 ssize_t
2543 x=offset_.xOff(),
2544 y=offset_.yOff();
2545
2546 ParseMetaGeometry(static_cast<std::string>(offset_).c_str(),&x,&y,&width,
2547 &height);
2548
2549 modifyImage();
2550 GetPPException;
2551 CompositeImage(image(),compositeImage_.constImage(),compose_,MagickTrue,
2552 x,y,exceptionInfo);
2553 ThrowImageException;
2554}

◆ composite() [2/2]

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

Definition at line 2556 of file Image.cpp.

2558{
2559 RectangleInfo
2560 geometry;
2561
2562 modifyImage();
2563 SetGeometry(compositeImage_.constImage(),&geometry);
2564 GravityAdjustGeometry(columns(),rows(),gravity_,&geometry);
2565
2566 GetPPException;
2567 CompositeImage(image(),compositeImage_.constImage(),compose_,MagickTrue,
2568 geometry.x,geometry.y,exceptionInfo);
2569 ThrowImageException;
2570}

◆ compressType() [1/2]

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

Definition at line 630 of file Image.cpp.

631{
632 modifyImage();
633 image()->compression=compressType_;
634 options()->compressType(compressType_);
635}

◆ compressType() [2/2]

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

Definition at line 637 of file Image.cpp.

638{
639 return(constImage()->compression);
640}

◆ connectedComponents()

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

Definition at line 2585 of file Image.cpp.

2586{
2587 MagickCore::Image
2588 *newImage;
2589
2590 GetPPException;
2591 newImage=ConnectedComponentsImage(constImage(),connectivity_,
2592 (CCObjectInfo **) NULL,exceptionInfo);
2593 replaceImage(newImage);
2594 ThrowImageException;
2595}

◆ constImage()

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

Definition at line 5028 of file Image.cpp.

5029{
5030 return(_imgRef->image());
5031}

◆ constImageInfo()

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

Definition at line 5038 of file Image.cpp.

5039{
5040 return(_imgRef->options()->imageInfo());
5041}

◆ constOptions()

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

Definition at line 5048 of file Image.cpp.

5049{
5050 return(_imgRef->options());
5051}

◆ constQuantizeInfo()

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

Definition at line 5058 of file Image.cpp.

5059{
5060 return(_imgRef->options()->quantizeInfo());
5061}

◆ contrast()

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

Definition at line 2597 of file Image.cpp.

2598{
2599 modifyImage();
2600 GetPPException;
2601 ContrastImage(image(),(MagickBooleanType) sharpen_,exceptionInfo);
2602 ThrowImageException;
2603}

◆ contrastStretch()

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

Definition at line 2605 of file Image.cpp.

2607{
2608 modifyImage();
2609 GetPPException;
2610 ContrastStretchImage(image(),blackPoint_,whitePoint_,exceptionInfo);
2611 ThrowImageException;
2612}

◆ contrastStretchChannel()

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

Definition at line 2614 of file Image.cpp.

2616{
2617 modifyImage();
2618 GetPPException;
2619 GetAndSetPPChannelMask(channel_);
2620 ContrastStretchImage(image(),blackPoint_,whitePoint_,exceptionInfo);
2621 RestorePPChannelMask;
2622 ThrowImageException;
2623}

◆ convolve()

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

Definition at line 2625 of file Image.cpp.

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

◆ copyPixels()

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

Definition at line 2652 of file Image.cpp.

2654{
2655 const OffsetInfo
2656 offset=offset_;
2657
2658 const RectangleInfo
2659 geometry=geometry_;
2660
2661 GetPPException;
2662 (void) CopyImagePixels(image(),source_.constImage(),&geometry,&offset,
2663 exceptionInfo);
2664 ThrowImageException;
2665}

◆ crop()

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

Definition at line 2667 of file Image.cpp.

2668{
2669 MagickCore::Image
2670 *newImage;
2671
2672 RectangleInfo
2673 cropInfo=geometry_;
2674
2675 GetPPException;
2676 newImage=CropImage(constImage(),&cropInfo,exceptionInfo);
2677 replaceImage(newImage);
2678 ThrowImageException;
2679}

◆ cycleColormap()

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

Definition at line 2681 of file Image.cpp.

2682{
2683 modifyImage();
2684 GetPPException;
2685 CycleColormapImage(image(),amount_,exceptionInfo);
2686 ThrowImageException;
2687}

◆ debug() [1/2]

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

Definition at line 642 of file Image.cpp.

643{
644 modifyImage();
645 options()->debug(flag_);
646}

◆ debug() [2/2]

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

Definition at line 648 of file Image.cpp.

649{
650 return(constOptions()->debug());
651}

◆ decipher()

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

Definition at line 2689 of file Image.cpp.

2690{
2691 modifyImage();
2692 GetPPException;
2693 DecipherImage(image(),passphrase_.c_str(),exceptionInfo);
2694 ThrowImageException;
2695}

◆ defineSet() [1/2]

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

Definition at line 2711 of file Image.cpp.

2713{
2714 const char
2715 *option;
2716
2717 std::string
2718 key;
2719
2720 key=magick_ + ":" + key_;
2721 option=GetImageOption(constImageInfo(),key.c_str());
2722 if (option)
2723 return(true);
2724 return(false);
2725}

◆ defineSet() [2/2]

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

Definition at line 2697 of file Image.cpp.

2699{
2700 std::string
2701 definition;
2702
2703 modifyImage();
2704 definition=magick_ + ":" + key_;
2705 if (flag_)
2706 (void) SetImageOption(imageInfo(),definition.c_str(),"");
2707 else
2708 DeleteImageOption(imageInfo(),definition.c_str());
2709}

◆ defineValue() [1/2]

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

Definition at line 2740 of file Image.cpp.

2742{
2743 const char
2744 *option;
2745
2746 std::string
2747 definition;
2748
2749 definition=magick_ + ":" + key_;
2750 option=GetImageOption(constImageInfo(),definition.c_str());
2751 if (option)
2752 return(std::string(option));
2753 return(std::string());
2754}

◆ defineValue() [2/2]

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

Definition at line 2727 of file Image.cpp.

2729{
2730 std::string
2731 format,
2732 option;
2733
2734 modifyImage();
2735 format=magick_ + ":" + key_;
2736 option=value_;
2737 (void) SetImageOption(imageInfo(),format.c_str(),option.c_str());
2738}

◆ density() [1/2]

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

Definition at line 653 of file Image.cpp.

654{
655 modifyImage();
656 options()->density(density_);
657 if (density_.isValid())
658 {
659 image()->resolution.x=density_.x();
660 if (density_.y() != 0.0)
661 image()->resolution.y=density_.y();
662 else
663 image()->resolution.y=density_.x();
664 }
665 else
666 {
667 // Reset to default
668 image()->resolution.x=0.0;
669 image()->resolution.y=0.0;
670 }
671}

◆ density() [2/2]

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

Definition at line 673 of file Image.cpp.

674{
675 if (isValid())
676 {
677 ssize_t
678 x_resolution=72,
679 y_resolution=72;
680
681 if (constImage()->resolution.x > 0.0)
682 x_resolution=constImage()->resolution.x;
683
684 if (constImage()->resolution.y > 0.0)
685 y_resolution=constImage()->resolution.y;
686
687 return(Point(x_resolution,y_resolution));
688 }
689
690 return(constOptions()->density());
691}

◆ depth() [1/2]

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

Definition at line 693 of file Image.cpp.

694{
695 modifyImage();
696 image()->depth=depth_;
697 options()->depth(depth_);
698}

◆ depth() [2/2]

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

Definition at line 700 of file Image.cpp.

701{
702 return(constImage()->depth);
703}

◆ deskew()

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

Definition at line 2756 of file Image.cpp.

2757{
2758 MagickCore::Image
2759 *newImage;
2760
2761 GetPPException;
2762 newImage=DeskewImage(constImage(),threshold_,exceptionInfo);
2763 replaceImage(newImage);
2764 ThrowImageException;
2765}

◆ despeckle()

void Magick::Image::despeckle ( void  )

Definition at line 2767 of file Image.cpp.

2768{
2769 MagickCore::Image
2770 *newImage;
2771
2772 GetPPException;
2773 newImage=DespeckleImage(constImage(),exceptionInfo);
2774 replaceImage(newImage);
2775 ThrowImageException;
2776}

◆ directory()

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

Definition at line 705 of file Image.cpp.

706{
707 if (constImage()->directory)
708 return(std::string(constImage()->directory));
709
710 if (!quiet())
711 throwExceptionExplicit(MagickCore::CorruptImageWarning,
712 "Image does not contain a directory");
713
714 return(std::string());
715}

◆ display()

void Magick::Image::display ( void  )

Definition at line 2778 of file Image.cpp.

2779{
2780 GetPPException;
2781 DisplayImages(imageInfo(),image(),exceptionInfo);
2782 ThrowImageException;
2783}

◆ distort()

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

Definition at line 2785 of file Image.cpp.

2787{
2788 MagickCore::Image
2789 *newImage;
2790
2791 GetPPException;
2792 newImage=DistortImage(constImage(), method_,numberArguments_,arguments_,
2793 bestfit_ == true ? MagickTrue : MagickFalse,exceptionInfo);
2794 replaceImage(newImage);
2795 ThrowImageException;
2796}

◆ draw() [1/2]

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

Definition at line 2798 of file Image.cpp.

2799{
2800 DrawingWand
2801 *wand;
2802
2803 modifyImage();
2804
2805 wand=AcquireDrawingWand(options()->drawInfo(),image());
2806
2807 if(wand)
2808 {
2809 drawable_.operator()(wand);
2810
2811 DrawRender(wand);
2812
2813 ClonePPDrawException(wand);
2814 wand=DestroyDrawingWand(wand);
2815 ThrowPPDrawException(quiet());
2816 }
2817}

◆ draw() [2/2]

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

Definition at line 2819 of file Image.cpp.

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

◆ edge()

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

Definition at line 2847 of file Image.cpp.

2848{
2849 MagickCore::Image
2850 *newImage;
2851
2852 GetPPException;
2853 newImage=EdgeImage(constImage(),radius_,exceptionInfo);
2854 replaceImage(newImage);
2855 ThrowImageException;
2856}

◆ emboss()

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

Definition at line 2858 of file Image.cpp.

2859{
2860 MagickCore::Image
2861 *newImage;
2862
2863 GetPPException;
2864 newImage=EmbossImage(constImage(),radius_,sigma_,exceptionInfo);
2865 replaceImage(newImage);
2866 ThrowImageException;
2867}

◆ encipher()

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

Definition at line 2869 of file Image.cpp.

2870{
2871 modifyImage();
2872 GetPPException;
2873 EncipherImage(image(),passphrase_.c_str(),exceptionInfo);
2874 ThrowImageException;
2875}

◆ endian() [1/2]

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

Definition at line 717 of file Image.cpp.

718{
719 modifyImage();
720 options()->endian(endian_);
721 image()->endian=endian_;
722}

◆ endian() [2/2]

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

Definition at line 724 of file Image.cpp.

725{
726 return(constImage()->endian);
727}

◆ enhance()

void Magick::Image::enhance ( void  )

Definition at line 2877 of file Image.cpp.

2878{
2879 MagickCore::Image
2880 *newImage;
2881
2882 GetPPException;
2883 newImage=EnhanceImage(constImage(),exceptionInfo);
2884 replaceImage(newImage);
2885 ThrowImageException;
2886}

◆ equalize()

void Magick::Image::equalize ( void  )

Definition at line 2888 of file Image.cpp.

2889{
2890 modifyImage();
2891 GetPPException;
2892 EqualizeImage(image(),exceptionInfo);
2893 ThrowImageException;
2894}

◆ erase()

void Magick::Image::erase ( void  )

Definition at line 2896 of file Image.cpp.

2897{
2898 modifyImage();
2899 GetPPException;
2900 (void) SetImageBackgroundColor(image(),exceptionInfo);
2901 ThrowImageException;
2902}

◆ evaluate() [1/2]

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

Definition at line 2904 of file Image.cpp.

2906{
2907 GetPPException;
2908 GetAndSetPPChannelMask(channel_);
2909 EvaluateImage(image(),operator_,rvalue_,exceptionInfo);
2910 RestorePPChannelMask;
2911 ThrowImageException;
2912}

◆ evaluate() [2/2]

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

Definition at line 2914 of file Image.cpp.

2917{
2918 GetPPException;
2919 GetAndSetPPChannelMask(channel_);
2920 FunctionImage(image(),function_,number_parameters_,parameters_,
2921 exceptionInfo);
2922 RestorePPChannelMask;
2923 ThrowImageException;
2924}

◆ exifProfile() [1/2]

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

Definition at line 729 of file Image.cpp.

730{
731 modifyImage();
732
733 if (exifProfile_.data() != 0)
734 {
735 StringInfo
736 *exif_profile;
737
738 exif_profile=AcquireStringInfo(exifProfile_.length());
739 SetStringInfoDatum(exif_profile,(unsigned char *) exifProfile_.data());
740 GetPPException;
741 (void) SetImageProfile(image(),"exif",exif_profile,exceptionInfo);
742 exif_profile=DestroyStringInfo(exif_profile);
743 ThrowImageException;
744 }
745}

◆ exifProfile() [2/2]

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

Definition at line 747 of file Image.cpp.

748{
749 const StringInfo
750 *exif_profile;
751
752 exif_profile=GetImageProfile(constImage(),"exif");
753 if (exif_profile == (StringInfo *) NULL)
754 return(Blob());
755 return(Blob(GetStringInfoDatum(exif_profile),
756 GetStringInfoLength(exif_profile)));
757}

◆ extent() [1/4]

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

Definition at line 2953 of file Image.cpp.

2954{
2955 MagickCore::Image
2956 *newImage;
2957
2958 RectangleInfo
2959 extentInfo=geometry_;
2960
2961 modifyImage();
2962 extentInfo.x=geometry_.xOff();
2963 extentInfo.y=geometry_.yOff();
2964 GetPPException;
2965 newImage=ExtentImage(image(),&extentInfo,exceptionInfo);
2966 replaceImage(newImage);
2967 ThrowImageException;
2968}

◆ extent() [2/4]

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

Definition at line 2970 of file Image.cpp.

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

◆ extent() [3/4]

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

Definition at line 2977 of file Image.cpp.

2979{
2980 backgroundColor(backgroundColor_);
2981 extent(geometry_,gravity_);
2982}

◆ extent() [4/4]

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

Definition at line 2984 of file Image.cpp.

2986{
2987 RectangleInfo
2988 geometry;
2989
2990 SetGeometry(image(),&geometry);
2991 geometry.width=geometry_.width();
2992 geometry.height=geometry_.height();
2993 GravityAdjustGeometry(image()->columns,image()->rows,gravity_,&geometry);
2994 extent(geometry);
2995}

◆ fileName() [1/2]

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

Definition at line 759 of file Image.cpp.

760{
761 ssize_t
762 max_length;
763
764 modifyImage();
765
766 max_length=sizeof(image()->filename)-1;
767 fileName_.copy(image()->filename,(size_t) max_length);
768 if ((ssize_t) fileName_.length() > max_length)
769 image()->filename[max_length]=0;
770 else
771 image()->filename[fileName_.length()]=0;
772
773 options()->fileName(fileName_);
774}

◆ fileName() [2/2]

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

Definition at line 776 of file Image.cpp.

777{
778 return(constOptions()->fileName());
779}

◆ fileSize()

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

Definition at line 781 of file Image.cpp.

782{
783 return(GetBlobSize(constImage()));
784}

◆ fillColor() [1/2]

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

Definition at line 786 of file Image.cpp.

787{
788 modifyImage();
789 options()->fillColor(fillColor_);
790}

◆ fillColor() [2/2]

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

Definition at line 792 of file Image.cpp.

793{
794 return(constOptions()->fillColor());
795}

◆ fillPattern() [1/2]

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

Definition at line 808 of file Image.cpp.

809{
810 modifyImage();
811 if (fillPattern_.isValid())
812 options()->fillPattern(fillPattern_.constImage());
813 else
814 options()->fillPattern(static_cast<MagickCore::Image*>(NULL));
815}

◆ fillPattern() [2/2]

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

Definition at line 817 of file Image.cpp.

818{
819 // FIXME: This is inordinately inefficient
820 const MagickCore::Image
821 *tmpTexture;
822
823 Image
824 texture;
825
826 tmpTexture=constOptions()->fillPattern();
827
828 if (tmpTexture)
829 {
830 MagickCore::Image
831 *image;
832
833 GetPPException;
834 image=CloneImage(tmpTexture,0,0,MagickTrue,exceptionInfo);
835 texture.replaceImage(image);
836 ThrowImageException;
837 }
838 return(texture);
839}

◆ fillRule() [1/2]

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

Definition at line 797 of file Image.cpp.

798{
799 modifyImage();
800 options()->fillRule(fillRule_);
801}

◆ fillRule() [2/2]

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

Definition at line 803 of file Image.cpp.

804{
805 return constOptions()->fillRule();
806}

◆ filterType() [1/2]

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

Definition at line 841 of file Image.cpp.

842{
843 modifyImage();
844 image()->filter=filterType_;
845}

◆ filterType() [2/2]

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

Definition at line 847 of file Image.cpp.

848{
849 return(constImage()->filter);
850}

◆ flip()

void Magick::Image::flip ( void  )

Definition at line 2997 of file Image.cpp.

2998{
2999 MagickCore::Image
3000 *newImage;
3001
3002 GetPPException;
3003 newImage=FlipImage(constImage(),exceptionInfo);
3004 replaceImage(newImage);
3005 ThrowImageException;
3006}

◆ 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 5120 of file Image.cpp.

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

◆ 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 3026 of file Image.cpp.

3028{
3029 PixelInfo
3030 target;
3031
3032 modifyImage();
3033
3034 target=static_cast<PixelInfo>(target_);
3035 target.alpha=alpha_;
3036 GetPPException;
3037 GetAndSetPPChannelMask(AlphaChannel);
3038 FloodfillPaintImage(image(),options()->drawInfo(),&target,x_,y_,
3039 (MagickBooleanType)invert_,exceptionInfo);
3040 RestorePPChannelMask;
3041 ThrowImageException;
3042}

◆ floodFillColor() [1/2]

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

Definition at line 3044 of file Image.cpp.

3046{
3047 floodFillColor(point_.xOff(),point_.yOff(),fillColor_,invert_);
3048}

◆ floodFillColor() [2/2]

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

Definition at line 3062 of file Image.cpp.

3065{
3066 floodFillColor(point_.xOff(),point_.yOff(),fillColor_,borderColor_,invert_);
3067}

◆ floodFillTexture() [1/2]

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

Definition at line 3082 of file Image.cpp.

3084{
3085 floodFillTexture(point_.xOff(),point_.yOff(),texture_,invert_);
3086}

◆ floodFillTexture() [2/2]

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

Definition at line 3100 of file Image.cpp.

3103{
3104 floodFillTexture(point_.xOff(),point_.yOff(),texture_,borderColor_,invert_);
3105}

◆ flop()

void Magick::Image::flop ( void  )

Definition at line 3120 of file Image.cpp.

3121{
3122 MagickCore::Image
3123 *newImage;
3124
3125 GetPPException;
3126 newImage=FlopImage(constImage(),exceptionInfo);
3127 replaceImage(newImage);
3128 ThrowImageException;
3129}

◆ font() [1/2]

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

Definition at line 852 of file Image.cpp.

853{
854 modifyImage();
855 options()->font(font_);
856}

◆ font() [2/2]

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

Definition at line 858 of file Image.cpp.

859{
860 return(constOptions()->font());
861}

◆ fontFamily() [1/2]

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

Definition at line 863 of file Image.cpp.

864{
865 modifyImage();
866 options()->fontFamily(family_);
867}

◆ fontFamily() [2/2]

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

Definition at line 869 of file Image.cpp.

870{
871 return(constOptions()->fontFamily());
872}

◆ fontPointsize() [1/2]

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

Definition at line 874 of file Image.cpp.

875{
876 modifyImage();
877 options()->fontPointsize(pointSize_);
878}

◆ fontPointsize() [2/2]

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

Definition at line 880 of file Image.cpp.

881{
882 return(constOptions()->fontPointsize());
883}

◆ fontStyle() [1/2]

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

Definition at line 885 of file Image.cpp.

886{
887 modifyImage();
888 options()->fontStyle(pointSize_);
889}

◆ fontStyle() [2/2]

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

Definition at line 891 of file Image.cpp.

892{
893 return(constOptions()->fontStyle());
894}

◆ fontTypeMetrics()

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

Definition at line 3131 of file Image.cpp.

3133{
3134 DrawInfo
3135 *drawInfo;
3136
3137 drawInfo=options()->drawInfo();
3138 drawInfo->text=DestroyString(drawInfo->text);
3139 drawInfo->text=const_cast<char *>(text_.c_str());
3140 GetPPException;
3141 GetTypeMetrics(image(),drawInfo,&(metrics->_typeMetric),exceptionInfo);
3142 drawInfo->text=(char *) NULL;
3143 ThrowImageException;
3144}

◆ fontTypeMetricsMultiline()

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

Definition at line 3146 of file Image.cpp.

3148{
3149 DrawInfo
3150 *drawInfo;
3151
3152 drawInfo=options()->drawInfo();
3153 drawInfo->text=DestroyString(drawInfo->text);
3154 drawInfo->text=const_cast<char *>(text_.c_str());
3155 GetPPException;
3156 (void) GetMultilineTypeMetrics(image(),drawInfo,&(metrics->_typeMetric),
3157 exceptionInfo);
3158 drawInfo->text=(char *) NULL;
3159 ThrowImageException;
3160}

◆ fontWeight() [1/2]

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

Definition at line 896 of file Image.cpp.

897{
898 modifyImage();
899 options()->fontWeight(weight_);
900}

◆ fontWeight() [2/2]

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

Definition at line 902 of file Image.cpp.

903{
904 return(constOptions()->fontWeight());
905}

◆ format()

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

Definition at line 907 of file Image.cpp.

908{
909 const MagickInfo
910 *magick_info;
911
912 GetPPException;
913 magick_info=GetMagickInfo(constImage()->magick,exceptionInfo);
914 ThrowImageException;
915
916 if ((magick_info != 0) && (*magick_info->description != '\0'))
917 return(std::string(magick_info->description));
918
919 if (!quiet())
920 throwExceptionExplicit(MagickCore::CorruptImageWarning,
921 "Unrecognized image magick type");
922
923 return(std::string());
924}

◆ formatExpression()

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

Definition at line 926 of file Image.cpp.

927{
928 char
929 *text;
930
931 std::string
932 text_string;
933
934 GetPPException;
935 modifyImage();
936 text=InterpretImageProperties(imageInfo(),image(),expression.c_str(),
937 exceptionInfo);
938 if (text != (char *) NULL)
939 {
940 text_string=std::string(text);
941 text=DestroyString(text);
942 }
943 ThrowImageException;
944 return(text_string);
945}

◆ frame()

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

Definition at line 3162 of file Image.cpp.

3163{
3164 FrameInfo
3165 info;
3166
3167 MagickCore::Image
3168 *newImage;
3169
3170 info.x=static_cast<ssize_t>(geometry_.width());
3171 info.y=static_cast<ssize_t>(geometry_.height());
3172 info.width=columns() + (static_cast<size_t>(info.x) << 1);
3173 info.height=rows() + (static_cast<size_t>(info.y) << 1);
3174 info.outer_bevel=geometry_.xOff();
3175 info.inner_bevel=geometry_.yOff();
3176
3177 GetPPException;
3178 newImage=FrameImage(constImage(),&info,image()->compose,exceptionInfo);
3179 replaceImage(newImage);
3180 ThrowImageException;
3181}

◆ fx() [1/2]

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

Definition at line 3205 of file Image.cpp.

3206{
3207 MagickCore::Image
3208 *newImage;
3209
3210 GetPPException;
3211 newImage=FxImage(constImage(),expression_.c_str(),exceptionInfo);
3212 replaceImage(newImage);
3213 ThrowImageException;
3214}

◆ fx() [2/2]

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

Definition at line 3216 of file Image.cpp.

3218{
3219 MagickCore::Image
3220 *newImage;
3221
3222 GetPPException;
3223 GetAndSetPPChannelMask(channel_);
3224 newImage=FxImage(constImage(),expression_.c_str(),exceptionInfo);
3225 RestorePPChannelMask;
3226 replaceImage(newImage);
3227 ThrowImageException;
3228}

◆ gamma() [1/3]

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

Definition at line 3230 of file Image.cpp.

3231{
3232 modifyImage();
3233 GetPPException;
3234 GammaImage(image(),gamma_,exceptionInfo);
3235 ThrowImageException;
3236}

◆ gamma() [2/3]

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

Definition at line 3238 of file Image.cpp.

3240{
3241 modifyImage();
3242 GetPPException;
3243 GetAndSetPPChannelMask(RedChannel);
3244 (void) GammaImage(image(),gammaRed_,exceptionInfo);
3245 SetPPChannelMask(GreenChannel);
3246 (void) GammaImage(image(),gammaGreen_,exceptionInfo);
3247 SetPPChannelMask(BlueChannel);
3248 (void) GammaImage(image(),gammaBlue_,exceptionInfo);
3249 RestorePPChannelMask;
3250 ThrowImageException;
3251}

◆ gamma() [3/3]

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

Definition at line 947 of file Image.cpp.

948{
949 return(constImage()->gamma);
950}

◆ gaussianBlur()

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

Definition at line 3253 of file Image.cpp.

3254{
3255 MagickCore::Image
3256 *newImage;
3257
3258 GetPPException;
3259 newImage=GaussianBlurImage(constImage(),radius_,sigma_,exceptionInfo);
3260 replaceImage(newImage);
3261 ThrowImageException;
3262}

◆ gaussianBlurChannel()

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

Definition at line 3264 of file Image.cpp.

3266{
3267 MagickCore::Image
3268 *newImage;
3269
3270 GetPPException;
3271 GetAndSetPPChannelMask(channel_);
3272 newImage=GaussianBlurImage(constImage(),radius_,sigma_,exceptionInfo);
3273 RestorePPChannelMask;
3274 replaceImage(newImage);
3275 ThrowImageException;
3276}

◆ geometry()

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

Definition at line 952 of file Image.cpp.

953{
954 if (constImage()->geometry)
955 return Geometry(constImage()->geometry);
956
957 if (!quiet())
958 throwExceptionExplicit(MagickCore::OptionWarning,
959 "Image does not contain a geometry");
960
961 return(Geometry());
962}

◆ getConstMetacontent()

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

Definition at line 3290 of file Image.cpp.

3291{
3292 const void
3293 *result;
3294
3295 result=GetVirtualMetacontent(constImage());
3296
3297 if(!result)
3298 throwExceptionExplicit(MagickCore::OptionError,
3299 "Unable to retrieve meta content.");
3300
3301 return(result);
3302}

◆ 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 3278 of file Image.cpp.

3280{
3281 const Quantum
3282 *p;
3283
3284 GetPPException;
3285 p=GetVirtualPixels(constImage(),x_, y_,columns_, rows_,exceptionInfo);
3286 ThrowImageException;
3287 return(p);
3288}

◆ getMetacontent()

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

Definition at line 3304 of file Image.cpp.

3305{
3306 void
3307 *result;
3308
3309 result=GetAuthenticMetacontent(image());
3310
3311 if(!result)
3312 throwExceptionExplicit(MagickCore::OptionError,
3313 "Unable to retrieve meta content.");
3314
3315 return(result);
3316}

◆ 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 3318 of file Image.cpp.

3320{
3321 Quantum
3322 *result;
3323
3324 modifyImage();
3325 GetPPException;
3326 result=GetAuthenticPixels(image(),x_, y_,columns_,rows_,exceptionInfo);
3327 ThrowImageException;
3328
3329 return(result);
3330}

◆ gifDisposeMethod()

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

Definition at line 971 of file Image.cpp.

972{
973 return(constImage()->dispose);
974}

◆ grayscale()

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

Definition at line 3332 of file Image.cpp.

3333{
3334 modifyImage();
3335 GetPPException;
3336 (void) GrayscaleImage(image(),method_,exceptionInfo);
3337 ThrowImageException;
3338}

◆ haldClut()

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

Definition at line 3340 of file Image.cpp.

3341{
3342 modifyImage();
3343 GetPPException;
3344 (void) HaldClutImage(image(),clutImage_.constImage(),exceptionInfo);
3345 ThrowImageException;
3346}

◆ hasChannel()

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

Definition at line 976 of file Image.cpp.

977{
978 if (GetPixelChannelTraits(constImage(),channel) == UndefinedPixelTrait)
979 return(false);
980
981 if (channel == GreenPixelChannel || channel == BluePixelChannel)
982 return (GetPixelChannelOffset(constImage(),channel) == (ssize_t)channel);
983
984 return(true);
985}

◆ highlightColor()

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

Definition at line 987 of file Image.cpp.

988{
989 std::string
990 value;
991
992 value=color_;
993 artifact("compare:highlight-color",value);
994}

◆ houghLine()

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

Definition at line 3348 of file Image.cpp.

3350{
3351 MagickCore::Image
3352 *newImage;
3353
3354 GetPPException;
3355 newImage=HoughLineImage(constImage(),width_,height_,threshold_,
3356 exceptionInfo);
3357 replaceImage(newImage);
3358 ThrowImageException;
3359}

◆ iccColorProfile() [1/2]

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

Definition at line 996 of file Image.cpp.

997{
998 profile("icc",colorProfile_);
999}

◆ iccColorProfile() [2/2]

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

Definition at line 1001 of file Image.cpp.

1002{
1003 const StringInfo
1004 *color_profile;
1005
1006 color_profile=GetImageProfile(constImage(),"icc");
1007 if (color_profile == (StringInfo *) NULL)
1008 return(Blob());
1009 return(Blob(GetStringInfoDatum(color_profile),GetStringInfoLength(
1010 color_profile)));
1011}

◆ identifyType()

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

Definition at line 3361 of file Image.cpp.

3362{
3363 ImageType
3364 image_type;
3365
3366 GetPPException;
3367 image_type=IdentifyImageType(constImage(),exceptionInfo);
3368 ThrowImageException;
3369 return(image_type);
3370}

◆ image()

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

Definition at line 5023 of file Image.cpp.

5024{
5025 return(_imgRef->image());
5026}

◆ imageInfo()

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

Definition at line 5033 of file Image.cpp.

5034{
5035 return(_imgRef->options()->imageInfo());
5036}

◆ implode()

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

Definition at line 3372 of file Image.cpp.

3373{
3374 MagickCore::Image
3375 *newImage;
3376
3377 GetPPException;
3378 newImage=ImplodeImage(constImage(),factor_,image()->interpolate,
3379 exceptionInfo);
3380 replaceImage(newImage);
3381 ThrowImageException;
3382}

◆ interlaceType() [1/2]

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

Definition at line 1013 of file Image.cpp.

1014{
1015 modifyImage();
1016 image()->interlace=interlace_;
1017 options()->interlaceType(interlace_);
1018}

◆ interlaceType() [2/2]

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

Definition at line 1020 of file Image.cpp.

1021{
1022 return(constImage()->interlace);
1023}

◆ interpolate() [1/2]

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

Definition at line 1025 of file Image.cpp.

1026{
1027 modifyImage();
1028 image()->interpolate=interpolate_;
1029}

◆ interpolate() [2/2]

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

Definition at line 1031 of file Image.cpp.

1032{
1033 return constImage()->interpolate;
1034}

◆ inverseFourierTransform() [1/2]

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

Definition at line 3384 of file Image.cpp.

3385{
3386 inverseFourierTransform(phase_,true);
3387}

◆ inverseFourierTransform() [2/2]

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

Definition at line 3389 of file Image.cpp.

3391{
3392 MagickCore::Image
3393 *newImage;
3394
3395 GetPPException;
3396 newImage=InverseFourierTransformImage(constImage(),phase_.constImage(),
3397 magnitude_ == true ? MagickTrue : MagickFalse,exceptionInfo);
3398 replaceImage(newImage);
3399 ThrowImageException;
3400}

◆ iptcProfile() [1/2]

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

Definition at line 1036 of file Image.cpp.

1037{
1038 modifyImage();
1039 if (iptcProfile_.data() != 0)
1040 {
1041 StringInfo
1042 *iptc_profile;
1043
1044 iptc_profile=AcquireStringInfo(iptcProfile_.length());
1045 SetStringInfoDatum(iptc_profile,(unsigned char *) iptcProfile_.data());
1046 GetPPException;
1047 (void) SetImageProfile(image(),"iptc",iptc_profile,exceptionInfo);
1048 iptc_profile=DestroyStringInfo(iptc_profile);
1049 ThrowImageException;
1050 }
1051}

◆ iptcProfile() [2/2]

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

Definition at line 1053 of file Image.cpp.

1054{
1055 const StringInfo
1056 *iptc_profile;
1057
1058 iptc_profile=GetImageProfile(constImage(),"iptc");
1059 if (iptc_profile == (StringInfo *) NULL)
1060 return(Blob());
1061 return(Blob(GetStringInfoDatum(iptc_profile),GetStringInfoLength(
1062 iptc_profile)));
1063}

◆ isOpaque()

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

Definition at line 1065 of file Image.cpp.

1066{
1067 MagickBooleanType
1068 result;
1069
1070 GetPPException;
1071 result=IsImageOpaque(constImage(),exceptionInfo);
1072 ThrowImageException;
1073 return(result != MagickFalse ? true : false);
1074}

◆ isValid() [1/2]

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

Definition at line 1076 of file Image.cpp.

1077{
1078 if (!isValid_)
1079 {
1080 delete _imgRef;
1081 _imgRef=new ImageRef;
1082 }
1083 else if (!isValid())
1084 {
1085 // Construct with single-pixel black image to make
1086 // image valid. This is an obvious hack.
1087 size(Geometry(1,1));
1088 read("xc:black");
1089 }
1090}

◆ isValid() [2/2]

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

Definition at line 1092 of file Image.cpp.

1093{
1094 return rows() && columns();
1095}

◆ kuwahara()

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

Definition at line 3402 of file Image.cpp.

3403{
3404 MagickCore::Image
3405 *newImage;
3406
3407 GetPPException;
3408 newImage=KuwaharaImage(constImage(),radius_,sigma_,exceptionInfo);
3409 replaceImage(newImage);
3410 ThrowImageException;
3411}

◆ kuwaharaChannel()

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

Definition at line 3413 of file Image.cpp.

3415{
3416 MagickCore::Image
3417 *newImage;
3418
3419 GetPPException;
3420 GetAndSetPPChannelMask(channel_);
3421 newImage=KuwaharaImage(constImage(),radius_,sigma_,exceptionInfo);
3422 replaceImage(newImage);
3423 RestorePPChannelMask;
3424 ThrowImageException;
3425}

◆ label() [1/2]

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

Definition at line 1097 of file Image.cpp.

1098{
1099 modifyImage();
1100 GetPPException;
1101 (void) SetImageProperty(image(),"Label",NULL,exceptionInfo);
1102 if (label_.length() > 0)
1103 (void) SetImageProperty(image(),"Label",label_.c_str(),exceptionInfo);
1104 ThrowImageException;
1105}

◆ label() [2/2]

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

Definition at line 1107 of file Image.cpp.

1108{
1109 const char
1110 *value;
1111
1112 GetPPException;
1113 value=GetImageProperty(constImage(),"Label",exceptionInfo);
1114 ThrowImageException;
1115
1116 if (value)
1117 return(std::string(value));
1118
1119 return(std::string());
1120}

◆ level()

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

Definition at line 3427 of file Image.cpp.

3429{
3430 modifyImage();
3431 GetPPException;
3432 (void) LevelImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
3433 ThrowImageException;
3434}

◆ levelChannel()

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

Definition at line 3436 of file Image.cpp.

3438{
3439 modifyImage();
3440 GetPPException;
3441 GetAndSetPPChannelMask(channel_);
3442 (void) LevelImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
3443 RestorePPChannelMask;
3444 ThrowImageException;
3445}

◆ levelColors()

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

Definition at line 3447 of file Image.cpp.

3449{
3450 PixelInfo
3451 black,
3452 white;
3453
3454 modifyImage();
3455
3456 black=static_cast<PixelInfo>(blackColor_);
3457 white=static_cast<PixelInfo>(whiteColor_);
3458 GetPPException;
3459 (void) LevelImageColors(image(),&black,&white,invert_ == true ?
3460 MagickTrue : MagickFalse,exceptionInfo);
3461 ThrowImageException;
3462}

◆ levelColorsChannel()

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

Definition at line 3464 of file Image.cpp.

3466{
3467 PixelInfo
3468 black,
3469 white;
3470
3471 modifyImage();
3472
3473 black=static_cast<PixelInfo>(blackColor_);
3474 white=static_cast<PixelInfo>(whiteColor_);
3475 GetPPException;
3476 GetAndSetPPChannelMask(channel_);
3477 (void) LevelImageColors(image(),&black,&white,invert_ == true ?
3478 MagickTrue : MagickFalse,exceptionInfo);
3479 RestorePPChannelMask;
3480 ThrowImageException;
3481}

◆ levelize()

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

Definition at line 3483 of file Image.cpp.

3485{
3486 modifyImage();
3487 GetPPException;
3488 (void) LevelizeImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
3489 ThrowImageException;
3490}

◆ levelizeChannel()

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

Definition at line 3492 of file Image.cpp.

3494{
3495 modifyImage();
3496 GetPPException;
3497 GetAndSetPPChannelMask(channel_);
3498 (void) LevelizeImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
3499 RestorePPChannelMask;
3500 ThrowImageException;
3501}

◆ linearStretch()

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

Definition at line 3503 of file Image.cpp.

3505{
3506 modifyImage();
3507 GetPPException;
3508 LinearStretchImage(image(),blackPoint_,whitePoint_,exceptionInfo);
3509 ThrowImageException;
3510}

◆ liquidRescale()

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

Definition at line 3512 of file Image.cpp.

3513{
3514 MagickCore::Image
3515 *newImage;
3516
3517 size_t
3518 height=rows(),
3519 width=columns();
3520
3521 ssize_t
3522 x=0,
3523 y=0;
3524
3525 ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
3526 &height);
3527
3528 GetPPException;
3529 newImage=LiquidRescaleImage(image(),width,height,x,y,exceptionInfo);
3530 replaceImage(newImage);
3531 ThrowImageException;
3532}

◆ localContrast()

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

Definition at line 3534 of file Image.cpp.

3535{
3536 MagickCore::Image
3537 *newImage;
3538
3539 GetPPException;
3540 newImage=LocalContrastImage(constImage(),radius_,strength_,exceptionInfo);
3541 replaceImage(newImage);
3542 ThrowImageException;
3543}

◆ localContrastChannel()

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

Definition at line 3545 of file Image.cpp.

3547{
3548 MagickCore::Image
3549 *newImage;
3550
3551 GetPPException;
3552 GetAndSetPPChannelMask(channel_);
3553 newImage=LocalContrastImage(constImage(),radius_,strength_,exceptionInfo);
3554 RestorePPChannelMask;
3555 replaceImage(newImage);
3556 ThrowImageException;
3557}

◆ lowlightColor()

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

Definition at line 1122 of file Image.cpp.

1123{
1124 std::string
1125 value;
1126
1127 value=color_;
1128 artifact("compare:lowlight-color",value);
1129}

◆ magick() [1/2]

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

Definition at line 1131 of file Image.cpp.

1132{
1133 size_t
1134 length;
1135
1136 modifyImage();
1137
1138 length=sizeof(image()->magick)-1;
1139 if (magick_.length() < length)
1140 length=magick_.length();
1141
1142 if (!magick_.empty())
1143 magick_.copy(image()->magick,length);
1144 image()->magick[length]=0;
1145
1146 options()->magick(magick_);
1147}

◆ magick() [2/2]

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

Definition at line 1149 of file Image.cpp.

1150{
1151 if (*(constImage()->magick) != '\0')
1152 return(std::string(constImage()->magick));
1153
1154 return(constOptions()->magick());
1155}

◆ magnify()

void Magick::Image::magnify ( void  )

Definition at line 3559 of file Image.cpp.

3560{
3561 MagickCore::Image
3562 *newImage;
3563
3564 GetPPException;
3565 newImage=MagnifyImage(constImage(),exceptionInfo);
3566 replaceImage(newImage);
3567 ThrowImageException;
3568}

◆ map()

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

Definition at line 3570 of file Image.cpp.

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

◆ mask() [1/2]

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

Definition at line 5159 of file Image.cpp.

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

◆ mask() [2/2]

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

Definition at line 5171 of file Image.cpp.

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

◆ masklightColor()

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

Definition at line 1157 of file Image.cpp.

1158{
1159 std::string
1160 value;
1161
1162 value=color_;
1163 artifact("compare:masklight-color",value);
1164}

◆ matteColor() [1/2]

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

Definition at line 331 of file Image.cpp.

332{
333 modifyImage();
334
335 if (matteColor_.isValid())
336 {
337 image()->matte_color=matteColor_;
338 options()->matteColor(matteColor_);
339 }
340 else
341 {
342 // Set to default matte color
343 Color tmpColor("#BDBDBD");
344 image()->matte_color=tmpColor;
345 options()->matteColor(tmpColor);
346 }
347}

◆ matteColor() [2/2]

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

Definition at line 349 of file Image.cpp.

350{
351 return(Color(constImage()->matte_color));
352}

◆ meanErrorPerPixel()

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

Definition at line 1166 of file Image.cpp.

1167{
1168 return(constImage()->error.mean_error_per_pixel);
1169}

◆ meanShift()

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

Definition at line 3580 of file Image.cpp.

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

◆ medianFilter()

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

Definition at line 3593 of file Image.cpp.

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

◆ minify()

void Magick::Image::minify ( void  )

Definition at line 3605 of file Image.cpp.

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

◆ modifyImage()

void Magick::Image::modifyImage ( void  )

Definition at line 5063 of file Image.cpp.

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

◆ modulate()

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

Definition at line 3616 of file Image.cpp.

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

◆ modulusDepth() [1/2]

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

Definition at line 1171 of file Image.cpp.

1172{
1173 modifyImage();
1174 GetPPException;
1175 SetImageDepth(image(),depth_,exceptionInfo);
1176 ThrowImageException;
1177 options()->depth(depth_);
1178}

◆ modulusDepth() [2/2]

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

Definition at line 1180 of file Image.cpp.

1181{
1182 size_t
1183 depth;
1184
1185 GetPPException;
1186 depth=GetImageDepth(constImage(),exceptionInfo);
1187 ThrowImageException;
1188 return(depth);
1189}

◆ moments()

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

Definition at line 3631 of file Image.cpp.

3632{
3633 return(ImageMoments(*this));
3634}

◆ monochrome() [1/2]

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

Definition at line 1191 of file Image.cpp.

1192{
1193 modifyImage();
1194 options()->monochrome(monochromeFlag_);
1195}

◆ monochrome() [2/2]

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

Definition at line 1197 of file Image.cpp.

1198{
1199 return(constOptions()->monochrome());
1200}

◆ montageGeometry()

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

Definition at line 1202 of file Image.cpp.

1203{
1204 if (constImage()->montage)
1205 return Magick::Geometry(constImage()->montage);
1206
1207 if (!quiet())
1208 throwExceptionExplicit(MagickCore::CorruptImageWarning,
1209 "Image does not contain a montage");
1210
1211 return(Magick::Geometry());
1212}

◆ 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 3656 of file Image.cpp.

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

◆ morphology() [2/2]

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

Definition at line 3636 of file Image.cpp.

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

◆ 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 3708 of file Image.cpp.

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

◆ 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 3680 of file Image.cpp.

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

◆ motionBlur()

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

Definition at line 3733 of file Image.cpp.

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

◆ negate()

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

Definition at line 3745 of file Image.cpp.

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

◆ negateChannel()

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

Definition at line 3753 of file Image.cpp.

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

◆ normalize()

void Magick::Image::normalize ( void  )

Definition at line 3764 of file Image.cpp.

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

◆ normalizedMaxError()

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

Definition at line 1214 of file Image.cpp.

1215{
1216 return(constImage()->error.normalized_maximum_error);
1217}

◆ normalizedMeanError()

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

Definition at line 1219 of file Image.cpp.

1220{
1221 return(constImage()->error.normalized_mean_error);
1222}

◆ oilPaint()

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

Definition at line 3772 of file Image.cpp.

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

◆ opaque()

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

Definition at line 3783 of file Image.cpp.

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

◆ operator=()

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

Definition at line 282 of file Image.cpp.

283{
284 if (this != &image_)
285 {
286 image_._imgRef->increase();
287 if (_imgRef->decrease() == 0)
288 delete _imgRef;
289
290 // Use new image reference
291 _imgRef=image_._imgRef;
292 }
293 return(*this);
294}

◆ options()

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

Definition at line 5043 of file Image.cpp.

5044{
5045 return(_imgRef->options());
5046}

◆ orderedDither()

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

Definition at line 3816 of file Image.cpp.

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

◆ orderedDitherChannel()

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

Definition at line 3824 of file Image.cpp.

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

◆ orientation() [1/2]

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

Definition at line 1224 of file Image.cpp.

1225{
1226 modifyImage();
1227 image()->orientation=orientation_;
1228}

◆ orientation() [2/2]

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

Definition at line 1230 of file Image.cpp.

1231{
1232 return(constImage()->orientation);
1233}

◆ page() [1/2]

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

Definition at line 1235 of file Image.cpp.

1236{
1237 modifyImage();
1238 options()->page(pageSize_);
1239 image()->page=pageSize_;
1240}

◆ page() [2/2]

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

Definition at line 1242 of file Image.cpp.

1243{
1244 return(Geometry(constImage()->page.width,constImage()->page.height,
1245 constImage()->page.x,constImage()->page.y));
1246}

◆ perceptible()

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

Definition at line 3835 of file Image.cpp.

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

◆ perceptibleChannel()

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

Definition at line 3843 of file Image.cpp.

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

◆ perceptualHash()

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

Definition at line 3854 of file Image.cpp.

3855{
3856 return(ImagePerceptualHash(*this));
3857}

◆ ping() [1/2]

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

Definition at line 3870 of file Image.cpp.

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

◆ ping() [2/2]

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

Definition at line 3859 of file Image.cpp.

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

◆ polaroid()

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

Definition at line 3928 of file Image.cpp.

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

◆ posterize()

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

Definition at line 3941 of file Image.cpp.

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

◆ posterizeChannel()

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

Definition at line 3949 of file Image.cpp.

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

◆ process()

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

Definition at line 3960 of file Image.cpp.

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

◆ profile() [1/2]

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

Definition at line 3981 of file Image.cpp.

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

◆ profile() [2/2]

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

Definition at line 3971 of file Image.cpp.

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

◆ quality() [1/2]

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

Definition at line 1248 of file Image.cpp.

1249{
1250 modifyImage();
1251 image()->quality=quality_;
1252 options()->quality(quality_);
1253}

◆ quality() [2/2]

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

Definition at line 1255 of file Image.cpp.

1256{
1257 return(constImage()->quality);
1258}

◆ quantize()

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

Definition at line 3994 of file Image.cpp.

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

◆ quantizeColors() [1/2]

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

Definition at line 1260 of file Image.cpp.

1261{
1262 modifyImage();
1263 options()->quantizeColors(colors_);
1264}

◆ quantizeColors() [2/2]

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

Definition at line 1266 of file Image.cpp.

1267{
1268 return(constOptions()->quantizeColors());
1269}

◆ quantizeColorSpace() [1/2]

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

Definition at line 1271 of file Image.cpp.

1273{
1274 modifyImage();
1275 options()->quantizeColorSpace(colorSpace_);
1276}

◆ quantizeColorSpace() [2/2]

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

Definition at line 1278 of file Image.cpp.

1279{
1280 return(constOptions()->quantizeColorSpace());
1281}

◆ quantizeDither() [1/2]

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

Definition at line 1283 of file Image.cpp.

1284{
1285 modifyImage();
1286 options()->quantizeDither(ditherFlag_);
1287}

◆ quantizeDither() [2/2]

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

Definition at line 1289 of file Image.cpp.

1290{
1291 return(constOptions()->quantizeDither());
1292}

◆ quantizeDitherMethod() [1/2]

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

Definition at line 1294 of file Image.cpp.

1295{
1296 modifyImage();
1297 options()->quantizeDitherMethod(ditherMethod_);
1298}

◆ quantizeDitherMethod() [2/2]

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

Definition at line 1300 of file Image.cpp.

1301{
1302 return(constOptions()->quantizeDitherMethod());
1303}

◆ quantizeInfo()

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

Definition at line 5053 of file Image.cpp.

5054{
5055 return(_imgRef->options()->quantizeInfo());
5056}

◆ quantizeTreeDepth() [1/2]

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

Definition at line 1305 of file Image.cpp.

1306{
1307 modifyImage();
1308 options()->quantizeTreeDepth(treeDepth_);
1309}

◆ quantizeTreeDepth() [2/2]

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

Definition at line 1311 of file Image.cpp.

1312{
1313 return(constOptions()->quantizeTreeDepth());
1314}

◆ quiet() [1/2]

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

Definition at line 1316 of file Image.cpp.

1317{
1318 modifyImage();
1319 options()->quiet(quiet_);
1320}

◆ quiet() [2/2]

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

Definition at line 1322 of file Image.cpp.

1323{
1324 return(constOptions()->quiet());
1325}

◆ raise()

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

Definition at line 4008 of file Image.cpp.

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

◆ randomThreshold()

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

Definition at line 4020 of file Image.cpp.

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

◆ randomThresholdChannel()

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

Definition at line 4027 of file Image.cpp.

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

◆ read() [1/9]

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

Definition at line 4038 of file Image.cpp.

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

◆ read() [2/9]

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

Definition at line 4049 of file Image.cpp.

4050{
4051 size(size_);
4052 read(blob_);
4053}

◆ read() [3/9]

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

Definition at line 4055 of file Image.cpp.

4057{
4058 size(size_);
4059 depth(depth_);
4060 read(blob_);
4061}

◆ read() [4/9]

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

Definition at line 4063 of file Image.cpp.

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

◆ read() [5/9]

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

Definition at line 4074 of file Image.cpp.

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

◆ read() [6/9]

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

Definition at line 4084 of file Image.cpp.

4085{
4086 size(size_);
4087 read(imageSpec_);
4088}

◆ 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 4090 of file Image.cpp.

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

◆ read() [8/9]

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

Definition at line 4103 of file Image.cpp.

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

◆ read() [9/9]

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

Definition at line 5091 of file Image.cpp.

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

◆ readMask() [1/2]

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

Definition at line 4114 of file Image.cpp.

4115{
4116 mask(mask_,ReadPixelMask);
4117}

◆ readMask() [2/2]

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

Definition at line 4119 of file Image.cpp.

4120{
4121 return(mask(ReadPixelMask));
4122}

◆ readPixels()

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

Definition at line 4124 of file Image.cpp.

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

◆ reduceNoise() [1/2]

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

Definition at line 4143 of file Image.cpp.

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

◆ reduceNoise() [2/2]

void Magick::Image::reduceNoise ( void  )

Definition at line 4138 of file Image.cpp.

4139{
4140 reduceNoise(3);
4141}

◆ renderingIntent() [1/2]

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

Definition at line 1327 of file Image.cpp.

1329{
1330 modifyImage();
1331 image()->rendering_intent=renderingIntent_;
1332}

◆ renderingIntent() [2/2]

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

Definition at line 1334 of file Image.cpp.

1335{
1336 return(static_cast<Magick::RenderingIntent>(constImage()->rendering_intent));
1337}

◆ repage()

void Magick::Image::repage ( )

Definition at line 4155 of file Image.cpp.

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

◆ replaceImage()

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

Definition at line 5073 of file Image.cpp.

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

◆ resample()

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

Definition at line 4165 of file Image.cpp.

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

◆ resize()

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

Definition at line 4177 of file Image.cpp.

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

◆ resolutionUnits() [1/2]

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

Definition at line 1339 of file Image.cpp.

1341{
1342 modifyImage();
1343 image()->units=resolutionUnits_;
1344 options()->resolutionUnits(resolutionUnits_);
1345}

◆ resolutionUnits() [2/2]

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

Definition at line 1347 of file Image.cpp.

1348{
1349 return(static_cast<Magick::ResolutionType>(constImage()->units));
1350}

◆ roll() [1/2]

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

Definition at line 4202 of file Image.cpp.

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

◆ roll() [2/2]

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

Definition at line 4213 of file Image.cpp.

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

◆ rotate()

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

Definition at line 4224 of file Image.cpp.

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

◆ rotationalBlur()

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

Definition at line 4235 of file Image.cpp.

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

◆ rotationalBlurChannel()

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

Definition at line 4246 of file Image.cpp.

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

◆ rows()

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

Definition at line 1352 of file Image.cpp.

1353{
1354 return(constImage()->rows);
1355}

◆ sample()

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

Definition at line 4260 of file Image.cpp.

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

◆ samplingFactor() [1/2]

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

Definition at line 1357 of file Image.cpp.

1358{
1359 modifyImage();
1360 options()->samplingFactor(samplingFactor_);
1361}

◆ samplingFactor() [2/2]

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

Definition at line 1363 of file Image.cpp.

1364{
1365 return(constOptions()->samplingFactor());
1366}

◆ scale()

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

Definition at line 4282 of file Image.cpp.

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

◆ scene() [1/2]

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

Definition at line 1368 of file Image.cpp.

1369{
1370 modifyImage();
1371 image()->scene=scene_;
1372}

◆ scene() [2/2]

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

Definition at line 1374 of file Image.cpp.

1375{
1376 return(constImage()->scene);
1377}

◆ segment()

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

Definition at line 4304 of file Image.cpp.

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

◆ selectiveBlur()

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

Definition at line 4316 of file Image.cpp.

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

◆ selectiveBlurChannel()

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

Definition at line 4329 of file Image.cpp.

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

◆ separate()

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

Definition at line 4344 of file Image.cpp.

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

◆ sepiaTone()

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

Definition at line 4358 of file Image.cpp.

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

◆ setColorMetric()

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

Definition at line 4369 of file Image.cpp.

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

◆ 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 4385 of file Image.cpp.

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

◆ shade()

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

Definition at line 4398 of file Image.cpp.

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

◆ 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 4411 of file Image.cpp.

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

◆ sharpen()

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

Definition at line 4424 of file Image.cpp.

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

◆ sharpenChannel()

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

Definition at line 4435 of file Image.cpp.

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

◆ shave()

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

Definition at line 4449 of file Image.cpp.

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

◆ shear()

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

Definition at line 4463 of file Image.cpp.

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

◆ sigmoidalContrast()

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

Definition at line 4474 of file Image.cpp.

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

◆ signature()

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

Definition at line 4484 of file Image.cpp.

4485{
4486 return(_imgRef->signature(force_));
4487}

◆ size() [1/2]

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

Definition at line 1379 of file Image.cpp.

1380{
1381 modifyImage();
1382 options()->size(geometry_);
1383 image()->rows=geometry_.height();
1384 image()->columns=geometry_.width();
1385}

◆ size() [2/2]

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

Definition at line 1387 of file Image.cpp.

1388{
1389 return(Magick::Geometry(constImage()->columns,constImage()->rows));
1390}

◆ sketch()

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

Definition at line 4489 of file Image.cpp.

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

◆ solarize()

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

Definition at line 4501 of file Image.cpp.

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

◆ sparseColor()

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

Definition at line 4509 of file Image.cpp.

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

◆ splice() [1/3]

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

Definition at line 4525 of file Image.cpp.

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

◆ splice() [2/3]

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

Definition at line 4539 of file Image.cpp.

4541{
4542 backgroundColor(backgroundColor_);
4543 splice(geometry_);
4544}

◆ splice() [3/3]

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

Definition at line 4546 of file Image.cpp.

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

◆ spread()

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

Definition at line 4554 of file Image.cpp.

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

◆ statistics()

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

Definition at line 4565 of file Image.cpp.

4566{
4567 return(ImageStatistics(*this));
4568}

◆ stegano()

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

Definition at line 4570 of file Image.cpp.

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

◆ stereo()

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

Definition at line 4581 of file Image.cpp.

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

◆ strip()

void Magick::Image::strip ( void  )

Definition at line 4592 of file Image.cpp.

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

◆ strokeAntiAlias() [1/2]

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

Definition at line 1392 of file Image.cpp.

1393{
1394 modifyImage();
1395 options()->strokeAntiAlias(flag_);
1396}

◆ strokeAntiAlias() [2/2]

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

Definition at line 1398 of file Image.cpp.

1399{
1400 return(constOptions()->strokeAntiAlias());
1401}

◆ strokeColor() [1/2]

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

Definition at line 1403 of file Image.cpp.

1404{
1405 std::string
1406 value;
1407
1408 modifyImage();
1409 options()->strokeColor(strokeColor_);
1410 value=strokeColor_;
1411 artifact("stroke",value);
1412}

◆ strokeColor() [2/2]

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

Definition at line 1414 of file Image.cpp.

1415{
1416 return(constOptions()->strokeColor());
1417}

◆ strokeDashArray() [1/2]

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

Definition at line 1419 of file Image.cpp.

1420{
1421 modifyImage();
1422 options()->strokeDashArray(strokeDashArray_);
1423}

◆ strokeDashArray() [2/2]

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

Definition at line 1425 of file Image.cpp.

1426{
1427 return(constOptions()->strokeDashArray());
1428}

◆ strokeDashOffset() [1/2]

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

Definition at line 1430 of file Image.cpp.

1431{
1432 modifyImage();
1433 options()->strokeDashOffset(strokeDashOffset_);
1434}

◆ strokeDashOffset() [2/2]

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

Definition at line 1436 of file Image.cpp.

1437{
1438 return(constOptions()->strokeDashOffset());
1439}

◆ strokeLineCap() [1/2]

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

Definition at line 1441 of file Image.cpp.

1442{
1443 modifyImage();
1444 options()->strokeLineCap(lineCap_);
1445}

◆ strokeLineCap() [2/2]

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

Definition at line 1447 of file Image.cpp.

1448{
1449 return(constOptions()->strokeLineCap());
1450}

◆ strokeLineJoin() [1/2]

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

Definition at line 1452 of file Image.cpp.

1453{
1454 modifyImage();
1455 options()->strokeLineJoin(lineJoin_);
1456}

◆ strokeLineJoin() [2/2]

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

Definition at line 1458 of file Image.cpp.

1459{
1460 return(constOptions()->strokeLineJoin());
1461}

◆ strokeMiterLimit() [1/2]

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

Definition at line 1463 of file Image.cpp.

1464{
1465 modifyImage();
1466 options()->strokeMiterLimit(strokeMiterLimit_);
1467}

◆ strokeMiterLimit() [2/2]

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

Definition at line 1469 of file Image.cpp.

1470{
1471 return(constOptions()->strokeMiterLimit());
1472}

◆ strokePattern() [1/2]

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

Definition at line 1474 of file Image.cpp.

1475{
1476 modifyImage();
1477 if(strokePattern_.isValid())
1478 options()->strokePattern(strokePattern_.constImage());
1479 else
1480 options()->strokePattern(static_cast<MagickCore::Image*>(NULL));
1481}

◆ strokePattern() [2/2]

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

Definition at line 1483 of file Image.cpp.

1484{
1485 // FIXME: This is inordinately inefficient
1486 const MagickCore::Image
1487 *tmpTexture;
1488
1489 Image
1490 texture;
1491
1492 tmpTexture=constOptions()->strokePattern();
1493
1494 if (tmpTexture)
1495 {
1496 MagickCore::Image
1497 *image;
1498
1499 GetPPException;
1500 image=CloneImage(tmpTexture,0,0,MagickTrue,exceptionInfo);
1501 texture.replaceImage(image);
1502 ThrowImageException;
1503 }
1504 return(texture);
1505}

◆ strokeWidth() [1/2]

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

Definition at line 1507 of file Image.cpp.

1508{
1509 char
1510 value[MagickPathExtent];
1511
1512 modifyImage();
1513 options()->strokeWidth(strokeWidth_);
1514 FormatLocaleString(value,MagickPathExtent,"%.20g",strokeWidth_);
1515 (void) SetImageArtifact(image(),"strokewidth",value);
1516}

◆ strokeWidth() [2/2]

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

Definition at line 1518 of file Image.cpp.

1519{
1520 return(constOptions()->strokeWidth());
1521}

◆ subImage() [1/2]

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

Definition at line 1523 of file Image.cpp.

1524{
1525 modifyImage();
1526 options()->subImage(subImage_);
1527}

◆ subImage() [2/2]

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

Definition at line 1529 of file Image.cpp.

1530{
1531 return(constOptions()->subImage());
1532}

◆ subImageSearch()

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

Definition at line 4600 of file Image.cpp.

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

◆ subRange() [1/2]

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

Definition at line 1534 of file Image.cpp.

1535{
1536 modifyImage();
1537 options()->subRange(subRange_);
1538}

◆ subRange() [2/2]

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

Definition at line 1540 of file Image.cpp.

1541{
1542 return(constOptions()->subRange());
1543}

◆ swirl()

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

Definition at line 4622 of file Image.cpp.

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

◆ syncPixels()

void Magick::Image::syncPixels ( void  )

Definition at line 4634 of file Image.cpp.

4635{
4636 GetPPException;
4637 (void) SyncAuthenticPixels(image(),exceptionInfo);
4638 ThrowImageException;
4639}

◆ textAntiAlias() [1/2]

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

Definition at line 1545 of file Image.cpp.

1546{
1547 modifyImage();
1548 options()->textAntiAlias(flag_);
1549}

◆ textAntiAlias() [2/2]

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

Definition at line 1551 of file Image.cpp.

1552{
1553 return(constOptions()->textAntiAlias());
1554}

◆ textDirection() [1/2]

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

Definition at line 1562 of file Image.cpp.

1563{
1564 return(constOptions()->textDirection());
1565}

◆ textDirection() [2/2]

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

Definition at line 1556 of file Image.cpp.

1557{
1558 modifyImage();
1559 options()->textDirection(direction_);
1560}

◆ textEncoding() [1/2]

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

Definition at line 1567 of file Image.cpp.

1568{
1569 modifyImage();
1570 options()->textEncoding(encoding_);
1571}

◆ textEncoding() [2/2]

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

Definition at line 1573 of file Image.cpp.

1574{
1575 return(constOptions()->textEncoding());
1576}

◆ textGravity() [1/2]

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

Definition at line 1584 of file Image.cpp.

1585{
1586 return(constOptions()->textGravity());
1587}

◆ textGravity() [2/2]

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

Definition at line 1578 of file Image.cpp.

1579{
1580 modifyImage();
1581 options()->textGravity(gravity_);
1582}

◆ textInterlineSpacing() [1/2]

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

Definition at line 1589 of file Image.cpp.

1590{
1591 modifyImage();
1592 options()->textInterlineSpacing(spacing_);
1593}

◆ textInterlineSpacing() [2/2]

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

Definition at line 1595 of file Image.cpp.

1596{
1597 return(constOptions()->textInterlineSpacing());
1598}

◆ textInterwordSpacing() [1/2]

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

Definition at line 1600 of file Image.cpp.

1601{
1602 modifyImage();
1603 options()->textInterwordSpacing(spacing_);
1604}

◆ textInterwordSpacing() [2/2]

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

Definition at line 1606 of file Image.cpp.

1607{
1608 return(constOptions()->textInterwordSpacing());
1609}

◆ textKerning() [1/2]

void Magick::Image::textKerning ( double  kerning_)

Definition at line 1611 of file Image.cpp.

1612{
1613 modifyImage();
1614 options()->textKerning(kerning_);
1615}

◆ textKerning() [2/2]

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

Definition at line 1617 of file Image.cpp.

1618{
1619 return(constOptions()->textKerning());
1620}

◆ textUnderColor() [1/2]

void Magick::Image::textUnderColor ( const Color underColor_)

Definition at line 1622 of file Image.cpp.

1623{
1624 modifyImage();
1625 options()->textUnderColor(underColor_);
1626}

◆ textUnderColor() [2/2]

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

Definition at line 1628 of file Image.cpp.

1629{
1630 return(constOptions()->textUnderColor());
1631}

◆ texture()

void Magick::Image::texture ( const Image texture_)

Definition at line 4641 of file Image.cpp.

4642{
4643 modifyImage();
4644 GetPPException;
4645 TextureImage(image(),texture_.constImage(),exceptionInfo);
4646 ThrowImageException;
4647}

◆ threshold()

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

Definition at line 4649 of file Image.cpp.

4650{
4651 modifyImage();
4652 GetPPException;
4653 BilevelImage(image(),threshold_,exceptionInfo);
4654 ThrowImageException;
4655}

◆ thumbnail()

void Magick::Image::thumbnail ( const Geometry geometry_)

Definition at line 4657 of file Image.cpp.

4658{
4659 MagickCore::Image
4660 *newImage;
4661
4662 size_t
4663 height=rows(),
4664 width=columns();
4665
4666 ssize_t
4667 x=0,
4668 y=0;
4669
4670 ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
4671 &height);
4672
4673 GetPPException;
4674 newImage=ThumbnailImage(constImage(),width,height,exceptionInfo);
4675 replaceImage(newImage);
4676 ThrowImageException;
4677}

◆ tint()

void Magick::Image::tint ( const std::string  opacity_)

Definition at line 4679 of file Image.cpp.

4680{
4681 MagickCore::Image
4682 *newImage;
4683
4684 PixelInfo
4685 color;
4686
4687 GetPPException;
4688 color=static_cast<PixelInfo>(constOptions()->fillColor());
4689 newImage=TintImage(constImage(),opacity_.c_str(),&color,exceptionInfo);
4690 replaceImage(newImage);
4691 ThrowImageException;
4692}

◆ totalColors()

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

Definition at line 1633 of file Image.cpp.

1634{
1635 size_t
1636 colors;
1637
1638 GetPPException;
1639 colors=GetNumberColors(constImage(),(FILE *) NULL,exceptionInfo);
1640 ThrowImageException;
1641 return colors;
1642}

◆ transformOrigin()

void Magick::Image::transformOrigin ( const double  x_,
const double  y_ 
)

Definition at line 4694 of file Image.cpp.

4695{
4696 modifyImage();
4697 options()->transformOrigin(x_,y_);
4698}

◆ transformReset()

void Magick::Image::transformReset ( void  )

Definition at line 4700 of file Image.cpp.

4701{
4702 modifyImage();
4703 options()->transformReset();
4704}

◆ transformRotation()

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

Definition at line 1644 of file Image.cpp.

1645{
1646 modifyImage();
1647 options()->transformRotation(angle_);
1648}

◆ transformScale()

void Magick::Image::transformScale ( const double  sx_,
const double  sy_ 
)

Definition at line 4706 of file Image.cpp.

4707{
4708 modifyImage();
4709 options()->transformScale(sx_,sy_);
4710}

◆ transformSkewX()

void Magick::Image::transformSkewX ( const double  skewx_)

Definition at line 1650 of file Image.cpp.

1651{
1652 modifyImage();
1653 options()->transformSkewX(skewx_);
1654}

◆ transformSkewY()

void Magick::Image::transformSkewY ( const double  skewy_)

Definition at line 1656 of file Image.cpp.

1657{
1658 modifyImage();
1659 options()->transformSkewY(skewy_);
1660}

◆ transparent()

void Magick::Image::transparent ( const Color color_,
const bool  inverse_ = false 
)

Definition at line 4712 of file Image.cpp.

4713{
4714 PixelInfo
4715 target;
4716
4717 std::string
4718 color;
4719
4720 if (!color_.isValid())
4721 throwExceptionExplicit(MagickCore::OptionError,
4722 "Color argument is invalid");
4723
4724 color=color_;
4725 GetPPException;
4726 (void) QueryColorCompliance(color.c_str(),AllCompliance,&target,
4727 exceptionInfo);
4728 modifyImage();
4729 TransparentPaintImage(image(),&target,TransparentAlpha,
4730 inverse_ == true ? MagickTrue : MagickFalse,exceptionInfo);
4731 ThrowImageException;
4732}

◆ transparentChroma()

void Magick::Image::transparentChroma ( const Color colorLow_,
const Color colorHigh_ 
)

Definition at line 4734 of file Image.cpp.

4736{
4737 std::string
4738 colorHigh,
4739 colorLow;
4740
4741 PixelInfo
4742 targetHigh,
4743 targetLow;
4744
4745 if (!colorLow_.isValid() || !colorHigh_.isValid())
4746 throwExceptionExplicit(MagickCore::OptionError,
4747 "Color argument is invalid");
4748
4749 colorLow=colorLow_;
4750 colorHigh=colorHigh_;
4751
4752 GetPPException;
4753 (void) QueryColorCompliance(colorLow.c_str(),AllCompliance,&targetLow,
4754 exceptionInfo);
4755 (void) QueryColorCompliance(colorHigh.c_str(),AllCompliance,&targetHigh,
4756 exceptionInfo);
4757 modifyImage();
4758 TransparentPaintImageChroma(image(),&targetLow,&targetHigh,TransparentAlpha,
4759 MagickFalse,exceptionInfo);
4760 ThrowImageException;
4761}

◆ transpose()

void Magick::Image::transpose ( void  )

Definition at line 4763 of file Image.cpp.

4764{
4765 MagickCore::Image
4766 *newImage;
4767
4768 GetPPException;
4769 newImage=TransposeImage(constImage(),exceptionInfo);
4770 replaceImage(newImage);
4771 ThrowImageException;
4772}

◆ transverse()

void Magick::Image::transverse ( void  )

Definition at line 4774 of file Image.cpp.

4775{
4776 MagickCore::Image
4777 *newImage;
4778
4779 GetPPException;
4780 newImage=TransverseImage(constImage(),exceptionInfo);
4781 replaceImage(newImage);
4782 ThrowImageException;
4783}

◆ trim()

void Magick::Image::trim ( void  )

Definition at line 4785 of file Image.cpp.

4786{
4787 MagickCore::Image
4788 *newImage;
4789
4790 GetPPException;
4791 newImage=TrimImage(constImage(),exceptionInfo);
4792 replaceImage(newImage);
4793 ThrowImageException;
4794}

◆ type() [1/2]

void Magick::Image::type ( const ImageType  type_)

Definition at line 1669 of file Image.cpp.

1670{
1671 modifyImage();
1672 options()->type(type_);
1673 GetPPException;
1674 SetImageType(image(),type_,exceptionInfo);
1675 ThrowImageException;
1676}

◆ type() [2/2]

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

Definition at line 1662 of file Image.cpp.

1663{
1664 if (constOptions()->type() != UndefinedType)
1665 return(constOptions()->type());
1666 return(GetImageType(constImage()));
1667}

◆ uniqueColors()

Magick::Image Magick::Image::uniqueColors ( void  ) const

Definition at line 4796 of file Image.cpp.

4797{
4798 MagickCore::Image
4799 *image;
4800
4801 GetPPException;
4802 image=UniqueImageColors(constImage(),exceptionInfo);
4803 ThrowImageException;
4804 if (image == (MagickCore::Image *) NULL)
4805 return(Magick::Image());
4806 else
4807 return(Magick::Image(image));
4808}

◆ unsharpmask()

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

Definition at line 4810 of file Image.cpp.

4812{
4813 MagickCore::Image
4814 *newImage;
4815
4816 GetPPException;
4817 newImage=UnsharpMaskImage(constImage(),radius_,sigma_,amount_,threshold_,
4818 exceptionInfo);
4819 replaceImage(newImage);
4820 ThrowImageException;
4821}

◆ unsharpmaskChannel()

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

Definition at line 4823 of file Image.cpp.

4826{
4827 MagickCore::Image
4828 *newImage;
4829
4830 GetPPException;
4831 GetAndSetPPChannelMask(channel_);
4832 newImage=UnsharpMaskImage(constImage(),radius_,sigma_,amount_,threshold_,
4833 exceptionInfo);
4834 RestorePPChannelMask;
4835 replaceImage(newImage);
4836 ThrowImageException;
4837}

◆ verbose() [1/2]

void Magick::Image::verbose ( const bool  verboseFlag_)

Definition at line 1678 of file Image.cpp.

1679{
1680 modifyImage();
1681 options()->verbose(verboseFlag_);
1682}

◆ verbose() [2/2]

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

Definition at line 1684 of file Image.cpp.

1685{
1686 return(constOptions()->verbose());
1687}

◆ 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 4839 of file Image.cpp.

4841{
4842 MagickCore::Image
4843 *newImage;
4844
4845 GetPPException;
4846 newImage=VignetteImage(constImage(),radius_,sigma_,x_,y_,exceptionInfo);
4847 replaceImage(newImage);
4848 ThrowImageException;
4849}

◆ virtualPixelMethod() [1/2]

void Magick::Image::virtualPixelMethod ( const VirtualPixelMethod  virtualPixelMethod_)

Definition at line 1689 of file Image.cpp.

1691{
1692 modifyImage();
1693 GetPPException;
1694 SetImageVirtualPixelMethod(image(),virtualPixelMethod_,exceptionInfo);
1695 ThrowImageException;
1696}

◆ virtualPixelMethod() [2/2]

Magick::VirtualPixelMethod Magick::Image::virtualPixelMethod ( void  ) const

Definition at line 1698 of file Image.cpp.

1699{
1700 return(GetImageVirtualPixelMethod(constImage()));
1701}

◆ wave()

void Magick::Image::wave ( const double  amplitude_ = 25.0,
const double  wavelength_ = 150.0 
)

Definition at line 4851 of file Image.cpp.

4852{
4853 MagickCore::Image
4854 *newImage;
4855
4856 GetPPException;
4857 newImage=WaveImage(constImage(),amplitude_,wavelength_,image()->interpolate,
4858 exceptionInfo);
4859 replaceImage(newImage);
4860 ThrowImageException;
4861}

◆ waveletDenoise()

void Magick::Image::waveletDenoise ( const double  threshold_,
const double  softness_ 
)

Definition at line 4863 of file Image.cpp.

4865{
4866 MagickCore::Image
4867 *newImage;
4868
4869 GetPPException;
4870 newImage=WaveletDenoiseImage(constImage(),threshold_,softness_,
4871 exceptionInfo);
4872 replaceImage(newImage);
4873 ThrowImageException;
4874}

◆ whiteThreshold()

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

Definition at line 4876 of file Image.cpp.

4877{
4878 modifyImage();
4879 GetPPException;
4880 WhiteThresholdImage(image(),threshold_.c_str(),exceptionInfo);
4881 ThrowImageException;
4882}

◆ whiteThresholdChannel()

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

Definition at line 4884 of file Image.cpp.

4886{
4887 modifyImage();
4888 GetPPException;
4889 GetAndSetPPChannelMask(channel_);
4890 WhiteThresholdImage(image(),threshold_.c_str(),exceptionInfo);
4891 RestorePPChannelMask;
4892 ThrowImageException;
4893}

◆ write() [1/4]

void Magick::Image::write ( Blob blob_)

Definition at line 4895 of file Image.cpp.

4896{
4897 size_t
4898 length=0;
4899
4900 void
4901 *data;
4902
4903 modifyImage();
4904 GetPPException;
4905 data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
4906 if (length > 0)
4907 blob_->updateNoCopy(data,length,Blob::MallocAllocator);
4908 else
4909 data=RelinquishMagickMemory(data);
4910 ThrowImageException;
4911}

◆ write() [2/4]

void Magick::Image::write ( Blob blob_,
const std::string &  magick_ 
)

Definition at line 4913 of file Image.cpp.

4914{
4915 size_t
4916 length=0;
4917
4918 void
4919 *data;
4920
4921 modifyImage();
4922 magick(magick_);
4923 GetPPException;
4924 data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
4925 if (length > 0)
4926 blob_->updateNoCopy(data,length,Blob::MallocAllocator);
4927 else
4928 data=RelinquishMagickMemory(data);
4929 ThrowImageException;
4930}

◆ write() [3/4]

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

Definition at line 4932 of file Image.cpp.

4934{
4935 size_t
4936 length=0;
4937
4938 void
4939 *data;
4940
4941 modifyImage();
4942 magick(magick_);
4943 depth(depth_);
4944 GetPPException;
4945 data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
4946 if (length > 0)
4947 blob_->updateNoCopy(data,length,Blob::MallocAllocator);
4948 else
4949 data=RelinquishMagickMemory(data);
4950 ThrowImageException;
4951}

◆ write() [4/4]

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

Definition at line 4963 of file Image.cpp.

4964{
4965 modifyImage();
4966 fileName(imageSpec_);
4967 GetPPException;
4968 WriteImage(constImageInfo(),image(),exceptionInfo);
4969 ThrowImageException;
4970}

◆ writeMask() [1/2]

void Magick::Image::writeMask ( const Image mask_)

Definition at line 4972 of file Image.cpp.

4973{
4974 mask(mask_,WritePixelMask);
4975}

◆ writeMask() [2/2]

Magick::Image Magick::Image::writeMask ( void  ) const

Definition at line 4977 of file Image.cpp.

4978{
4979 return(mask(WritePixelMask));
4980}

◆ writePixels()

void Magick::Image::writePixels ( const QuantumType  quantum_,
unsigned char *  destination_ 
)

Definition at line 4982 of file Image.cpp.

4984{
4985 QuantumInfo
4986 *quantum_info;
4987
4988 quantum_info=AcquireQuantumInfo(imageInfo(),image());
4989 GetPPException;
4990 ExportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
4991 quantum_,destination_, exceptionInfo);
4992 quantum_info=DestroyQuantumInfo(quantum_info);
4993 ThrowImageException;
4994}

◆ x11Display() [1/2]

void Magick::Image::x11Display ( const std::string &  display_)

Definition at line 1703 of file Image.cpp.

1704{
1705 modifyImage();
1706 options()->x11Display(display_);
1707}

◆ x11Display() [2/2]

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

Definition at line 1709 of file Image.cpp.

1710{
1711 return(constOptions()->x11Display());
1712}

◆ xResolution()

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

Definition at line 1714 of file Image.cpp.

1715{
1716 return(constImage()->resolution.x);
1717}

◆ yResolution()

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

Definition at line 1719 of file Image.cpp.

1720{
1721 return(constImage()->resolution.y);
1722}

◆ zoom()

void Magick::Image::zoom ( const Geometry geometry_)

Definition at line 4996 of file Image.cpp.

4997{
4998 MagickCore::Image
4999 *newImage;
5000
5001 size_t
5002 height=rows(),
5003 width=columns();
5004
5005 ssize_t
5006 x=0,
5007 y=0;
5008
5009 ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
5010 &height);
5011
5012 GetPPException;
5013 newImage=ResizeImage(constImage(),width,height,image()->filter,exceptionInfo);
5014 replaceImage(newImage);
5015 ThrowImageException;
5016}

Member Data Documentation

◆ _imgRef

ImageRef* Magick::Image::_imgRef
private

Definition at line 1559 of file Image.h.


The documentation for this class was generated from the following files: