Loading...
Searching...
No Matches
Magick::Image Class Reference

## Public Member Functions

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

## Private Member Functions

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

## Private Attributes

ImageRef * | _imgRef

## Detailed Description

Definition at line 55 of file Image.h.

## Constructor & Destructor Documentation

## Image() [1/12]

Magick::Image::Image | ( | void |  | ) |

Definition at line 79 of file Image.cpp.

: _imgRef(new ImageRef)
{
}

## Image() [2/12]

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

Definition at line 84 of file Image.cpp.

: _imgRef(new ImageRef)
{
try
{
// Initialize, Allocate and Read images
quiet(true);
read(blob_);
quiet(false);
}
catch (const Error&)
{
// Release resources
delete _imgRef;
throw;
}
}

## Image() [3/12]

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

Definition at line 102 of file Image.cpp.

: _imgRef(new ImageRef)
{
try
{
// Read from Blob
quiet(true);
read(blob_, size_);
quiet(false);
}
catch(const Error&)
{
// Release resources
delete _imgRef;
throw;
}
}

## Image() [4/12]

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

Definition at line 120 of file Image.cpp.

: _imgRef(new ImageRef)
{
try
{
// Read from Blob
quiet(true);
read(blob_,size_,depth_);
quiet(false);
}
catch(const Error&)
{
// Release resources
delete _imgRef;
throw;
}
}

## 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.

: _imgRef(new ImageRef)
{
try
{
// Read from Blob
quiet(true);
read(blob_,size_,depth_,magick_);
quiet(false);
}
catch(const Error&)
{
// Release resources
delete _imgRef;
throw;
}
}

## Image() [6/12]

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

Definition at line 158 of file Image.cpp.

: _imgRef(new ImageRef)
{
try
{
// Read from Blob
quiet(true);
read(blob_,size_,magick_);
quiet(false);
}
catch(const Error&)
{
// Release resources
delete _imgRef;
throw;
}
}

## Image() [7/12]

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

Definition at line 177 of file Image.cpp.

: _imgRef(new ImageRef)
{
// xc: prefix specifies an X11 color string
std::string imageSpec("xc:");
imageSpec+=color_;
try
{
quiet(true);
// Set image size
size(size_);
// Initialize, Allocate and Read images
read(imageSpec);
quiet(false);
}
catch(const Error&)
{
// Release resources
delete _imgRef;
throw;
}
}

## Image() [8/12]

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

Definition at line 202 of file Image.cpp.

: _imgRef(image_._imgRef)
{
_imgRef->increase();
}

## Image() [9/12]

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

Definition at line 208 of file Image.cpp.

: _imgRef(new ImageRef)
{
const RectangleInfo
geometry=geometry_;
OffsetInfo
offset;
MagickCore::Image
*image;
GetPPException;
image=CloneImage(image_.constImage(),geometry_.width(),geometry_.height(),
MagickTrue,exceptionInfo);
replaceImage(image);
_imgRef->options(new Options(*image_.constOptions()));
offset.x=0;
offset.y=0;
(void) CopyImagePixels(image,image_.constImage(),&geometry,&offset,
exceptionInfo);
ThrowImageException;
}

## 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.

: _imgRef(new ImageRef)
{
try
{
quiet(true);
read(width_,height_,map_.c_str(),type_,pixels_);
quiet(false);
}
catch(const Error&)
{
// Release resources
delete _imgRef;
throw;
}
}

## Image() [11/12]

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

Definition at line 250 of file Image.cpp.

: _imgRef(new ImageRef)
{
try
{
// Initialize, Allocate and Read images
quiet(true);
read(imageSpec_);
quiet(false);
}
catch(const Error&)
{
// Release resources
delete _imgRef;
throw;
}
}

## ~Image()

Magick::Image::~Image | ( |  | ) |

virtual

Definition at line 268 of file Image.cpp.

{
try
{
if (_imgRef->decrease() == 0)
delete _imgRef;
}
catch(Magick::Exception&)
{
}
_imgRef=(Magick::ImageRef *) NULL;
}

## Image() [12/12]

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

Definition at line 5023 of file Image.cpp.

: _imgRef(new ImageRef(image_))
{
}

## 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.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=AdaptiveBlurImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## adaptiveResize()

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

Definition at line 1735 of file Image.cpp.

{
MagickCore::Image
*newImage;
size_t
height=rows(),
width=columns();
ssize_t
x=0,
y=0;
ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
&height);
GetPPException;
newImage=AdaptiveResizeImage(constImage(),width,height,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## adaptiveSharpen()

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

Definition at line 1757 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=AdaptiveSharpenImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## 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.

{
MagickCore::Image
*newImage;
GetPPException;
GetAndSetPPChannelMask(channel_);
newImage=AdaptiveSharpenImage(constImage(),radius_,sigma_,exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowImageException;
}

## 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.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=AdaptiveThresholdImage(constImage(),width_,height_,bias_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## addNoise()

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

Definition at line 1796 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=AddNoiseImage(constImage(),noiseType_,attenuate_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## addNoiseChannel()

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

Definition at line 1807 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
GetAndSetPPChannelMask(channel_);
newImage=AddNoiseImage(constImage(),noiseType_,attenuate_,exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowImageException;
}

## adjoin() [1/2]

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

Definition at line 296 of file Image.cpp.

{
modifyImage();
options()->adjoin(flag_);
}

## adjoin() [2/2]

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

Definition at line 302 of file Image.cpp.

{
return(constOptions()->adjoin());
}

## affineTransform()

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

Definition at line 1821 of file Image.cpp.

{
AffineMatrix
_affine;
MagickCore::Image
*newImage;
_affine.sx=affine_.sx();
_affine.sy=affine_.sy();
_affine.rx=affine_.rx();
_affine.ry=affine_.ry();
_affine.tx=affine_.tx();
_affine.ty=affine_.ty();
GetPPException;
newImage=AffineTransformImage(constImage(),&_affine,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## alpha() [1/3]

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

Definition at line 307 of file Image.cpp.

{
modifyImage();
// If matte channel is requested, but image doesn't already have a
// matte channel, then create an opaque matte channel. Likewise, if
// the image already has a matte channel but a matte channel is not
// desired, then set the matte channel to opaque.
GetPPException;
if (bool(alphaFlag_) != bool(constImage()->alpha_trait))
SetImageAlpha(image(),OpaqueAlpha,exceptionInfo);
ThrowImageException;
image()->alpha_trait=alphaFlag_ ? BlendPixelTrait : UndefinedPixelTrait;
}

## alpha() [2/3]

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

Definition at line 1842 of file Image.cpp.

{
modifyImage();
GetPPException;
SetImageAlpha(image(),(Quantum) alpha_,exceptionInfo);
ThrowImageException;
}

## alpha() [3/3]

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

Definition at line 323 of file Image.cpp.

{
if (constImage()->alpha_trait == BlendPixelTrait)
return(true);
else
return(false);
}

## alphaChannel()

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

Definition at line 1850 of file Image.cpp.

{
modifyImage();
GetPPException;
SetImageAlphaChannel(image(),alphaOption_,exceptionInfo);
ThrowImageException;
}

## animationDelay() [1/2]

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

Definition at line 354 of file Image.cpp.

{
modifyImage();
image()->delay=delay_;
}

## animationDelay() [2/2]

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

Definition at line 360 of file Image.cpp.

{
return(constImage()->delay);
}

## animationIterations() [1/2]

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

Definition at line 365 of file Image.cpp.

{
modifyImage();
image()->iterations=iterations_;
}

## animationIterations() [2/2]

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

Definition at line 371 of file Image.cpp.

{
return(constImage()->iterations);
}

## 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.

{
annotate(text_,boundingArea_,gravity_,0.0);
}

## 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.

{
AffineMatrix
oaffine;
char
boundingArea[MagickPathExtent];
DrawInfo
*drawInfo;
modifyImage();
drawInfo=options()->drawInfo();
drawInfo->text=DestroyString(drawInfo->text);
drawInfo->text=const_cast<char *>(text_.c_str());
drawInfo->geometry=DestroyString(drawInfo->geometry);
if (boundingArea_.isValid())
{
if (boundingArea_.width() == 0 || boundingArea_.height() == 0)
{
FormatLocaleString(boundingArea,MagickPathExtent,"%+.20g%+.20g",
(double) boundingArea_.xOff(),(double) boundingArea_.yOff());
}
else
{
(void) CopyMagickString(boundingArea,
std::string(boundingArea_).c_str(), MagickPathExtent);
}
drawInfo->geometry=boundingArea;
}
drawInfo->gravity=gravity_;
oaffine=drawInfo->affine;
if (degrees_ != 0.0)
{
AffineMatrix
affine,
current;
affine.sx=1.0;
affine.rx=0.0;
affine.ry=0.0;
affine.sy=1.0;
affine.tx=0.0;
affine.ty=0.0;
current=drawInfo->affine;
affine.sx=cos(DegreesToRadians(fmod(degrees_,360.0)));
affine.rx=sin(DegreesToRadians(fmod(degrees_,360.0)));
affine.ry=(-sin(DegreesToRadians(fmod(degrees_,360.0))));
affine.sy=cos(DegreesToRadians(fmod(degrees_,360.0)));
drawInfo->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
drawInfo->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
drawInfo->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
drawInfo->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
drawInfo->affine.tx=current.sx*affine.tx+current.ry*affine.ty
+current.tx;
}
GetPPException;
AnnotateImage(image(),drawInfo,exceptionInfo);
// Restore original values
drawInfo->affine=oaffine;
drawInfo->text=(char *) NULL;
drawInfo->geometry=(char *) NULL;
ThrowImageException;
}

## annotate() [3/4]

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

Definition at line 1858 of file Image.cpp.

{
annotate(text_,location_,NorthWestGravity,0.0);
}

## annotate() [4/4]

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

Definition at line 1946 of file Image.cpp.

{
DrawInfo
*drawInfo;
modifyImage();
drawInfo=options()->drawInfo();
drawInfo->text=DestroyString(drawInfo->text);
drawInfo->text=const_cast<char *>(text_.c_str());
drawInfo->gravity=gravity_;
GetPPException;
AnnotateImage(image(),drawInfo,exceptionInfo);
drawInfo->gravity=NorthWestGravity;
drawInfo->text=(char *) NULL;
ThrowImageException;
}

## artifact() [1/2]

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

Definition at line 1974 of file Image.cpp.

{
const char
*value;
value=GetImageArtifact(constImage(),name_.c_str());
if (value)
return(std::string(value));
return(std::string());
}

## artifact() [2/2]

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

Definition at line 1968 of file Image.cpp.

{
modifyImage();
(void) SetImageArtifact(image(),name_.c_str(),value_.c_str());
}

## attribute() [1/3]

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

Definition at line 2001 of file Image.cpp.

{
const char
*value;
GetPPException;
value=GetImageProperty(constImage(),name_.c_str(),exceptionInfo);
ThrowImageException;
if (value)
return(std::string(value));
return(std::string()); // Intentionally no exception
}

## attribute() [2/3]

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

Definition at line 1985 of file Image.cpp.

{
modifyImage();
GetPPException;
SetImageProperty(image(),name_.c_str(),value_,exceptionInfo);
ThrowImageException;
}

## attribute() [3/3]

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

Definition at line 1993 of file Image.cpp.

{
modifyImage();
GetPPException;
SetImageProperty(image(),name_.c_str(),value_.c_str(),exceptionInfo);
ThrowImageException;
}

## autoGamma()

void Magick::Image::autoGamma | ( | void |  | ) |

Definition at line 2016 of file Image.cpp.

{
modifyImage();
GetPPException;
(void) SyncImageSettings(imageInfo(),image(),exceptionInfo);
(void) AutoGammaImage(image(),exceptionInfo);
ThrowImageException;
}

## autoGammaChannel()

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

Definition at line 2025 of file Image.cpp.

{
modifyImage();
GetPPException;
GetAndSetPPChannelMask(channel_);
(void) SyncImageSettings(imageInfo(),image(),exceptionInfo);
(void) AutoGammaImage(image(),exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## autoLevel()

void Magick::Image::autoLevel | ( | void |  | ) |

Definition at line 2036 of file Image.cpp.

{
modifyImage();
GetPPException;
(void) AutoLevelImage(image(),exceptionInfo);
ThrowImageException;
}

## autoLevelChannel()

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

Definition at line 2044 of file Image.cpp.

{
modifyImage();
GetPPException;
GetAndSetPPChannelMask(channel_);
(void) AutoLevelImage(image(),exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## autoOrient()

void Magick::Image::autoOrient | ( | void |  | ) |

Definition at line 2054 of file Image.cpp.

{
MagickCore::Image
*newImage;
if (image()->orientation == UndefinedOrientation ||
image()->orientation == TopLeftOrientation)
return;
GetPPException;
newImage=AutoOrientImage(constImage(),image()->orientation,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## autoThreshold()

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

Definition at line 2069 of file Image.cpp.

{
modifyImage();
GetPPException;
AutoThresholdImage(image(),method_, exceptionInfo);
ThrowImageException;
}

## backgroundColor() [1/2]

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

Definition at line 376 of file Image.cpp.

{
modifyImage();
if (backgroundColor_.isValid())
image()->background_color=backgroundColor_;
else
image()->background_color=Color();
options()->backgroundColor(backgroundColor_);
}

## backgroundColor() [2/2]

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

Definition at line 388 of file Image.cpp.

{
return(constOptions()->backgroundColor());
}

## backgroundTexture() [1/2]

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

Definition at line 393 of file Image.cpp.

{
modifyImage();
options()->backgroundTexture(backgroundTexture_);
}

## backgroundTexture() [2/2]

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

Definition at line 399 of file Image.cpp.

{
return(constOptions()->backgroundTexture());
}

## baseColumns()

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

Definition at line 404 of file Image.cpp.

{
return(constImage()->magick_columns);
}

## baseFilename()

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

Definition at line 409 of file Image.cpp.

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

## baseRows()

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

Definition at line 414 of file Image.cpp.

{
return(constImage()->magick_rows);
}

## blackPointCompensation() [1/2]

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

Definition at line 419 of file Image.cpp.

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

## blackPointCompensation() [2/2]

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

Definition at line 424 of file Image.cpp.

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

## blackThreshold()

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

Definition at line 2077 of file Image.cpp.

{
modifyImage();
GetPPException;
BlackThresholdImage(image(),threshold_.c_str(),exceptionInfo);
ThrowImageException;
}

## blackThresholdChannel()

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

Definition at line 2085 of file Image.cpp.

{
modifyImage();
GetPPException;
GetAndSetPPChannelMask(channel_);
BlackThresholdImage(image(),threshold_.c_str(),exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## blueShift()

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

Definition at line 2096 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=BlueShiftImage(constImage(),factor_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## blur()

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

Definition at line 2107 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=BlurImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## 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.

{
MagickCore::Image
*newImage;
GetPPException;
GetAndSetPPChannelMask(channel_);
newImage=BlurImage(constImage(),radius_,sigma_,exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowImageException;
}

## border()

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

Definition at line 2132 of file Image.cpp.

{
MagickCore::Image
*newImage;
RectangleInfo
borderInfo=geometry_;
GetPPException;
newImage=BorderImage(constImage(),&borderInfo,image()->compose,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## borderColor() [1/2]

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

Definition at line 429 of file Image.cpp.

{
modifyImage();
if (borderColor_.isValid())
image()->border_color=borderColor_;
else
image()->border_color=Color();
options()->borderColor(borderColor_);
}

## borderColor() [2/2]

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

Definition at line 441 of file Image.cpp.

{
return(constOptions()->borderColor());
}

## boundingBox()

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

Definition at line 446 of file Image.cpp.

{
RectangleInfo
bbox;
GetPPException;
bbox=GetImageBoundingBox(constImage(),exceptionInfo);
ThrowImageException;
return(Geometry(bbox));
}

## boxColor() [1/2]

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

Definition at line 457 of file Image.cpp.

{
modifyImage();
options()->boxColor(boxColor_);
}

## boxColor() [2/2]

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

Definition at line 463 of file Image.cpp.

{
return(constOptions()->boxColor());
}

## brightnessContrast()

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

Definition at line 2147 of file Image.cpp.

{
modifyImage();
GetPPException;
BrightnessContrastImage(image(),brightness_,contrast_,exceptionInfo);
ThrowImageException;
}

## 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.

{
modifyImage();
GetPPException;
GetAndSetPPChannelMask(channel_);
BrightnessContrastImage(image(),brightness_,contrast_,exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## 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.

{
MagickCore::Image
*newImage;
modifyImage();
GetPPException;
newImage=CannyEdgeImage(constImage(),radius_,sigma_,lowerPercent_,
upperPercent_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## cdl()

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

Definition at line 2181 of file Image.cpp.

{
modifyImage();
GetPPException;
(void) ColorDecisionListImage(image(),cdl_.c_str(),exceptionInfo);
ThrowImageException;
}

## channel()

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

Definition at line 2189 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=SeparateImage(constImage(),channel_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## channelDepth() [1/2]

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

Definition at line 479 of file Image.cpp.

{
size_t
channel_depth;
GetPPException;
GetAndSetPPChannelMask(channel_);
channel_depth=GetImageDepth(constImage(),exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
return(channel_depth);
}

## channelDepth() [2/2]

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

Definition at line 468 of file Image.cpp.

{
modifyImage();
GetPPException;
GetAndSetPPChannelMask(channel_);
SetImageDepth(image(),depth_,exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## channels()

size_t Magick::Image::channels | ( |  | ) | const

Definition at line 492 of file Image.cpp.

{
return(constImage()->number_channels);
}

## charcoal()

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

Definition at line 2200 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=CharcoalImage(image(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## 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.

{
MagickCore::Image
*newImage;
GetPPException;
GetAndSetPPChannelMask(channel_);
newImage=CharcoalImage(image(),radius_,sigma_,exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowImageException;
}

## chop()

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

Definition at line 2225 of file Image.cpp.

{
MagickCore::Image
*newImage;
RectangleInfo
chopInfo=geometry_;
GetPPException;
newImage=ChopImage(image(),&chopInfo,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## chromaBluePrimary() [1/2]

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

Definition at line 2239 of file Image.cpp.

{
modifyImage();
image()->chromaticity.blue_primary.x=x_;
image()->chromaticity.blue_primary.y=y_;
image()->chromaticity.blue_primary.z=z_;
}

## chromaBluePrimary() [2/2]

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

Definition at line 2248 of file Image.cpp.

{
*x_=constImage()->chromaticity.blue_primary.x;
*y_=constImage()->chromaticity.blue_primary.y;
*z_=constImage()->chromaticity.blue_primary.z;
}

## chromaGreenPrimary() [1/2]

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

Definition at line 2255 of file Image.cpp.

{
modifyImage();
image()->chromaticity.green_primary.x=x_;
image()->chromaticity.green_primary.y=y_;
image()->chromaticity.green_primary.z=z_;
}

## chromaGreenPrimary() [2/2]

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

Definition at line 2264 of file Image.cpp.

{
*x_=constImage()->chromaticity.green_primary.x;
*y_=constImage()->chromaticity.green_primary.y;
*z_=constImage()->chromaticity.green_primary.z;
}

## chromaRedPrimary() [1/2]

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

Definition at line 2271 of file Image.cpp.

{
modifyImage();
image()->chromaticity.red_primary.x=x_;
image()->chromaticity.red_primary.y=y_;
image()->chromaticity.red_primary.z=z_;
}

## chromaRedPrimary() [2/2]

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

Definition at line 2280 of file Image.cpp.

{
*x_=constImage()->chromaticity.red_primary.x;
*y_=constImage()->chromaticity.red_primary.y;
*z_=constImage()->chromaticity.red_primary.z;
}

## chromaWhitePoint() [1/2]

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

Definition at line 2287 of file Image.cpp.

{
modifyImage();
image()->chromaticity.white_point.x=x_;
image()->chromaticity.white_point.y=y_;
image()->chromaticity.white_point.z=z_;
}

## chromaWhitePoint() [2/2]

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

Definition at line 2296 of file Image.cpp.

{
*x_=constImage()->chromaticity.white_point.x;
*y_=constImage()->chromaticity.white_point.y;
*z_=constImage()->chromaticity.white_point.z;
}

## clamp()

void Magick::Image::clamp | ( | void |  | ) |

Definition at line 2303 of file Image.cpp.

{
modifyImage();
GetPPException;
ClampImage(image(),exceptionInfo);
ThrowImageException;
}

## clampChannel()

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

Definition at line 2311 of file Image.cpp.

{
modifyImage();
GetPPException;
GetAndSetPPChannelMask(channel_);
ClampImage(image(),exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## classType() [1/2]

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

Definition at line 497 of file Image.cpp.

{
if (classType() == PseudoClass && class_ == DirectClass)
{
// Use SyncImage to synchronize the DirectClass pixels with the
// color map and then set to DirectClass type.
modifyImage();
GetPPException;
SyncImage(image(),exceptionInfo);
ThrowImageException;
image()->colormap=(PixelInfo *)RelinquishMagickMemory(image()->colormap);
image()->storage_class=static_cast<MagickCore::ClassType>(DirectClass);
return;
}
if (classType() == DirectClass && class_ == PseudoClass)
{
// Quantize to create PseudoClass color map
modifyImage();
quantizeColors(MaxColormapSize);
quantize();
image()->storage_class=static_cast<MagickCore::ClassType>(PseudoClass);
}
}

## classType() [2/2]

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

Definition at line 522 of file Image.cpp.

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

## clip()

void Magick::Image::clip | ( | void |  | ) |

Definition at line 2321 of file Image.cpp.

{
modifyImage();
GetPPException;
ClipImage(image(),exceptionInfo);
ThrowImageException;
}

## clipPath()

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

Definition at line 2329 of file Image.cpp.

{
modifyImage();
GetPPException;
ClipImagePath(image(),pathname_.c_str(),(MagickBooleanType) inside_,
exceptionInfo);
ThrowImageException;
}

## clut()

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

Definition at line 2338 of file Image.cpp.

{
modifyImage();
GetPPException;
ClutImage(image(),clutImage_.constImage(),method,exceptionInfo);
ThrowImageException;
}

## clutChannel()

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

Definition at line 2347 of file Image.cpp.

{
modifyImage();
GetPPException;
GetAndSetPPChannelMask(channel_);
ClutImage(image(),clutImage_.constImage(),method,exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## colorFuzz() [1/2]

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

Definition at line 527 of file Image.cpp.

{
modifyImage();
image()->fuzz=fuzz_;
options()->colorFuzz(fuzz_);
}

## colorFuzz() [2/2]

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

Definition at line 534 of file Image.cpp.

{
return(constOptions()->colorFuzz());
}

## colorize() [1/2]

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

Definition at line 2358 of file Image.cpp.

{
colorize(alpha_,alpha_,alpha_,penColor_);
}

## 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.

{
char
blend[MagickPathExtent];
MagickCore::Image
*newImage;
PixelInfo
target;
if (!penColor_.isValid())
throwExceptionExplicit(MagickCore::OptionError,
"Pen color argument is invalid");
FormatLocaleString(blend,MagickPathExtent,"%u/%u/%u",alphaRed_,alphaGreen_,
alphaBlue_);
target=static_cast<PixelInfo>(penColor_);
GetPPException;
newImage=ColorizeImage(image(),blend,&target,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## colorMap() [1/2]

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

Definition at line 2415 of file Image.cpp.

{
if (!constImage()->colormap)
{
throwExceptionExplicit(MagickCore::OptionError,
"Image does not contain a colormap");
return(Color());
}
if (index_ > constImage()->colors-1)
throwExceptionExplicit(MagickCore::OptionError,"Index out of range");
return(Magick::Color((constImage()->colormap)[index_]));
}

## colorMap() [2/2]

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

Definition at line 2390 of file Image.cpp.

{
MagickCore::Image
*imageptr;
imageptr=image();
if (index_ > (MaxColormapSize-1))
throwExceptionExplicit(MagickCore::OptionError,
"Colormap index must be less than MaxColormapSize");
if (!color_.isValid())
throwExceptionExplicit(MagickCore::OptionError,
"Color argument is invalid");
modifyImage();
// Ensure that colormap size is large enough
if (colorMapSize() < (index_+1))
colorMapSize(index_+1);
// Set color at index in colormap
(imageptr->colormap)[index_]=color_;
}

## colorMapSize() [1/2]

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

Definition at line 539 of file Image.cpp.

{
if (entries_ >MaxColormapSize)
throwExceptionExplicit(MagickCore::OptionError,
"Colormap entries must not exceed MaxColormapSize");
modifyImage();
GetPPException;
(void) AcquireImageColormap(image(),entries_,exceptionInfo);
ThrowImageException;
}

## colorMapSize() [2/2]

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

Definition at line 551 of file Image.cpp.

{
if (!constImage()->colormap)
throwExceptionExplicit(MagickCore::OptionError,
"Image does not contain a colormap");
return(constImage()->colors);
}

## colorMatrix()

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

Definition at line 2430 of file Image.cpp.

{
KernelInfo
*kernel_info;
GetPPException;
kernel_info=AcquireKernelInfo((const char *) NULL,exceptionInfo);
if (kernel_info != (KernelInfo *) NULL)
{
kernel_info->width=order_;
kernel_info->height=order_;
kernel_info->values=(MagickRealType *) AcquireAlignedMemory(order_,
order_*sizeof(*kernel_info->values));
if (kernel_info->values != (MagickRealType *) NULL)
{
MagickCore::Image
*newImage;
for (ssize_t i=0; i < (ssize_t) (order_*order_); i++)
kernel_info->values[i]=color_matrix_[i];
newImage=ColorMatrixImage(image(),kernel_info,exceptionInfo);
replaceImage(newImage);
}
kernel_info=DestroyKernelInfo(kernel_info);
}
ThrowImageException;
}

## colorSpace() [1/2]

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

Definition at line 560 of file Image.cpp.

{
if (image()->colorspace == colorSpace_)
return;
modifyImage();
GetPPException;
TransformImageColorspace(image(),colorSpace_,exceptionInfo);
ThrowImageException;
}

## colorSpace() [2/2]

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

Definition at line 571 of file Image.cpp.

{
return (constImage()->colorspace);
}

## colorSpaceType() [1/2]

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

Definition at line 576 of file Image.cpp.

{
modifyImage();
GetPPException;
SetImageColorspace(image(),colorSpace_,exceptionInfo);
ThrowImageException;
options()->colorspaceType(colorSpace_);
}

## colorSpaceType() [2/2]

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

Definition at line 585 of file Image.cpp.

{
return(constOptions()->colorspaceType());
}

## columns()

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

Definition at line 590 of file Image.cpp.

{
return(constImage()->columns);
}

## comment() [1/2]

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

Definition at line 595 of file Image.cpp.

{
modifyImage();
GetPPException;
SetImageProperty(image(),"Comment",NULL,exceptionInfo);
if (comment_.length() > 0)
SetImageProperty(image(),"Comment",comment_.c_str(),exceptionInfo);
ThrowImageException;
}

## comment() [2/2]

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

Definition at line 605 of file Image.cpp.

{
const char
*value;
GetPPException;
value=GetImageProperty(constImage(),"Comment",exceptionInfo);
ThrowImageException;
if (value)
return(std::string(value));
return(std::string()); // Intentionally no exception
}

## compare() [1/3]

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

Definition at line 2459 of file Image.cpp.

{
bool
status;
Image
ref=reference_;
GetPPException;
status=static_cast<bool>(IsImagesEqual(constImage(),ref.constImage(),
exceptionInfo));
ThrowImageException;
return(status);
}

## compare() [2/3]

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

Definition at line 2474 of file Image.cpp.

{
double
distortion=0.0;
GetPPException;
GetImageDistortion(image(),reference_.constImage(),metric_,&distortion,
exceptionInfo);
ThrowImageException;
return(distortion);
}

## compare() [3/3]

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

Definition at line 2501 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=CompareImages(image(),reference_.constImage(),metric_,distortion,
exceptionInfo);
ThrowImageException;
if (newImage == (MagickCore::Image *) NULL)
return(Magick::Image());
else
return(Magick::Image(newImage));
}

## compareChannel() [1/2]

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

Definition at line 2486 of file Image.cpp.

{
double
distortion=0.0;
GetPPException;
GetAndSetPPChannelMask(channel_);
GetImageDistortion(image(),reference_.constImage(),metric_,&distortion,
exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
return(distortion);
}

## 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.

{
MagickCore::Image
*newImage;
GetPPException;
GetAndSetPPChannelMask(channel_);
newImage=CompareImages(image(),reference_.constImage(),metric_,distortion,
exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
if (newImage == (MagickCore::Image *) NULL)
return(Magick::Image());
else
return(Magick::Image(newImage));
}

## compose() [1/2]

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

Definition at line 620 of file Image.cpp.

{
image()->compose=compose_;
}

## compose() [2/2]

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

Definition at line 625 of file Image.cpp.

{
return(constImage()->compose);
}

## 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.

{
size_t
height=rows(),
width=columns();
ssize_t
x=offset_.xOff(),
y=offset_.yOff();
ParseMetaGeometry(static_cast<std::string>(offset_).c_str(),&x,&y,&width,
&height);
modifyImage();
GetPPException;
CompositeImage(image(),compositeImage_.constImage(),compose_,MagickTrue,
x,y,exceptionInfo);
ThrowImageException;
}

## 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.

{
RectangleInfo
geometry;
modifyImage();
SetGeometry(compositeImage_.constImage(),&geometry);
GravityAdjustGeometry(columns(),rows(),gravity_,&geometry);
GetPPException;
CompositeImage(image(),compositeImage_.constImage(),compose_,MagickTrue,
geometry.x,geometry.y,exceptionInfo);
ThrowImageException;
}

## compressType() [1/2]

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

Definition at line 630 of file Image.cpp.

{
modifyImage();
image()->compression=compressType_;
options()->compressType(compressType_);
}

## compressType() [2/2]

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

Definition at line 637 of file Image.cpp.

{
return(constImage()->compression);
}

## connectedComponents()

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

Definition at line 2585 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=ConnectedComponentsImage(constImage(),connectivity_,
(CCObjectInfo **) NULL,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## constImage()

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

Definition at line 5033 of file Image.cpp.

{
return(_imgRef->image());
}

## constImageInfo()

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

Definition at line 5043 of file Image.cpp.

{
return(_imgRef->options()->imageInfo());
}

## constOptions()

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

Definition at line 5053 of file Image.cpp.

{
return(_imgRef->options());
}

## constQuantizeInfo()

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

Definition at line 5063 of file Image.cpp.

{
return(_imgRef->options()->quantizeInfo());
}

## contrast()

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

Definition at line 2597 of file Image.cpp.

{
modifyImage();
GetPPException;
ContrastImage(image(),(MagickBooleanType) sharpen_,exceptionInfo);
ThrowImageException;
}

## contrastStretch()

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

Definition at line 2605 of file Image.cpp.

{
modifyImage();
GetPPException;
ContrastStretchImage(image(),blackPoint_,whitePoint_,exceptionInfo);
ThrowImageException;
}

## contrastStretchChannel()

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

Definition at line 2614 of file Image.cpp.

{
modifyImage();
GetPPException;
GetAndSetPPChannelMask(channel_);
ContrastStretchImage(image(),blackPoint_,whitePoint_,exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## convolve()

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

Definition at line 2625 of file Image.cpp.

{
KernelInfo
*kernel_info;
GetPPException;
kernel_info=AcquireKernelInfo((const char *) NULL,exceptionInfo);
kernel_info->width=order_;
kernel_info->height=order_;
kernel_info->x=(ssize_t) (order_-1)/2;
kernel_info->y=(ssize_t) (order_-1)/2;
kernel_info->values=(MagickRealType *) AcquireAlignedMemory(order_,
order_*sizeof(*kernel_info->values));
if (kernel_info->values != (MagickRealType *) NULL)
{
MagickCore::Image
*newImage;
for (ssize_t i=0; i < (ssize_t) (order_*order_); i++)
kernel_info->values[i]=kernel_[i];
newImage=ConvolveImage(image(),kernel_info,exceptionInfo);
replaceImage(newImage);
}
kernel_info=DestroyKernelInfo(kernel_info);
ThrowImageException;
}

## copyPixels()

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

Definition at line 2652 of file Image.cpp.

{
const OffsetInfo
offset=offset_;
const RectangleInfo
geometry=geometry_;
GetPPException;
(void) CopyImagePixels(image(),source_.constImage(),&geometry,&offset,
exceptionInfo);
ThrowImageException;
}

## crop()

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

Definition at line 2667 of file Image.cpp.

{
MagickCore::Image
*newImage;
RectangleInfo
cropInfo=geometry_;
GetPPException;
newImage=CropImage(constImage(),&cropInfo,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## cycleColormap()

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

Definition at line 2681 of file Image.cpp.

{
modifyImage();
GetPPException;
CycleColormapImage(image(),amount_,exceptionInfo);
ThrowImageException;
}

## debug() [1/2]

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

Definition at line 642 of file Image.cpp.

{
modifyImage();
options()->debug(flag_);
}

## debug() [2/2]

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

Definition at line 648 of file Image.cpp.

{
return(constOptions()->debug());
}

## decipher()

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

Definition at line 2689 of file Image.cpp.

{
modifyImage();
GetPPException;
DecipherImage(image(),passphrase_.c_str(),exceptionInfo);
ThrowImageException;
}

## defineSet() [1/2]

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

Definition at line 2711 of file Image.cpp.

{
const char
*option;
std::string
key;
key=magick_ + ":" + key_;
option=GetImageOption(constImageInfo(),key.c_str());
if (option)
return(true);
return(false);
}

## 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.

{
std::string
definition;
modifyImage();
definition=magick_ + ":" + key_;
if (flag_)
(void) SetImageOption(imageInfo(),definition.c_str(),"");
else
DeleteImageOption(imageInfo(),definition.c_str());
}

## 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.

{
const char
*option;
std::string
definition;
definition=magick_ + ":" + key_;
option=GetImageOption(constImageInfo(),definition.c_str());
if (option)
return(std::string(option));
return(std::string());
}

## 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.

{
std::string
format,
option;
modifyImage();
format=magick_ + ":" + key_;
option=value_;
(void) SetImageOption(imageInfo(),format.c_str(),option.c_str());
}

## density() [1/2]

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

Definition at line 653 of file Image.cpp.

{
modifyImage();
options()->density(density_);
if (density_.isValid())
{
image()->resolution.x=density_.x();
if (density_.y() != 0.0)
image()->resolution.y=density_.y();
else
image()->resolution.y=density_.x();
}
else
{
// Reset to default
image()->resolution.x=0.0;
image()->resolution.y=0.0;
}
}

## density() [2/2]

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

Definition at line 673 of file Image.cpp.

{
if (isValid())
{
double
x_resolution=72,
y_resolution=72;
if (constImage()->resolution.x > 0.0)
x_resolution=constImage()->resolution.x;
if (constImage()->resolution.y > 0.0)
y_resolution=constImage()->resolution.y;
return(Point(x_resolution, y_resolution));
}
return(constOptions()->density());
}

## depth() [1/2]

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

Definition at line 693 of file Image.cpp.

{
modifyImage();
image()->depth=depth_;
options()->depth(depth_);
}

## depth() [2/2]

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

Definition at line 700 of file Image.cpp.

{
return(constImage()->depth);
}

## deskew()

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

Definition at line 2756 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=DeskewImage(constImage(),threshold_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## despeckle()

void Magick::Image::despeckle | ( | void |  | ) |

Definition at line 2767 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=DespeckleImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## directory()

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

Definition at line 705 of file Image.cpp.

{
if (constImage()->directory)
return(std::string(constImage()->directory));
if (!quiet())
throwExceptionExplicit(MagickCore::CorruptImageWarning,
"Image does not contain a directory");
return(std::string());
}

## display()

void Magick::Image::display | ( | void |  | ) |

Definition at line 2778 of file Image.cpp.

{
GetPPException;
DisplayImages(imageInfo(),image(),exceptionInfo);
ThrowImageException;
}

## 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.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=DistortImage(constImage(), method_,numberArguments_,arguments_,
bestfit_ == true ? MagickTrue : MagickFalse,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## draw() [1/2]

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

Definition at line 2798 of file Image.cpp.

{
DrawingWand
*wand;
modifyImage();
wand=AcquireDrawingWand(options()->drawInfo(),image());
if(wand)
{
drawable_.operator()(wand);
DrawRender(wand);
ClonePPDrawException(wand);
wand=DestroyDrawingWand(wand);
ThrowPPDrawException(quiet());
}
}

## draw() [2/2]

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

Definition at line 2819 of file Image.cpp.

{
DrawingWand
*wand;
modifyImage();
wand= AcquireDrawingWand(options()->drawInfo(),image());
if(wand)
{
for (std::vector<Magick::Drawable>::const_iterator p = drawable_.begin();
p != drawable_.end(); p++ )
{
p->operator()(wand);
if (DrawGetExceptionType(wand) != MagickCore::UndefinedException)
break;
}
if (DrawGetExceptionType(wand) == MagickCore::UndefinedException)
DrawRender(wand);
ClonePPDrawException(wand);
wand=DestroyDrawingWand(wand);
ThrowPPDrawException(quiet());
}
}

## edge()

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

Definition at line 2847 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=EdgeImage(constImage(),radius_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## emboss()

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

Definition at line 2858 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=EmbossImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## encipher()

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

Definition at line 2869 of file Image.cpp.

{
modifyImage();
GetPPException;
EncipherImage(image(),passphrase_.c_str(),exceptionInfo);
ThrowImageException;
}

## endian()

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

Definition at line 724 of file Image.cpp.

{
return(constImage()->endian);
}

## enhance()

void Magick::Image::enhance | ( | void |  | ) |

Definition at line 2877 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=EnhanceImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## equalize()

void Magick::Image::equalize | ( | void |  | ) |

Definition at line 2888 of file Image.cpp.

{
modifyImage();
GetPPException;
EqualizeImage(image(),exceptionInfo);
ThrowImageException;
}

## erase()

void Magick::Image::erase | ( | void |  | ) |

Definition at line 2896 of file Image.cpp.

{
modifyImage();
GetPPException;
(void) SetImageBackgroundColor(image(),exceptionInfo);
ThrowImageException;
}

## evaluate() [1/2]

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

Definition at line 2904 of file Image.cpp.

{
GetPPException;
GetAndSetPPChannelMask(channel_);
EvaluateImage(image(),operator_,rvalue_,exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## 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.

{
GetPPException;
GetAndSetPPChannelMask(channel_);
FunctionImage(image(),function_,number_parameters_,parameters_,
exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## exifProfile() [1/2]

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

Definition at line 729 of file Image.cpp.

{
modifyImage();
if (exifProfile_.data() != 0)
{
StringInfo
*exif_profile;
exif_profile=AcquireStringInfo(exifProfile_.length());
SetStringInfoDatum(exif_profile,(unsigned char *) exifProfile_.data());
GetPPException;
(void) SetImageProfile(image(),"exif",exif_profile,exceptionInfo);
exif_profile=DestroyStringInfo(exif_profile);
ThrowImageException;
}
}

## exifProfile() [2/2]

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

Definition at line 747 of file Image.cpp.

{
const StringInfo
*exif_profile;
exif_profile=GetImageProfile(constImage(),"exif");
if (exif_profile == (StringInfo *) NULL)
return(Blob());
return(Blob(GetStringInfoDatum(exif_profile),
GetStringInfoLength(exif_profile)));
}

## extent() [1/4]

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

Definition at line 2953 of file Image.cpp.

{
MagickCore::Image
*newImage;
RectangleInfo
extentInfo=geometry_;
modifyImage();
extentInfo.x=geometry_.xOff();
extentInfo.y=geometry_.yOff();
GetPPException;
newImage=ExtentImage(image(),&extentInfo,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## extent() [2/4]

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

Definition at line 2970 of file Image.cpp.

{
backgroundColor(backgroundColor_);
extent(geometry_);
}

## extent() [3/4]

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

Definition at line 2977 of file Image.cpp.

{
backgroundColor(backgroundColor_);
extent(geometry_,gravity_);
}

## extent() [4/4]

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

Definition at line 2984 of file Image.cpp.

{
RectangleInfo
geometry;
SetGeometry(image(),&geometry);
geometry.width=geometry_.width();
geometry.height=geometry_.height();
GravityAdjustGeometry(image()->columns,image()->rows,gravity_,&geometry);
extent(geometry);
}

## fileName() [1/2]

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

Definition at line 759 of file Image.cpp.

{
ssize_t
max_length;
modifyImage();
max_length=sizeof(image()->filename)-1;
fileName_.copy(image()->filename,(size_t) max_length);
if ((ssize_t) fileName_.length() > max_length)
image()->filename[max_length]=0;
else
image()->filename[fileName_.length()]=0;
options()->fileName(fileName_);
}

## fileName() [2/2]

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

Definition at line 776 of file Image.cpp.

{
return(constOptions()->fileName());
}

## fileSize()

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

Definition at line 781 of file Image.cpp.

{
return(GetBlobSize(constImage()));
}

## fillColor() [1/2]

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

Definition at line 786 of file Image.cpp.

{
modifyImage();
options()->fillColor(fillColor_);
}

## fillColor() [2/2]

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

Definition at line 792 of file Image.cpp.

{
return(constOptions()->fillColor());
}

## fillPattern() [1/2]

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

Definition at line 808 of file Image.cpp.

{
modifyImage();
if (fillPattern_.isValid())
options()->fillPattern(fillPattern_.constImage());
else
options()->fillPattern(static_cast<MagickCore::Image*>(NULL));
}

## fillPattern() [2/2]

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

Definition at line 817 of file Image.cpp.

{
// FIXME: This is inordinately inefficient
const MagickCore::Image
*tmpTexture;
Image
texture;
tmpTexture=constOptions()->fillPattern();
if (tmpTexture)
{
MagickCore::Image
*image;
GetPPException;
image=CloneImage(tmpTexture,0,0,MagickTrue,exceptionInfo);
texture.replaceImage(image);
ThrowImageException;
}
return(texture);
}

## fillRule()

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

Definition at line 803 of file Image.cpp.

{
return constOptions()->fillRule();
}

## filterType()

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

Definition at line 847 of file Image.cpp.

{
return(constImage()->filter);
}

## flip()

void Magick::Image::flip | ( | void |  | ) |

Definition at line 2997 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=FlipImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## 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 5125 of file Image.cpp.

{
Magick::Color
fillColor;
MagickCore::Image
*fillPattern;
// Set drawing fill pattern or fill color
fillColor=options()->fillColor();
fillPattern=(MagickCore::Image *)NULL;
if (options()->fillPattern() != (MagickCore::Image *)NULL)
{
GetPPException;
fillPattern=CloneImage(options()->fillPattern(),0,0,MagickTrue,
exceptionInfo);
ThrowImageException;
}
if (fillPattern_ == (Magick::Image *)NULL)
{
options()->fillPattern((MagickCore::Image *)NULL);
options()->fillColor(fill_);
}
else
options()->fillPattern(fillPattern_->constImage());
GetPPException;
(void) FloodfillPaintImage(image(),options()->drawInfo(),
target_,static_cast<ssize_t>(x_),static_cast<ssize_t>(y_),
(MagickBooleanType) invert_,exceptionInfo);
options()->fillColor(fillColor);
options()->fillPattern(fillPattern);
ThrowImageException;
}

## 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.

{
PixelInfo
target;
modifyImage();
target=static_cast<PixelInfo>(target_);
target.alpha=alpha_;
GetPPException;
GetAndSetPPChannelMask(AlphaChannel);
FloodfillPaintImage(image(),options()->drawInfo(),&target,x_,y_,
(MagickBooleanType)invert_,exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## 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.

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

## 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.

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

## 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.

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

## 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.

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

## flop()

void Magick::Image::flop | ( | void |  | ) |

Definition at line 3120 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=FlopImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## font() [1/2]

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

Definition at line 852 of file Image.cpp.

{
modifyImage();
options()->font(font_);
}

## font() [2/2]

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

Definition at line 858 of file Image.cpp.

{
return(constOptions()->font());
}

## fontFamily() [1/2]

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

Definition at line 863 of file Image.cpp.

{
modifyImage();
options()->fontFamily(family_);
}

## fontFamily() [2/2]

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

Definition at line 869 of file Image.cpp.

{
return(constOptions()->fontFamily());
}

## fontPointsize() [1/2]

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

Definition at line 874 of file Image.cpp.

{
modifyImage();
options()->fontPointsize(pointSize_);
}

## fontPointsize() [2/2]

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

Definition at line 880 of file Image.cpp.

{
return(constOptions()->fontPointsize());
}

## fontStyle() [1/2]

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

Definition at line 885 of file Image.cpp.

{
modifyImage();
options()->fontStyle(pointSize_);
}

## fontStyle() [2/2]

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

Definition at line 891 of file Image.cpp.

{
return(constOptions()->fontStyle());
}

## fontTypeMetrics()

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

Definition at line 3131 of file Image.cpp.

{
DrawInfo
*drawInfo;
drawInfo=options()->drawInfo();
drawInfo->text=DestroyString(drawInfo->text);
drawInfo->text=const_cast<char *>(text_.c_str());
GetPPException;
GetTypeMetrics(image(),drawInfo,&(metrics->_typeMetric),exceptionInfo);
drawInfo->text=(char *) NULL;
ThrowImageException;
}

## fontTypeMetricsMultiline()

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

Definition at line 3146 of file Image.cpp.

{
DrawInfo
*drawInfo;
drawInfo=options()->drawInfo();
drawInfo->text=DestroyString(drawInfo->text);
drawInfo->text=const_cast<char *>(text_.c_str());
GetPPException;
(void) GetMultilineTypeMetrics(image(),drawInfo,&(metrics->_typeMetric),
exceptionInfo);
drawInfo->text=(char *) NULL;
ThrowImageException;
}

## fontWeight() [1/2]

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

Definition at line 896 of file Image.cpp.

{
modifyImage();
options()->fontWeight(weight_);
}

## fontWeight() [2/2]

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

Definition at line 902 of file Image.cpp.

{
return(constOptions()->fontWeight());
}

## format()

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

Definition at line 907 of file Image.cpp.

{
const MagickInfo
*magick_info;
GetPPException;
magick_info=GetMagickInfo(constImage()->magick,exceptionInfo);
ThrowImageException;
if ((magick_info != 0) && (*magick_info->description != '\0'))
return(std::string(magick_info->description));
if (!quiet())
throwExceptionExplicit(MagickCore::CorruptImageWarning,
"Unrecognized image magick type");
return(std::string());
}

## formatExpression()

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

Definition at line 926 of file Image.cpp.

{
char
*text;
std::string
text_string;
GetPPException;
modifyImage();
text=InterpretImageProperties(imageInfo(),image(),expression.c_str(),
exceptionInfo);
if (text != (char *) NULL)
{
text_string=std::string(text);
text=DestroyString(text);
}
ThrowImageException;
return(text_string);
}

## frame()

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

Definition at line 3162 of file Image.cpp.

{
FrameInfo
info;
MagickCore::Image
*newImage;
info.x=static_cast<ssize_t>(geometry_.width());
info.y=static_cast<ssize_t>(geometry_.height());
info.width=columns() + (static_cast<size_t>(info.x) << 1);
info.height=rows() + (static_cast<size_t>(info.y) << 1);
info.outer_bevel=geometry_.xOff();
info.inner_bevel=geometry_.yOff();
GetPPException;
newImage=FrameImage(constImage(),&info,image()->compose,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## fx() [1/2]

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

Definition at line 3205 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=FxImage(constImage(),expression_.c_str(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## fx() [2/2]

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

Definition at line 3216 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
GetAndSetPPChannelMask(channel_);
newImage=FxImage(constImage(),expression_.c_str(),exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowImageException;
}

## gamma() [1/3]

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

Definition at line 3230 of file Image.cpp.

{
modifyImage();
GetPPException;
GammaImage(image(),gamma_,exceptionInfo);
ThrowImageException;
}

## gamma() [2/3]

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

Definition at line 3238 of file Image.cpp.

{
modifyImage();
GetPPException;
GetAndSetPPChannelMask(RedChannel);
(void) GammaImage(image(),gammaRed_,exceptionInfo);
SetPPChannelMask(GreenChannel);
(void) GammaImage(image(),gammaGreen_,exceptionInfo);
SetPPChannelMask(BlueChannel);
(void) GammaImage(image(),gammaBlue_,exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## gamma() [3/3]

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

Definition at line 947 of file Image.cpp.

{
return(constImage()->gamma);
}

## gaussianBlur()

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

Definition at line 3253 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=GaussianBlurImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## gaussianBlurChannel()

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

Definition at line 3264 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
GetAndSetPPChannelMask(channel_);
newImage=GaussianBlurImage(constImage(),radius_,sigma_,exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowImageException;
}

## geometry()

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

Definition at line 952 of file Image.cpp.

{
if (constImage()->geometry)
return Geometry(constImage()->geometry);
if (!quiet())
throwExceptionExplicit(MagickCore::OptionWarning,
"Image does not contain a geometry");
return(Geometry());
}

## getConstMetacontent()

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

Definition at line 3290 of file Image.cpp.

{
const void
*result;
result=GetVirtualMetacontent(constImage());
if(!result)
throwExceptionExplicit(MagickCore::OptionError,
"Unable to retrieve meta content.");
return(result);
}

## 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.

{
const Quantum
*p;
GetPPException;
p=GetVirtualPixels(constImage(),x_, y_,columns_, rows_,exceptionInfo);
ThrowImageException;
return(p);
}

## getMetacontent()

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

Definition at line 3304 of file Image.cpp.

{
void
*result;
result=GetAuthenticMetacontent(image());
if(!result)
throwExceptionExplicit(MagickCore::OptionError,
"Unable to retrieve meta content.");
return(result);
}

## 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.

{
Quantum
*result;
modifyImage();
GetPPException;
result=GetAuthenticPixels(image(),x_, y_,columns_,rows_,exceptionInfo);
ThrowImageException;
return(result);
}

## gifDisposeMethod()

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

Definition at line 971 of file Image.cpp.

{
return(constImage()->dispose);
}

## grayscale()

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

Definition at line 3332 of file Image.cpp.

{
modifyImage();
GetPPException;
(void) GrayscaleImage(image(),method_,exceptionInfo);
ThrowImageException;
}

## haldClut()

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

Definition at line 3340 of file Image.cpp.

{
modifyImage();
GetPPException;
(void) HaldClutImage(image(),clutImage_.constImage(),exceptionInfo);
ThrowImageException;
}

## hasChannel()

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

Definition at line 976 of file Image.cpp.

{
if (GetPixelChannelTraits(constImage(),channel) == UndefinedPixelTrait)
return(false);
if (channel == GreenPixelChannel || channel == BluePixelChannel)
return (GetPixelChannelOffset(constImage(),channel) == (ssize_t)channel);
return(true);
}

## highlightColor()

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

Definition at line 987 of file Image.cpp.

{
std::string
value;
value=color_;
artifact("compare:highlight-color",value);
}

## 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.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=HoughLineImage(constImage(),width_,height_,threshold_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## iccColorProfile() [1/2]

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

Definition at line 996 of file Image.cpp.

{
profile("icc",colorProfile_);
}

## iccColorProfile() [2/2]

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

Definition at line 1001 of file Image.cpp.

{
const StringInfo
*color_profile;
color_profile=GetImageProfile(constImage(),"icc");
if (color_profile == (StringInfo *) NULL)
return(Blob());
return(Blob(GetStringInfoDatum(color_profile),GetStringInfoLength(
color_profile)));
}

## identifyType()

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

Definition at line 3361 of file Image.cpp.

{
ImageType
image_type;
GetPPException;
image_type=IdentifyImageType(constImage(),exceptionInfo);
ThrowImageException;
return(image_type);
}

## image()

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

Definition at line 5028 of file Image.cpp.

{
return(_imgRef->image());
}

## imageInfo()

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

Definition at line 5038 of file Image.cpp.

{
return(_imgRef->options()->imageInfo());
}

## implode()

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

Definition at line 3372 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=ImplodeImage(constImage(),factor_,image()->interpolate,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## interlaceType()

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

Definition at line 1020 of file Image.cpp.

{
return(constImage()->interlace);
}

## interpolate() [1/2]

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

Definition at line 1025 of file Image.cpp.

{
modifyImage();
image()->interpolate=interpolate_;
}

## interpolate() [2/2]

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

Definition at line 1031 of file Image.cpp.

{
return constImage()->interpolate;
}

## inverseFourierTransform() [1/2]

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

Definition at line 3384 of file Image.cpp.

{
inverseFourierTransform(phase_,true);
}

## inverseFourierTransform() [2/2]

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

Definition at line 3389 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=InverseFourierTransformImage(constImage(),phase_.constImage(),
magnitude_ == true ? MagickTrue : MagickFalse,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## iptcProfile() [1/2]

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

Definition at line 1036 of file Image.cpp.

{
modifyImage();
if (iptcProfile_.data() != 0)
{
StringInfo
*iptc_profile;
iptc_profile=AcquireStringInfo(iptcProfile_.length());
SetStringInfoDatum(iptc_profile,(unsigned char *) iptcProfile_.data());
GetPPException;
(void) SetImageProfile(image(),"iptc",iptc_profile,exceptionInfo);
iptc_profile=DestroyStringInfo(iptc_profile);
ThrowImageException;
}
}

## iptcProfile() [2/2]

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

Definition at line 1053 of file Image.cpp.

{
const StringInfo
*iptc_profile;
iptc_profile=GetImageProfile(constImage(),"iptc");
if (iptc_profile == (StringInfo *) NULL)
return(Blob());
return(Blob(GetStringInfoDatum(iptc_profile),GetStringInfoLength(
iptc_profile)));
}

## isOpaque()

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

Definition at line 1065 of file Image.cpp.

{
MagickBooleanType
result;
GetPPException;
result=IsImageOpaque(constImage(),exceptionInfo);
ThrowImageException;
return(result != MagickFalse ? true : false);
}

## isValid() [1/2]

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

Definition at line 1076 of file Image.cpp.

{
if (!isValid_)
{
delete _imgRef;
_imgRef=new ImageRef;
}
else if (!isValid())
{
// Construct with single-pixel black image to make
// image valid. This is an obvious hack.
size(Geometry(1,1));
read("xc:black");
}
}

## isValid() [2/2]

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

Definition at line 1092 of file Image.cpp.

{
return rows() && columns();
}

## kuwahara()

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

Definition at line 3402 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=KuwaharaImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## 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.

{
MagickCore::Image
*newImage;
GetPPException;
GetAndSetPPChannelMask(channel_);
newImage=KuwaharaImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
RestorePPChannelMask;
ThrowImageException;
}

## label() [1/2]

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

Definition at line 1097 of file Image.cpp.

{
modifyImage();
GetPPException;
(void) SetImageProperty(image(),"Label",NULL,exceptionInfo);
if (label_.length() > 0)
(void) SetImageProperty(image(),"Label",label_.c_str(),exceptionInfo);
ThrowImageException;
}

## label() [2/2]

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

Definition at line 1107 of file Image.cpp.

{
const char
*value;
GetPPException;
value=GetImageProperty(constImage(),"Label",exceptionInfo);
ThrowImageException;
if (value)
return(std::string(value));
return(std::string());
}

## level()

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

Definition at line 3427 of file Image.cpp.

{
modifyImage();
GetPPException;
(void) LevelImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
ThrowImageException;
}

## 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.

{
modifyImage();
GetPPException;
GetAndSetPPChannelMask(channel_);
(void) LevelImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## levelColors()

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

Definition at line 3447 of file Image.cpp.

{
PixelInfo
black,
white;
modifyImage();
black=static_cast<PixelInfo>(blackColor_);
white=static_cast<PixelInfo>(whiteColor_);
GetPPException;
(void) LevelImageColors(image(),&black,&white,invert_ == true ?
MagickTrue : MagickFalse,exceptionInfo);
ThrowImageException;
}

## 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.

{
PixelInfo
black,
white;
modifyImage();
black=static_cast<PixelInfo>(blackColor_);
white=static_cast<PixelInfo>(whiteColor_);
GetPPException;
GetAndSetPPChannelMask(channel_);
(void) LevelImageColors(image(),&black,&white,invert_ == true ?
MagickTrue : MagickFalse,exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## levelize()

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

Definition at line 3483 of file Image.cpp.

{
modifyImage();
GetPPException;
(void) LevelizeImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
ThrowImageException;
}

## 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.

{
modifyImage();
GetPPException;
GetAndSetPPChannelMask(channel_);
(void) LevelizeImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## linearStretch()

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

Definition at line 3503 of file Image.cpp.

{
modifyImage();
GetPPException;
LinearStretchImage(image(),blackPoint_,whitePoint_,exceptionInfo);
ThrowImageException;
}

## liquidRescale()

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

Definition at line 3512 of file Image.cpp.

{
MagickCore::Image
*newImage;
size_t
height=rows(),
width=columns();
ssize_t
x=0,
y=0;
ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
&height);
GetPPException;
newImage=LiquidRescaleImage(image(),width,height,(double) x,(double) y,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## localContrast()

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

Definition at line 3534 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=LocalContrastImage(constImage(),radius_,strength_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## localContrastChannel()

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

Definition at line 3545 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
GetAndSetPPChannelMask(channel_);
newImage=LocalContrastImage(constImage(),radius_,strength_,exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowImageException;
}

## lowlightColor()

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

Definition at line 1122 of file Image.cpp.

{
std::string
value;
value=color_;
artifact("compare:lowlight-color",value);
}

## magick() [1/2]

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

Definition at line 1131 of file Image.cpp.

{
size_t
length;
modifyImage();
length=sizeof(image()->magick)-1;
if (magick_.length() < length)
length=magick_.length();
if (!magick_.empty())
magick_.copy(image()->magick,length);
image()->magick[length]=0;
options()->magick(magick_);
}

## magick() [2/2]

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

Definition at line 1149 of file Image.cpp.

{
if (*(constImage()->magick) != '\0')
return(std::string(constImage()->magick));
return(constOptions()->magick());
}

## magnify()

void Magick::Image::magnify | ( | void |  | ) |

Definition at line 3559 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=MagnifyImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## map() [1/2]

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

Definition at line 3570 of file Image.cpp.

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

## map() [2/2]

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

Definition at line 3575 of file Image.cpp.

{
modifyImage();
GetPPException;
options()->quantizeDither(ditherMethod_);
RemapImage(options()->quantizeInfo(),image(),mapImage_.constImage(),
exceptionInfo);
ThrowImageException;
}

## mask() [1/2]

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

private

Definition at line 5164 of file Image.cpp.

{
modifyImage();
GetPPException;
if (mask_.isValid())
SetImageMask(image(),type,mask_.constImage(),exceptionInfo);
else
SetImageMask(image(),type,(MagickCore::Image *) NULL,exceptionInfo);
ThrowImageException;
}

## mask() [2/2]

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

private

Definition at line 5176 of file Image.cpp.

{
MagickCore::Image
*image;
GetPPException;
image = GetImageMask(constImage(),type,exceptionInfo);
ThrowImageException;
if (image == (MagickCore::Image *) NULL)
return(Magick::Image());
else
return(Magick::Image(image));
}

## masklightColor()

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

Definition at line 1157 of file Image.cpp.

{
std::string
value;
value=color_;
artifact("compare:masklight-color",value);
}

## matteColor() [1/2]

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

Definition at line 331 of file Image.cpp.

{
modifyImage();
if (matteColor_.isValid())
{
image()->matte_color=matteColor_;
options()->matteColor(matteColor_);
}
else
{
// Set to default matte color
Color tmpColor("#BDBDBD");
image()->matte_color=tmpColor;
options()->matteColor(tmpColor);
}
}

## matteColor() [2/2]

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

Definition at line 349 of file Image.cpp.

{
return(Color(constImage()->matte_color));
}

## meanErrorPerPixel()

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

Definition at line 1166 of file Image.cpp.

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

## meanShift()

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

Definition at line 3585 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=MeanShiftImage(constImage(),width_,height_,color_distance_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## medianFilter()

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

Definition at line 3598 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=StatisticImage(image(),MedianStatistic,(size_t) radius_,
(size_t) radius_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## minify()

void Magick::Image::minify | ( | void |  | ) |

Definition at line 3610 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=MinifyImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## modifyImage()

void Magick::Image::modifyImage | ( | void |  | ) |

Definition at line 5068 of file Image.cpp.

{
if (!_imgRef->isShared())
return;
GetPPException;
replaceImage(CloneImage(image(),0,0,MagickTrue,exceptionInfo));
ThrowImageException;
}

## modulate()

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

Definition at line 3621 of file Image.cpp.

{
char
modulate[MagickPathExtent + 1];
FormatLocaleString(modulate,MagickPathExtent,"%3.6f,%3.6f,%3.6f",brightness_,
saturation_,hue_);
modifyImage();
GetPPException;
ModulateImage(image(),modulate,exceptionInfo);
ThrowImageException;
}

## modulusDepth() [1/2]

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

Definition at line 1171 of file Image.cpp.

{
modifyImage();
GetPPException;
SetImageDepth(image(),depth_,exceptionInfo);
ThrowImageException;
options()->depth(depth_);
}

## modulusDepth() [2/2]

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

Definition at line 1180 of file Image.cpp.

{
size_t
depth;
GetPPException;
depth=GetImageDepth(constImage(),exceptionInfo);
ThrowImageException;
return(depth);
}

## moments()

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

Definition at line 3636 of file Image.cpp.

{
return(ImageMoments(*this));
}

## monochrome() [1/2]

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

Definition at line 1191 of file Image.cpp.

{
modifyImage();
options()->monochrome(monochromeFlag_);
}

## monochrome() [2/2]

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

Definition at line 1197 of file Image.cpp.

{
return(constOptions()->monochrome());
}

## montageGeometry()

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

Definition at line 1202 of file Image.cpp.

{
if (constImage()->montage)
return Magick::Geometry(constImage()->montage);
if (!quiet())
throwExceptionExplicit(MagickCore::CorruptImageWarning,
"Image does not contain a montage");
return(Magick::Geometry());
}

## 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 3661 of file Image.cpp.

{
const char
*option;
std::string
kernel;
option=CommandOptionToMnemonic(MagickKernelOptions,kernel_);
if (option == (const char *)NULL)
{
throwExceptionExplicit(MagickCore::OptionError,
"Unable to determine kernel type.");
return;
}
kernel=std::string(option);
if (!arguments_.empty())
kernel+=":"+arguments_;
morphology(method_,kernel,iterations_);
}

## morphology() [2/2]

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

Definition at line 3641 of file Image.cpp.

{
KernelInfo
*kernel;
MagickCore::Image
*newImage;
GetPPException;
kernel=AcquireKernelInfo(kernel_.c_str(),exceptionInfo);
if (kernel == (KernelInfo *) NULL)
throwExceptionExplicit(MagickCore::OptionError,"Unable to parse kernel.");
newImage=MorphologyImage(constImage(),method_,iterations_,kernel,
exceptionInfo);
replaceImage(newImage);
kernel=DestroyKernelInfo(kernel);
ThrowImageException;
}

## 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 3713 of file Image.cpp.

{
const char
*option;
std::string
kernel;
option=CommandOptionToMnemonic(MagickKernelOptions,kernel_);
if (option == (const char *)NULL)
{
throwExceptionExplicit(MagickCore::OptionError,
"Unable to determine kernel type.");
return;
}
kernel=std::string(option);
if (!arguments_.empty())
kernel+=":"+arguments_;
morphologyChannel(channel_,method_,kernel,iterations_);
}

## 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 3685 of file Image.cpp.

{
KernelInfo
*kernel;
MagickCore::Image
*newImage;
GetPPException;
kernel=AcquireKernelInfo(kernel_.c_str(),exceptionInfo);
if (kernel == (KernelInfo *)NULL)
{
throwExceptionExplicit(MagickCore::OptionError,
"Unable to parse kernel.");
return;
}
GetAndSetPPChannelMask(channel_);
newImage=MorphologyImage(constImage(),method_,iterations_,kernel,
exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
kernel=DestroyKernelInfo(kernel);
ThrowImageException;
}

## motionBlur()

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

Definition at line 3738 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=MotionBlurImage(constImage(),radius_,sigma_,angle_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## negate()

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

Definition at line 3750 of file Image.cpp.

{
modifyImage();
GetPPException;
NegateImage(image(),(MagickBooleanType) grayscale_,exceptionInfo);
ThrowImageException;
}

## negateChannel()

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

Definition at line 3758 of file Image.cpp.

{
modifyImage();
GetPPException;
GetAndSetPPChannelMask(channel_);
NegateImage(image(),(MagickBooleanType) grayscale_,exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## normalize()

void Magick::Image::normalize | ( | void |  | ) |

Definition at line 3769 of file Image.cpp.

{
modifyImage();
GetPPException;
NormalizeImage(image(),exceptionInfo);
ThrowImageException;
}

## normalizedMaxError()

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

Definition at line 1214 of file Image.cpp.

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

## normalizedMeanError()

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

Definition at line 1219 of file Image.cpp.

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

## oilPaint()

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

Definition at line 3777 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=OilPaintImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## opaque()

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

Definition at line 3788 of file Image.cpp.

{
std::string
opaqueColor,
penColor;
PixelInfo
opaque,
pen;
if (!opaqueColor_.isValid())
throwExceptionExplicit(MagickCore::OptionError,
"Opaque color argument is invalid");
if (!penColor_.isValid())
throwExceptionExplicit(MagickCore::OptionError,
"Pen color argument is invalid");
modifyImage();
opaqueColor=opaqueColor_;
penColor=penColor_;
GetPPException;
(void) QueryColorCompliance(opaqueColor.c_str(),AllCompliance,&opaque,
exceptionInfo);
(void) QueryColorCompliance(penColor.c_str(),AllCompliance,&pen,
exceptionInfo);
OpaquePaintImage(image(),&opaque,&pen,invert_ ? MagickTrue : MagickFalse,
exceptionInfo);
ThrowImageException;
}

## operator=()

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

Definition at line 282 of file Image.cpp.

{
if (this != &image_)
{
image_._imgRef->increase();
if (_imgRef->decrease() == 0)
delete _imgRef;
// Use new image reference
_imgRef=image_._imgRef;
}
return(*this);
}

## options()

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

Definition at line 5048 of file Image.cpp.

{
return(_imgRef->options());
}

## orderedDither()

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

Definition at line 3821 of file Image.cpp.

{
modifyImage();
GetPPException;
(void) OrderedDitherImage(image(),thresholdMap_.c_str(),exceptionInfo);
ThrowImageException;
}

## orderedDitherChannel()

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

Definition at line 3829 of file Image.cpp.

{
modifyImage();
GetPPException;
GetAndSetPPChannelMask(channel_);
(void)OrderedDitherImage(image(),thresholdMap_.c_str(),exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## orientation()

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

Definition at line 1230 of file Image.cpp.

{
return(constImage()->orientation);
}

## page() [1/2]

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

Definition at line 1235 of file Image.cpp.

{
modifyImage();
options()->page(pageSize_);
image()->page=pageSize_;
}

## page() [2/2]

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

Definition at line 1242 of file Image.cpp.

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

## perceptible()

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

Definition at line 3840 of file Image.cpp.

{
modifyImage();
GetPPException;
PerceptibleImage(image(),epsilon_,exceptionInfo);
ThrowImageException;
}

## perceptibleChannel()

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

Definition at line 3848 of file Image.cpp.

{
modifyImage();
GetPPException;
GetAndSetPPChannelMask(channel_);
PerceptibleImage(image(),epsilon_,exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## perceptualHash()

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

Definition at line 3859 of file Image.cpp.

{
return(ImagePerceptualHash(*this));
}

## ping() [1/2]

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

Definition at line 3875 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=PingBlob(imageInfo(),blob_.data(),blob_.length(),exceptionInfo);
read(newImage,exceptionInfo);
}

## ping() [2/2]

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

Definition at line 3864 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
options()->fileName(imageSpec_);
newImage=PingImage(imageInfo(),exceptionInfo);
read(newImage,exceptionInfo);
}

## polaroid()

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

Definition at line 3933 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=PolaroidImage(constImage(),options()->drawInfo(),caption_.c_str(),
angle_,method_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## posterize()

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

Definition at line 3946 of file Image.cpp.

{
modifyImage();
GetPPException;
PosterizeImage(image(),levels_,method_,exceptionInfo);
ThrowImageException;
}

## posterizeChannel()

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

Definition at line 3954 of file Image.cpp.

{
modifyImage();
GetPPException;
GetAndSetPPChannelMask(channel_);
PosterizeImage(image(),levels_,method_,exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## process()

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

Definition at line 3965 of file Image.cpp.

{
modifyImage();
GetPPException;
(void) InvokeDynamicImageFilter(name_.c_str(),&image(),(int) argc,argv,
exceptionInfo);
ThrowImageException;
}

## profile() [1/2]

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

Definition at line 3986 of file Image.cpp.

{
const StringInfo
*profile;
profile=GetImageProfile(constImage(),name_.c_str());
if (profile == (StringInfo *) NULL)
return(Blob());
return(Blob((void*) GetStringInfoDatum(profile),GetStringInfoLength(
profile)));
}

## profile() [2/2]

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

Definition at line 3976 of file Image.cpp.

{
modifyImage();
GetPPException;
(void) ProfileImage(image(),name_.c_str(),(unsigned char *)profile_.data(),
profile_.length(),exceptionInfo);
ThrowImageException;
}

## quality() [1/2]

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

Definition at line 1248 of file Image.cpp.

{
modifyImage();
image()->quality=quality_;
options()->quality(quality_);
}

## quality() [2/2]

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

Definition at line 1255 of file Image.cpp.

{
return(constImage()->quality);
}

## quantize()

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

Definition at line 3999 of file Image.cpp.

{
modifyImage();
if (measureError_)
options()->quantizeInfo()->measure_error=MagickTrue;
else
options()->quantizeInfo()->measure_error=MagickFalse;
GetPPException;
QuantizeImage(options()->quantizeInfo(),image(),exceptionInfo);
ThrowImageException;
}

## quantizeColors() [1/2]

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

Definition at line 1260 of file Image.cpp.

{
modifyImage();
options()->quantizeColors(colors_);
}

## quantizeColors() [2/2]

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

Definition at line 1266 of file Image.cpp.

{
return(constOptions()->quantizeColors());
}

## quantizeColorSpace()

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

Definition at line 1278 of file Image.cpp.

{
return(constOptions()->quantizeColorSpace());
}

## quantizeDither() [1/2]

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

Definition at line 1283 of file Image.cpp.

{
modifyImage();
options()->quantizeDither(ditherFlag_);
}

## quantizeDither() [2/2]

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

Definition at line 1289 of file Image.cpp.

{
return(constOptions()->quantizeDither());
}

## quantizeDitherMethod() [1/2]

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

Definition at line 1294 of file Image.cpp.

{
modifyImage();
options()->quantizeDitherMethod(ditherMethod_);
}

## quantizeDitherMethod() [2/2]

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

Definition at line 1300 of file Image.cpp.

{
return(constOptions()->quantizeDitherMethod());
}

## quantizeInfo()

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

Definition at line 5058 of file Image.cpp.

{
return(_imgRef->options()->quantizeInfo());
}

## quantizeTreeDepth() [1/2]

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

Definition at line 1305 of file Image.cpp.

{
modifyImage();
options()->quantizeTreeDepth(treeDepth_);
}

## quantizeTreeDepth() [2/2]

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

Definition at line 1311 of file Image.cpp.

{
return(constOptions()->quantizeTreeDepth());
}

## quiet() [1/2]

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

Definition at line 1316 of file Image.cpp.

{
modifyImage();
options()->quiet(quiet_);
}

## quiet() [2/2]

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

Definition at line 1322 of file Image.cpp.

{
return(constOptions()->quiet());
}

## raise()

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

Definition at line 4013 of file Image.cpp.

{
RectangleInfo
raiseInfo=geometry_;
GetPPException;
modifyImage();
RaiseImage(image(),&raiseInfo,raisedFlag_ == true ? MagickTrue : MagickFalse,
exceptionInfo);
ThrowImageException;
}

## randomThreshold()

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

Definition at line 4025 of file Image.cpp.

{
GetPPException;
(void) RandomThresholdImage(image(),low_,high_,exceptionInfo);
ThrowImageException;
}

## randomThresholdChannel()

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

Definition at line 4032 of file Image.cpp.

{
modifyImage();
GetPPException;
GetAndSetPPChannelMask(channel_);
(void) RandomThresholdImage(image(),low_,high_,exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## read() [1/9]

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

Definition at line 4043 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=BlobToImage(imageInfo(),static_cast<const void *>(blob_.data()),
blob_.length(),exceptionInfo);
read(newImage,exceptionInfo);
}

## read() [2/9]

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

Definition at line 4054 of file Image.cpp.

{
size(size_);
read(blob_);
}

## read() [3/9]

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

Definition at line 4060 of file Image.cpp.

{
size(size_);
depth(depth_);
read(blob_);
}

## read() [4/9]

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

Definition at line 4068 of file Image.cpp.

{
size(size_);
depth(depth_);
magick(magick_);
// Set explicit image format
fileName(magick_ + ':');
read(blob_);
}

## read() [5/9]

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

Definition at line 4079 of file Image.cpp.

{
size(size_);
magick(magick_);
// Set explicit image format
fileName(magick_ + ':');
read(blob_);
}

## read() [6/9]

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

Definition at line 4089 of file Image.cpp.

{
size(size_);
read(imageSpec_);
}

## 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 4095 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=ConstituteImage(width_,height_,map_.c_str(),type_, pixels_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## read() [8/9]

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

Definition at line 4108 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
options()->fileName(imageSpec_);
newImage=ReadImage(imageInfo(),exceptionInfo);
read(newImage,exceptionInfo);
}

## read() [9/9]

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

private

Definition at line 5096 of file Image.cpp.

{
// Ensure that multiple image frames were not read.
if (image != (MagickCore::Image *) NULL &&
image->next != (MagickCore::Image *) NULL)
{
MagickCore::Image
*next;
// Destroy any extra image frames
next=image->next;
image->next=(MagickCore::Image *) NULL;
next->previous=(MagickCore::Image *) NULL;
DestroyImageList(next);
}
replaceImage(image);
if (exceptionInfo->severity == MagickCore::UndefinedException &&
image == (MagickCore::Image *) NULL)
{
(void) MagickCore::DestroyExceptionInfo(exceptionInfo);
if (!quiet())
throwExceptionExplicit(MagickCore::ImageWarning,
"No image was loaded.");
return;
}
ThrowImageException;
}

## readMask() [1/2]

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

Definition at line 4119 of file Image.cpp.

{
mask(mask_,ReadPixelMask);
}

## readMask() [2/2]

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

Definition at line 4124 of file Image.cpp.

{
return(mask(ReadPixelMask));
}

## readPixels()

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

Definition at line 4129 of file Image.cpp.

{
QuantumInfo
*quantum_info;
quantum_info=AcquireQuantumInfo(imageInfo(),image());
GetPPException;
ImportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
quantum_,source_,exceptionInfo);
quantum_info=DestroyQuantumInfo(quantum_info);
ThrowImageException;
}

## reduceNoise() [1/2]

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

Definition at line 4148 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=StatisticImage(constImage(),NonpeakStatistic,order_,
order_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## reduceNoise() [2/2]

void Magick::Image::reduceNoise | ( | void |  | ) |

Definition at line 4143 of file Image.cpp.

{
reduceNoise(3);
}

## renderingIntent()

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

Definition at line 1334 of file Image.cpp.

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

## repage()

void Magick::Image::repage | ( |  | ) |

Definition at line 4160 of file Image.cpp.

{
modifyImage();
options()->page(Geometry());
image()->page.width = 0;
image()->page.height = 0;
image()->page.x = 0;
image()->page.y = 0;
}

## replaceImage()

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

Definition at line 5078 of file Image.cpp.

{
MagickCore::Image
*image;
if (replacement_)
image=replacement_;
else
{
GetPPException;
image=AcquireImage(constImageInfo(),exceptionInfo);
ThrowImageException;
}
_imgRef=ImageRef::replaceImage(_imgRef,image);
return(image);
}

## resample()

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

Definition at line 4170 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=ResampleImage(constImage(),density_.x(),density_.y(),
image()->filter,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## resize()

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

Definition at line 4182 of file Image.cpp.

{
MagickCore::Image
*newImage;
size_t
height=rows(),
width=columns();
ssize_t
x=0,
y=0;
// Calculate new size. This code should be supported using binary arguments
// in the ImageMagick library.
ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
&height);
GetPPException;
newImage=ResizeImage(constImage(),width,height,image()->filter,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## resolutionUnits()

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

Definition at line 1347 of file Image.cpp.

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

## roll() [1/2]

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

Definition at line 4207 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=RollImage(constImage(),roll_.xOff(),roll_.yOff(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## roll() [2/2]

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

Definition at line 4218 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=RollImage(constImage(),columns_, rows_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## rotate()

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

Definition at line 4229 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=RotateImage(constImage(),degrees_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## rotationalBlur()

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

Definition at line 4240 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=RotationalBlurImage(constImage(),angle_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## rotationalBlurChannel()

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

Definition at line 4251 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
GetAndSetPPChannelMask(channel_);
newImage=RotationalBlurImage(constImage(),angle_,exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowImageException;
}

## rows()

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

Definition at line 1352 of file Image.cpp.

{
return(constImage()->rows);
}

## sample()

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

Definition at line 4265 of file Image.cpp.

{
MagickCore::Image
*newImage;
size_t
height=rows(),
width=columns();
ssize_t
x=0,
y=0;
ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
&height);
GetPPException;
newImage=SampleImage(constImage(),width,height,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## samplingFactor() [1/2]

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

Definition at line 1357 of file Image.cpp.

{
modifyImage();
options()->samplingFactor(samplingFactor_);
}

## samplingFactor() [2/2]

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

Definition at line 1363 of file Image.cpp.

{
return(constOptions()->samplingFactor());
}

## scale()

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

Definition at line 4287 of file Image.cpp.

{
MagickCore::Image
*newImage;
size_t
height=rows(),
width=columns();
ssize_t
x=0,
y=0;
ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
&height);
GetPPException;
newImage=ScaleImage(constImage(),width,height,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## scene() [1/2]

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

Definition at line 1368 of file Image.cpp.

{
modifyImage();
image()->scene=scene_;
}

## scene() [2/2]

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

Definition at line 1374 of file Image.cpp.

{
return(constImage()->scene);
}

## segment()

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

Definition at line 4309 of file Image.cpp.

{
modifyImage();
GetPPException;
SegmentImage(image(),options()->quantizeColorSpace(),
(MagickBooleanType) options()->verbose(),clusterThreshold_,
smoothingThreshold_,exceptionInfo);
SyncImage(image(),exceptionInfo);
ThrowImageException;
}

## selectiveBlur()

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

Definition at line 4321 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=SelectiveBlurImage(constImage(),radius_,sigma_,threshold_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## selectiveBlurChannel()

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

Definition at line 4334 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
GetAndSetPPChannelMask(channel_);
newImage=SelectiveBlurImage(constImage(),radius_,sigma_,threshold_,
exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowImageException;
}

## separate()

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

Definition at line 4349 of file Image.cpp.

{
MagickCore::Image
*image;
GetPPException;
image=SeparateImage(constImage(),channel_,exceptionInfo);
ThrowImageException;
if (image == (MagickCore::Image *) NULL)
return(Magick::Image());
else
return(Magick::Image(image));
}

## sepiaTone()

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

Definition at line 4363 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=SepiaToneImage(constImage(),threshold_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## setColorMetric()

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

Definition at line 4374 of file Image.cpp.

{
bool
status;
Image
ref=reference_;
GetPPException;
modifyImage();
status=static_cast<bool>(SetImageColorMetric(image(),ref.constImage(),
exceptionInfo));
ThrowImageException;
return(status);
}

## 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 4390 of file Image.cpp.

{
Quantum
*result;
modifyImage();
GetPPException;
result=QueueAuthenticPixels(image(),x_,y_,columns_,rows_,exceptionInfo);
ThrowImageException;
return(result);
}

## shade()

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

Definition at line 4403 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=ShadeImage(constImage(),colorShading_ == true ?
MagickTrue : MagickFalse,azimuth_,elevation_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## 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 4416 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=ShadowImage(constImage(),percent_opacity_, sigma_,x_, y_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## sharpen()

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

Definition at line 4429 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=SharpenImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## sharpenChannel()

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

Definition at line 4440 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
GetAndSetPPChannelMask(channel_);
newImage=SharpenImage(constImage(),radius_,sigma_,exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowImageException;
}

## shave()

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

Definition at line 4454 of file Image.cpp.

{
MagickCore::Image
*newImage;
RectangleInfo
shaveInfo=geometry_;
GetPPException;
newImage=ShaveImage(constImage(),&shaveInfo,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## shear()

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

Definition at line 4468 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=ShearImage(constImage(),xShearAngle_,yShearAngle_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## sigmoidalContrast()

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

Definition at line 4479 of file Image.cpp.

{
modifyImage();
GetPPException;
(void) SigmoidalContrastImage(image(),(MagickBooleanType) sharpen_,contrast,
midpoint,exceptionInfo);
ThrowImageException;
}

## signature()

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

Definition at line 4489 of file Image.cpp.

{
return(_imgRef->signature(force_));
}

## size() [1/2]

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

Definition at line 1379 of file Image.cpp.

{
modifyImage();
options()->size(geometry_);
image()->rows=geometry_.height();
image()->columns=geometry_.width();
}

## size() [2/2]

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

Definition at line 1387 of file Image.cpp.

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

## sketch()

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

Definition at line 4494 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=SketchImage(constImage(),radius_,sigma_,angle_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## solarize()

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

Definition at line 4506 of file Image.cpp.

{
modifyImage();
GetPPException;
SolarizeImage(image(),factor_,exceptionInfo);
ThrowImageException;
}

## sparseColor()

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

Definition at line 4514 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
GetAndSetPPChannelMask(channel_);
newImage=SparseColorImage(constImage(),method_,numberArguments_,arguments_,
exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowImageException;
}

## splice() [1/3]

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

Definition at line 4530 of file Image.cpp.

{
MagickCore::Image
*newImage;
RectangleInfo
spliceInfo=geometry_;
GetPPException;
newImage=SpliceImage(constImage(),&spliceInfo,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## splice() [2/3]

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

Definition at line 4544 of file Image.cpp.

{
backgroundColor(backgroundColor_);
splice(geometry_);
}

## splice() [3/3]

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

Definition at line 4551 of file Image.cpp.

{
backgroundColor(backgroundColor_);
image()->gravity=gravity_;
splice(geometry_);
}

## spread()

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

Definition at line 4559 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=SpreadImage(constImage(),image()->interpolate,amount_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## statistics()

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

Definition at line 4570 of file Image.cpp.

{
return(ImageStatistics(*this));
}

## stegano()

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

Definition at line 4575 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=SteganoImage(constImage(),watermark_.constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## stereo()

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

Definition at line 4586 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=StereoImage(constImage(),rightImage_.constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## strip()

void Magick::Image::strip | ( | void |  | ) |

Definition at line 4597 of file Image.cpp.

{
modifyImage();
GetPPException;
StripImage(image(),exceptionInfo);
ThrowImageException;
}

## strokeAntiAlias() [1/2]

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

Definition at line 1392 of file Image.cpp.

{
modifyImage();
options()->strokeAntiAlias(flag_);
}

## strokeAntiAlias() [2/2]

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

Definition at line 1398 of file Image.cpp.

{
return(constOptions()->strokeAntiAlias());
}

## strokeColor() [1/2]

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

Definition at line 1403 of file Image.cpp.

{
std::string
value;
modifyImage();
options()->strokeColor(strokeColor_);
value=strokeColor_;
artifact("stroke",value);
}

## strokeColor() [2/2]

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

Definition at line 1414 of file Image.cpp.

{
return(constOptions()->strokeColor());
}

## strokeDashArray() [1/2]

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

Definition at line 1419 of file Image.cpp.

{
modifyImage();
options()->strokeDashArray(strokeDashArray_);
}

## strokeDashArray() [2/2]

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

Definition at line 1425 of file Image.cpp.

{
return(constOptions()->strokeDashArray());
}

## strokeDashOffset() [1/2]

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

Definition at line 1430 of file Image.cpp.

{
modifyImage();
options()->strokeDashOffset(strokeDashOffset_);
}

## strokeDashOffset() [2/2]

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

Definition at line 1436 of file Image.cpp.

{
return(constOptions()->strokeDashOffset());
}

## strokeLineCap()

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

Definition at line 1447 of file Image.cpp.

{
return(constOptions()->strokeLineCap());
}

## strokeLineJoin()

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

Definition at line 1458 of file Image.cpp.

{
return(constOptions()->strokeLineJoin());
}

## strokeMiterLimit() [1/2]

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

Definition at line 1463 of file Image.cpp.

{
modifyImage();
options()->strokeMiterLimit(strokeMiterLimit_);
}

## strokeMiterLimit() [2/2]

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

Definition at line 1469 of file Image.cpp.

{
return(constOptions()->strokeMiterLimit());
}

## strokePattern() [1/2]

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

Definition at line 1474 of file Image.cpp.

{
modifyImage();
if(strokePattern_.isValid())
options()->strokePattern(strokePattern_.constImage());
else
options()->strokePattern(static_cast<MagickCore::Image*>(NULL));
}

## strokePattern() [2/2]

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

Definition at line 1483 of file Image.cpp.

{
// FIXME: This is inordinately inefficient
const MagickCore::Image
*tmpTexture;
Image
texture;
tmpTexture=constOptions()->strokePattern();
if (tmpTexture)
{
MagickCore::Image
*image;
GetPPException;
image=CloneImage(tmpTexture,0,0,MagickTrue,exceptionInfo);
texture.replaceImage(image);
ThrowImageException;
}
return(texture);
}

## strokeWidth() [1/2]

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

Definition at line 1507 of file Image.cpp.

{
char
value[MagickPathExtent];
modifyImage();
options()->strokeWidth(strokeWidth_);
FormatLocaleString(value,MagickPathExtent,"%.20g",strokeWidth_);
(void) SetImageArtifact(image(),"strokewidth",value);
}

## strokeWidth() [2/2]

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

Definition at line 1518 of file Image.cpp.

{
return(constOptions()->strokeWidth());
}

## subImage() [1/2]

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

Definition at line 1523 of file Image.cpp.

{
modifyImage();
options()->subImage(subImage_);
}

## subImage() [2/2]

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

Definition at line 1529 of file Image.cpp.

{
return(constOptions()->subImage());
}

## subImageSearch()

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

Definition at line 4605 of file Image.cpp.

{
MagickCore::Image
*newImage;
RectangleInfo
offset;
GetPPException;
newImage=SimilarityImage(image(),reference_.constImage(),metric_,
similarityThreshold,&offset,similarityMetric_,exceptionInfo);
ThrowImageException;
if (offset_ != (Geometry *) NULL)
*offset_=offset;
if (newImage == (MagickCore::Image *) NULL)
return(Magick::Image());
else
return(Magick::Image(newImage));
}

## subRange() [1/2]

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

Definition at line 1534 of file Image.cpp.

{
modifyImage();
options()->subRange(subRange_);
}

## subRange() [2/2]

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

Definition at line 1540 of file Image.cpp.

{
return(constOptions()->subRange());
}

## swirl()

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

Definition at line 4627 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=SwirlImage(constImage(),degrees_,image()->interpolate,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## syncPixels()

void Magick::Image::syncPixels | ( | void |  | ) |

Definition at line 4639 of file Image.cpp.

{
GetPPException;
(void) SyncAuthenticPixels(image(),exceptionInfo);
ThrowImageException;
}

## textAntiAlias() [1/2]

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

Definition at line 1545 of file Image.cpp.

{
modifyImage();
options()->textAntiAlias(flag_);
}

## textAntiAlias() [2/2]

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

Definition at line 1551 of file Image.cpp.

{
return(constOptions()->textAntiAlias());
}

## textDirection() [1/2]

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

Definition at line 1562 of file Image.cpp.

{
return(constOptions()->textDirection());
}

## textDirection() [2/2]

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

Definition at line 1556 of file Image.cpp.

{
modifyImage();
options()->textDirection(direction_);
}

## textEncoding() [1/2]

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

Definition at line 1567 of file Image.cpp.

{
modifyImage();
options()->textEncoding(encoding_);
}

## textEncoding() [2/2]

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

Definition at line 1573 of file Image.cpp.

{
return(constOptions()->textEncoding());
}

## textGravity() [1/2]

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

Definition at line 1584 of file Image.cpp.

{
return(constOptions()->textGravity());
}

## textGravity() [2/2]

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

Definition at line 1578 of file Image.cpp.

{
modifyImage();
options()->textGravity(gravity_);
}

## textInterlineSpacing() [1/2]

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

Definition at line 1589 of file Image.cpp.

{
modifyImage();
options()->textInterlineSpacing(spacing_);
}

## textInterlineSpacing() [2/2]

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

Definition at line 1595 of file Image.cpp.

{
return(constOptions()->textInterlineSpacing());
}

## textInterwordSpacing() [1/2]

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

Definition at line 1600 of file Image.cpp.

{
modifyImage();
options()->textInterwordSpacing(spacing_);
}

## textInterwordSpacing() [2/2]

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

Definition at line 1606 of file Image.cpp.

{
return(constOptions()->textInterwordSpacing());
}

## textKerning() [1/2]

void Magick::Image::textKerning | ( | double | kerning_ | ) |

Definition at line 1611 of file Image.cpp.

{
modifyImage();
options()->textKerning(kerning_);
}

## textKerning() [2/2]

double Magick::Image::textKerning | ( | void |  | ) | const

Definition at line 1617 of file Image.cpp.

{
return(constOptions()->textKerning());
}

## textUnderColor() [1/2]

void Magick::Image::textUnderColor | ( | const Color & | underColor_ | ) |

Definition at line 1622 of file Image.cpp.

{
modifyImage();
options()->textUnderColor(underColor_);
}

## textUnderColor() [2/2]

Magick::Color Magick::Image::textUnderColor | ( | void |  | ) | const

Definition at line 1628 of file Image.cpp.

{
return(constOptions()->textUnderColor());
}

## texture()

void Magick::Image::texture | ( | const Image & | texture_ | ) |

Definition at line 4646 of file Image.cpp.

{
modifyImage();
GetPPException;
TextureImage(image(),texture_.constImage(),exceptionInfo);
ThrowImageException;
}

## threshold()

void Magick::Image::threshold | ( | const double | threshold_ | ) |

Definition at line 4654 of file Image.cpp.

{
modifyImage();
GetPPException;
BilevelImage(image(),threshold_,exceptionInfo);
ThrowImageException;
}

## thumbnail()

void Magick::Image::thumbnail | ( | const Geometry & | geometry_ | ) |

Definition at line 4662 of file Image.cpp.

{
MagickCore::Image
*newImage;
size_t
height=rows(),
width=columns();
ssize_t
x=0,
y=0;
ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
&height);
GetPPException;
newImage=ThumbnailImage(constImage(),width,height,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## tint()

void Magick::Image::tint | ( | const std::string | opacity_ | ) |

Definition at line 4684 of file Image.cpp.

{
MagickCore::Image
*newImage;
PixelInfo
color;
GetPPException;
color=static_cast<PixelInfo>(constOptions()->fillColor());
newImage=TintImage(constImage(),opacity_.c_str(),&color,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## totalColors()

size_t Magick::Image::totalColors | ( | void |  | ) | const

Definition at line 1633 of file Image.cpp.

{
size_t
colors;
GetPPException;
colors=GetNumberColors(constImage(),(FILE *) NULL,exceptionInfo);
ThrowImageException;
return colors;
}

## transformOrigin()

void Magick::Image::transformOrigin | ( | const double | x_,
|  | const double | y_ )

Definition at line 4699 of file Image.cpp.

{
modifyImage();
options()->transformOrigin(x_,y_);
}

## transformReset()

void Magick::Image::transformReset | ( | void |  | ) |

Definition at line 4705 of file Image.cpp.

{
modifyImage();
options()->transformReset();
}

## transformRotation()

void Magick::Image::transformRotation | ( | const double | angle_ | ) |

Definition at line 1644 of file Image.cpp.

{
modifyImage();
options()->transformRotation(angle_);
}

## transformScale()

void Magick::Image::transformScale | ( | const double | sx_,
|  | const double | sy_ )

Definition at line 4711 of file Image.cpp.

{
modifyImage();
options()->transformScale(sx_,sy_);
}

## transformSkewX()

void Magick::Image::transformSkewX | ( | const double | skewx_ | ) |

Definition at line 1650 of file Image.cpp.

{
modifyImage();
options()->transformSkewX(skewx_);
}

## transformSkewY()

void Magick::Image::transformSkewY | ( | const double | skewy_ | ) |

Definition at line 1656 of file Image.cpp.

{
modifyImage();
options()->transformSkewY(skewy_);
}

## transparent()

void Magick::Image::transparent | ( | const Color & | color_,
|  | const bool | inverse_ = false )

Definition at line 4717 of file Image.cpp.

{
PixelInfo
target;
std::string
color;
if (!color_.isValid())
throwExceptionExplicit(MagickCore::OptionError,
"Color argument is invalid");
color=color_;
GetPPException;
(void) QueryColorCompliance(color.c_str(),AllCompliance,&target,
exceptionInfo);
modifyImage();
TransparentPaintImage(image(),&target,TransparentAlpha,
inverse_ == true ? MagickTrue : MagickFalse,exceptionInfo);
ThrowImageException;
}

## transparentChroma()

void Magick::Image::transparentChroma | ( | const Color & | colorLow_,
|  | const Color & | colorHigh_ )

Definition at line 4739 of file Image.cpp.

{
std::string
colorHigh,
colorLow;
PixelInfo
targetHigh,
targetLow;
if (!colorLow_.isValid() || !colorHigh_.isValid())
throwExceptionExplicit(MagickCore::OptionError,
"Color argument is invalid");
colorLow=colorLow_;
colorHigh=colorHigh_;
GetPPException;
(void) QueryColorCompliance(colorLow.c_str(),AllCompliance,&targetLow,
exceptionInfo);
(void) QueryColorCompliance(colorHigh.c_str(),AllCompliance,&targetHigh,
exceptionInfo);
modifyImage();
TransparentPaintImageChroma(image(),&targetLow,&targetHigh,TransparentAlpha,
MagickFalse,exceptionInfo);
ThrowImageException;
}

## transpose()

void Magick::Image::transpose | ( | void |  | ) |

Definition at line 4768 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=TransposeImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## transverse()

void Magick::Image::transverse | ( | void |  | ) |

Definition at line 4779 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=TransverseImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## trim()

void Magick::Image::trim | ( | void |  | ) |

Definition at line 4790 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=TrimImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## type()

Magick::ImageType Magick::Image::type | ( | void |  | ) | const

Definition at line 1662 of file Image.cpp.

{
if (constOptions()->type() != UndefinedType)
return(constOptions()->type());
return(GetImageType(constImage()));
}

## uniqueColors()

Magick::Image Magick::Image::uniqueColors | ( | void |  | ) | const

Definition at line 4801 of file Image.cpp.

{
MagickCore::Image
*image;
GetPPException;
image=UniqueImageColors(constImage(),exceptionInfo);
ThrowImageException;
if (image == (MagickCore::Image *) NULL)
return(Magick::Image());
else
return(Magick::Image(image));
}

## unsharpmask()

void Magick::Image::unsharpmask | ( | const double | radius_,
|  | const double | sigma_,
|  | const double | amount_,
|  | const double | threshold_ )

Definition at line 4815 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=UnsharpMaskImage(constImage(),radius_,sigma_,amount_,threshold_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## unsharpmaskChannel()

void Magick::Image::unsharpmaskChannel | ( | const ChannelType | channel_,
|  | const double | radius_,
|  | const double | sigma_,
|  | const double | amount_,
|  | const double | threshold_ )

Definition at line 4828 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
GetAndSetPPChannelMask(channel_);
newImage=UnsharpMaskImage(constImage(),radius_,sigma_,amount_,threshold_,
exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowImageException;
}

## verbose() [1/2]

void Magick::Image::verbose | ( | const bool | verboseFlag_ | ) |

Definition at line 1678 of file Image.cpp.

{
modifyImage();
options()->verbose(verboseFlag_);
}

## verbose() [2/2]

bool Magick::Image::verbose | ( | void |  | ) | const

Definition at line 1684 of file Image.cpp.

{
return(constOptions()->verbose());
}

## 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 4844 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=VignetteImage(constImage(),radius_,sigma_,x_,y_,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## virtualPixelMethod() [1/2]

void Magick::Image::virtualPixelMethod | ( | const VirtualPixelMethod | virtualPixelMethod_ | ) |

Definition at line 1689 of file Image.cpp.

{
modifyImage();
GetPPException;
SetImageVirtualPixelMethod(image(),virtualPixelMethod_,exceptionInfo);
ThrowImageException;
}

## virtualPixelMethod() [2/2]

Magick::VirtualPixelMethod Magick::Image::virtualPixelMethod | ( | void |  | ) | const

Definition at line 1698 of file Image.cpp.

{
return(GetImageVirtualPixelMethod(constImage()));
}

## wave()

void Magick::Image::wave | ( | const double | amplitude_ = 25.0,
|  | const double | wavelength_ = 150.0 )

Definition at line 4856 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=WaveImage(constImage(),amplitude_,wavelength_,image()->interpolate,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## waveletDenoise()

void Magick::Image::waveletDenoise | ( | const double | threshold_,
|  | const double | softness_ )

Definition at line 4868 of file Image.cpp.

{
MagickCore::Image
*newImage;
GetPPException;
newImage=WaveletDenoiseImage(constImage(),threshold_,softness_,
exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## whiteThreshold()

void Magick::Image::whiteThreshold | ( | const std::string & | threshold_ | ) |

Definition at line 4881 of file Image.cpp.

{
modifyImage();
GetPPException;
WhiteThresholdImage(image(),threshold_.c_str(),exceptionInfo);
ThrowImageException;
}

## whiteThresholdChannel()

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

Definition at line 4889 of file Image.cpp.

{
modifyImage();
GetPPException;
GetAndSetPPChannelMask(channel_);
WhiteThresholdImage(image(),threshold_.c_str(),exceptionInfo);
RestorePPChannelMask;
ThrowImageException;
}

## write() [1/4]

void Magick::Image::write | ( | Blob * | blob_ | ) |

Definition at line 4900 of file Image.cpp.

{
size_t
length=0;
void
*data;
modifyImage();
GetPPException;
data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
if (length > 0)
blob_->updateNoCopy(data,length,Blob::MallocAllocator);
else
data=RelinquishMagickMemory(data);
ThrowImageException;
}

## write() [2/4]

void Magick::Image::write | ( | Blob * | blob_,
|  | const std::string & | magick_ )

Definition at line 4918 of file Image.cpp.

{
size_t
length=0;
void
*data;
modifyImage();
magick(magick_);
GetPPException;
data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
if (length > 0)
blob_->updateNoCopy(data,length,Blob::MallocAllocator);
else
data=RelinquishMagickMemory(data);
ThrowImageException;
}

## write() [3/4]

void Magick::Image::write | ( | Blob * | blob_,
|  | const std::string & | magick_,
|  | const size_t | depth_ )

Definition at line 4937 of file Image.cpp.

{
size_t
length=0;
void
*data;
modifyImage();
magick(magick_);
depth(depth_);
GetPPException;
data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
if (length > 0)
blob_->updateNoCopy(data,length,Blob::MallocAllocator);
else
data=RelinquishMagickMemory(data);
ThrowImageException;
}

## write() [4/4]

void Magick::Image::write | ( | const std::string & | imageSpec_ | ) |

Definition at line 4968 of file Image.cpp.

{
modifyImage();
fileName(imageSpec_);
GetPPException;
WriteImage(constImageInfo(),image(),exceptionInfo);
ThrowImageException;
}

## writeMask() [1/2]

void Magick::Image::writeMask | ( | const Image & | mask_ | ) |

Definition at line 4977 of file Image.cpp.

{
mask(mask_,WritePixelMask);
}

## writeMask() [2/2]

Magick::Image Magick::Image::writeMask | ( | void |  | ) | const

Definition at line 4982 of file Image.cpp.

{
return(mask(WritePixelMask));
}

## writePixels()

void Magick::Image::writePixels | ( | const QuantumType | quantum_,
|  | unsigned char * | destination_ )

Definition at line 4987 of file Image.cpp.

{
QuantumInfo
*quantum_info;
quantum_info=AcquireQuantumInfo(imageInfo(),image());
GetPPException;
ExportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
quantum_,destination_, exceptionInfo);
quantum_info=DestroyQuantumInfo(quantum_info);
ThrowImageException;
}

## x11Display() [1/2]

void Magick::Image::x11Display | ( | const std::string & | display_ | ) |

Definition at line 1703 of file Image.cpp.

{
modifyImage();
options()->x11Display(display_);
}

## x11Display() [2/2]

std::string Magick::Image::x11Display | ( | void |  | ) | const

Definition at line 1709 of file Image.cpp.

{
return(constOptions()->x11Display());
}

## xResolution()

double Magick::Image::xResolution | ( | void |  | ) | const

Definition at line 1714 of file Image.cpp.

{
return(constImage()->resolution.x);
}

## yResolution()

double Magick::Image::yResolution | ( | void |  | ) | const

Definition at line 1719 of file Image.cpp.

{
return(constImage()->resolution.y);
}

## zoom()

void Magick::Image::zoom | ( | const Geometry & | geometry_ | ) |

Definition at line 5001 of file Image.cpp.

{
MagickCore::Image
*newImage;
size_t
height=rows(),
width=columns();
ssize_t
x=0,
y=0;
ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
&height);
GetPPException;
newImage=ResizeImage(constImage(),width,height,image()->filter,exceptionInfo);
replaceImage(newImage);
ThrowImageException;
}

## Field Documentation

## _imgRef

ImageRef* Magick::Image::_imgRef

private

Definition at line 1560 of file Image.h.

The documentation for this class was generated from the following files:

- Image.h
- Image.cpp