root/Magick++/lib/Image.cpp

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. adjoin
  2. adjoin
  3. antiAlias
  4. antiAlias
  5. animationDelay
  6. animationDelay
  7. animationIterations
  8. animationIterations
  9. attenuate
  10. backgroundColor
  11. backgroundColor
  12. backgroundTexture
  13. backgroundTexture
  14. baseColumns
  15. baseFilename
  16. baseRows
  17. blackPointCompensation
  18. blackPointCompensation
  19. borderColor
  20. borderColor
  21. boundingBox
  22. boxColor
  23. boxColor
  24. cacheThreshold
  25. classType
  26. clipMask
  27. clipMask
  28. colorFuzz
  29. colorFuzz
  30. colorMapSize
  31. colorMapSize
  32. colorSpace
  33. colorSpace
  34. colorspaceType
  35. colorspaceType
  36. comment
  37. comment
  38. compose
  39. compose
  40. compressType
  41. compressType
  42. debug
  43. debug
  44. density
  45. density
  46. depth
  47. depth
  48. directory
  49. endian
  50. endian
  51. exifProfile
  52. exifProfile
  53. fileName
  54. fileName
  55. fileSize
  56. fillColor
  57. fillColor
  58. fillRule
  59. fillRule
  60. fillPattern
  61. fillPattern
  62. filterType
  63. filterType
  64. font
  65. font
  66. fontFamily
  67. fontFamily
  68. fontPointsize
  69. fontPointsize
  70. format
  71. fontStyle
  72. fontStyle
  73. fontWeight
  74. fontWeight
  75. formatExpression
  76. gamma
  77. geometry
  78. gifDisposeMethod
  79. gifDisposeMethod
  80. highlightColor
  81. iccColorProfile
  82. iccColorProfile
  83. interlaceType
  84. interlaceType
  85. interpolate
  86. interpolate
  87. iptcProfile
  88. iptcProfile
  89. isOpaque
  90. isValid
  91. isValid
  92. label
  93. label
  94. lowlightColor
  95. magick
  96. magick
  97. mask
  98. mask
  99. matte
  100. matte
  101. matteColor
  102. matteColor
  103. meanErrorPerPixel
  104. modulusDepth
  105. modulusDepth
  106. monochrome
  107. monochrome
  108. montageGeometry
  109. normalizedMaxError
  110. normalizedMeanError
  111. orientation
  112. orientation
  113. page
  114. page
  115. penColor
  116. penColor
  117. penTexture
  118. penTexture
  119. quality
  120. quality
  121. quantizeColors
  122. quantizeColors
  123. quantizeColorSpace
  124. quantizeColorSpace
  125. quantizeDither
  126. quantizeDither
  127. quantizeDitherMethod
  128. quantizeDitherMethod
  129. quantizeTreeDepth
  130. quantizeTreeDepth
  131. quiet
  132. quiet
  133. renderingIntent
  134. renderingIntent
  135. resolutionUnits
  136. resolutionUnits
  137. scene
  138. scene
  139. size
  140. size
  141. strokeAntiAlias
  142. strokeAntiAlias
  143. strokeColor
  144. strokeColor
  145. strokeDashArray
  146. strokeDashArray
  147. strokeDashOffset
  148. strokeDashOffset
  149. strokeLineCap
  150. strokeLineCap
  151. strokeLineJoin
  152. strokeLineJoin
  153. strokeMiterLimit
  154. strokeMiterLimit
  155. strokePattern
  156. strokePattern
  157. strokeWidth
  158. strokeWidth
  159. subImage
  160. subImage
  161. subRange
  162. subRange
  163. textDirection
  164. textDirection
  165. textEncoding
  166. textEncoding
  167. textGravity
  168. textGravity
  169. textInterlineSpacing
  170. textInterlineSpacing
  171. textInterwordSpacing
  172. textInterwordSpacing
  173. textKerning
  174. textKerning
  175. textUnderColor
  176. textUnderColor
  177. tileName
  178. tileName
  179. totalColors
  180. transformRotation
  181. transformSkewX
  182. transformSkewY
  183. type
  184. type
  185. verbose
  186. verbose
  187. view
  188. view
  189. virtualPixelMethod
  190. virtualPixelMethod
  191. x11Display
  192. x11Display
  193. xResolution
  194. yResolution
  195. adaptiveBlur
  196. adaptiveResize
  197. adaptiveSharpen
  198. adaptiveSharpenChannel
  199. adaptiveThreshold
  200. addNoise
  201. addNoiseChannel
  202. affineTransform
  203. alphaChannel
  204. annotate
  205. annotate
  206. annotate
  207. annotate
  208. artifact
  209. artifact
  210. attribute
  211. attribute
  212. autoGamma
  213. autoGammaChannel
  214. autoLevel
  215. autoLevelChannel
  216. autoOrient
  217. blackThreshold
  218. blackThresholdChannel
  219. blueShift
  220. blur
  221. blurChannel
  222. border
  223. brightnessContrast
  224. brightnessContrastChannel
  225. cannyEdge
  226. cdl
  227. channel
  228. channelDepth
  229. channelDepth
  230. charcoal
  231. chop
  232. chromaBluePrimary
  233. chromaBluePrimary
  234. chromaGreenPrimary
  235. chromaGreenPrimary
  236. chromaRedPrimary
  237. chromaRedPrimary
  238. chromaWhitePoint
  239. chromaWhitePoint
  240. clamp
  241. clampChannel
  242. clip
  243. clipPath
  244. clut
  245. clutChannel
  246. colorize
  247. colorize
  248. colorMap
  249. colorMap
  250. colorMatrix
  251. compare
  252. compare
  253. compareChannel
  254. compare
  255. compareChannel
  256. composite
  257. composite
  258. composite
  259. connectedComponents
  260. contrast
  261. contrastStretch
  262. contrastStretchChannel
  263. convolve
  264. copyPixels
  265. crop
  266. cycleColormap
  267. decipher
  268. defineSet
  269. defineSet
  270. defineValue
  271. defineValue
  272. deskew
  273. despeckle
  274. determineType
  275. display
  276. distort
  277. draw
  278. draw
  279. edge
  280. emboss
  281. encipher
  282. enhance
  283. equalize
  284. erase
  285. extent
  286. extent
  287. extent
  288. extent
  289. flip
  290. floodFillColor
  291. floodFillColor
  292. floodFillColor
  293. floodFillColor
  294. floodFillColor
  295. floodFillColor
  296. floodFillColor
  297. floodFillColor
  298. floodFillOpacity
  299. floodFillOpacity
  300. floodFillOpacity
  301. floodFillTexture
  302. floodFillTexture
  303. floodFillTexture
  304. floodFillTexture
  305. floodFillTexture
  306. floodFillTexture
  307. floodFillTexture
  308. floodFillTexture
  309. flop
  310. fontTypeMetrics
  311. fontTypeMetricsMultiline
  312. frame
  313. frame
  314. fx
  315. fx
  316. gamma
  317. gamma
  318. gaussianBlur
  319. gaussianBlurChannel
  320. getConstIndexes
  321. getConstPixels
  322. getIndexes
  323. getPixels
  324. grayscale
  325. haldClut
  326. houghLine
  327. implode
  328. inverseFourierTransform
  329. inverseFourierTransform
  330. kuwahara
  331. kuwaharaChannel
  332. level
  333. levelChannel
  334. levelColors
  335. levelColorsChannel
  336. levelize
  337. levelizeChannel
  338. linearStretch
  339. liquidRescale
  340. localContrast
  341. magnify
  342. map
  343. matteFloodfill
  344. medianFilter
  345. mergeLayers
  346. minify
  347. modulate
  348. moments
  349. morphology
  350. morphology
  351. morphologyChannel
  352. morphologyChannel
  353. motionBlur
  354. negate
  355. negateChannel
  356. normalize
  357. oilPaint
  358. opacity
  359. opaque
  360. orderedDither
  361. orderedDitherChannel
  362. perceptible
  363. perceptibleChannel
  364. ping
  365. ping
  366. pixelColor
  367. pixelColor
  368. polaroid
  369. posterize
  370. posterizeChannel
  371. process
  372. profile
  373. profile
  374. quantize
  375. quantumOperator
  376. quantumOperator
  377. quantumOperator
  378. raise
  379. randomThreshold
  380. randomThresholdChannel
  381. read
  382. read
  383. read
  384. read
  385. read
  386. read
  387. read
  388. read
  389. readPixels
  390. reduceNoise
  391. repage
  392. resample
  393. resize
  394. roll
  395. roll
  396. rotate
  397. rotationalBlur
  398. rotationalBlurChannel
  399. sample
  400. scale
  401. segment
  402. selectiveBlur
  403. selectiveBlurChannel
  404. separate
  405. sepiaTone
  406. setPixels
  407. shade
  408. shadow
  409. sharpen
  410. sharpenChannel
  411. shave
  412. shear
  413. sigmoidalContrast
  414. signature
  415. sketch
  416. solarize
  417. sparseColor
  418. splice
  419. splice
  420. splice
  421. spread
  422. statistics
  423. stegano
  424. stereo
  425. strip
  426. subImageSearch
  427. swirl
  428. syncPixels
  429. texture
  430. threshold
  431. thumbnail
  432. tint
  433. transform
  434. transform
  435. transformOrigin
  436. transformReset
  437. transformScale
  438. transparent
  439. transparentChroma
  440. transpose
  441. transverse
  442. trim
  443. uniqueColors
  444. unsharpmask
  445. unsharpmaskChannel
  446. vignette
  447. wave
  448. whiteThreshold
  449. whiteThresholdChannel
  450. write
  451. write
  452. write
  453. write
  454. write
  455. writePixels
  456. zoom
  457. image
  458. constImage
  459. imageInfo
  460. constImageInfo
  461. options
  462. constOptions
  463. quantizeInfo
  464. constQuantizeInfo
  465. modifyImage
  466. replaceImage
  467. throwImageException
  468. read
  469. floodFill

// This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003
// Copyright Dirk Lemstra 2013-2015
//
// Implementation of Image
//

#define MAGICKCORE_IMPLEMENTATION  1
#define MAGICK_PLUSPLUS_IMPLEMENTATION 1

#include "Magick++/Include.h"
#include <cstdlib>
#include <string>
#include <string.h>
#include <errno.h>
#include <math.h>

using namespace std;

#include "Magick++/Image.h"
#include "Magick++/Functions.h"
#include "Magick++/Pixels.h"
#include "Magick++/Options.h"
#include "Magick++/ImageRef.h"
#include "Magick++/ResourceLimits.h"

#define AbsoluteValue(x)  ((x) < 0 ? -(x) : (x))
#define MagickPI  3.14159265358979323846264338327950288419716939937510
#define DegreesToRadians(x)  (MagickPI*(x)/180.0)
#define ThrowImageException ThrowPPException(quiet())

MagickPPExport const char *Magick::borderGeometryDefault="6x6+0+0";
MagickPPExport const char *Magick::frameGeometryDefault="25x25+6+6";
MagickPPExport const char *Magick::raiseGeometryDefault="6x6+0+0";

MagickPPExport int Magick::operator == (const Magick::Image &left_,
  const Magick::Image &right_)
{
  // If image pixels and signature are the same, then the image is identical
  return((left_.rows() == right_.rows()) &&
    (left_.columns() == right_.columns()) &&
    (left_.signature() == right_.signature()));
}

MagickPPExport int Magick::operator != (const Magick::Image &left_,
  const Magick::Image &right_)
{
  return(!(left_ == right_));
}

MagickPPExport int Magick::operator > (const Magick::Image &left_,
  const Magick::Image &right_)
{
  return(!(left_ < right_) && (left_ != right_));
}

MagickPPExport int Magick::operator < (const Magick::Image &left_,
  const Magick::Image &right_)
{
  // If image pixels are less, then image is smaller
  return((left_.rows() * left_.columns()) < (right_.rows() * 
    right_.columns()));
}

MagickPPExport int Magick::operator >= (const Magick::Image &left_,
  const Magick::Image &right_)
{
  return((left_ > right_) || (left_ == right_));
}

MagickPPExport int Magick::operator <= (const Magick::Image &left_,
  const Magick::Image &right_)
{
  return((left_ < right_) || (left_ == right_));
}

Magick::Image::Image(void)
  : _imgRef(new ImageRef)
{
}

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

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

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

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

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

Magick::Image::Image(const Geometry &size_,const Color &color_)
  : _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;
  }
}

Magick::Image::Image(const Image &image_)
  : _imgRef(image_._imgRef)
{
  Lock lock(&_imgRef->_mutexLock);

  // Increase reference count
  ++_imgRef->_refCount;
}

Magick::Image::Image(const Image &image_,const Geometry &geometry_)
  : _imgRef(new ImageRef)
{
  const RectangleInfo
    geometry=geometry_;

  OffsetInfo
    offset;

  MagickCore::Image
    *image;

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

Magick::Image::Image(const size_t width_,const size_t height_,
  const std::string &map_,const StorageType type_,const void *pixels_)
  : _imgRef(new ImageRef)
{
  try
  {
    quiet(true);
    read(width_,height_,map_,type_,pixels_);
    quiet(false);
  }
  catch(const Error&)
  {
    // Release resources
    delete _imgRef;
    throw;
  }
}

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

Magick::Image::~Image()
{
  bool
    doDelete=false;

  {
    Lock lock(&_imgRef->_mutexLock);
    if (--_imgRef->_refCount == 0)
      doDelete=true;
  }

  if (doDelete)
    delete _imgRef;

  _imgRef=0;
}

Magick::Image& Magick::Image::operator=(const Magick::Image &image_)
{
  if (this != &image_)
    {
      bool
        doDelete=false;

      {
        Lock lock(&image_._imgRef->_mutexLock);
        ++image_._imgRef->_refCount;
      }

      {
        Lock lock(&_imgRef->_mutexLock);
        if (--_imgRef->_refCount == 0)
          doDelete=true;
      }

      if (doDelete)
        {
          // Delete old image reference with associated image and options.
          delete _imgRef;
          _imgRef=0;
        }

      // Use new image reference
      _imgRef=image_._imgRef;
    }

  return(*this);
}

void Magick::Image::adjoin(const bool flag_)
{
  modifyImage();
  options()->adjoin(flag_);
}

bool Magick::Image::adjoin(void) const
{
  return(constOptions()->adjoin());
}

void Magick::Image::antiAlias(const bool flag_)
{
  modifyImage();
  options()->antiAlias(flag_);
}

bool Magick::Image::antiAlias(void) const
{
  return(constOptions()->antiAlias());
}

void Magick::Image::animationDelay(const size_t delay_)
{
  modifyImage();
  image()->delay=delay_;
}

size_t Magick::Image::animationDelay(void) const
{
  return(constImage()->delay);
}

void Magick::Image::animationIterations(const size_t iterations_)
{
  modifyImage();
  image()->iterations=iterations_;
}

size_t Magick::Image::animationIterations(void) const
{
  return(constImage()->iterations);
}

void Magick::Image::attenuate(const double attenuate_)
{
  char
    value[MaxTextExtent];

  modifyImage();
  FormatLocaleString(value,MaxTextExtent,"%.20g",attenuate_);
  (void) SetImageArtifact(image(),"attenuate",value);
}

void Magick::Image::backgroundColor(const Color &backgroundColor_)
{
  modifyImage();

  if (backgroundColor_.isValid())
    image()->background_color=backgroundColor_;
  else
    image()->background_color=Color();

  options()->backgroundColor(backgroundColor_);
}

Magick::Color Magick::Image::backgroundColor(void) const
{
  return(constOptions()->backgroundColor());
}

void Magick::Image::backgroundTexture(const std::string &backgroundTexture_)
{
  modifyImage();
  options()->backgroundTexture(backgroundTexture_);
}

std::string Magick::Image::backgroundTexture(void) const
{
  return(constOptions()->backgroundTexture());
}

size_t Magick::Image::baseColumns(void) const
{
  return(constImage()->magick_columns);
}

std::string Magick::Image::baseFilename(void) const
{
  return(std::string(constImage()->magick_filename));
}

size_t Magick::Image::baseRows(void) const
{
  return(constImage()->magick_rows);
}

void Magick::Image::blackPointCompensation(const bool flag_)
{
  image()->black_point_compensation=(MagickBooleanType) flag_;
}

bool Magick::Image::blackPointCompensation(void) const
{
  return(static_cast<bool>(constImage()->black_point_compensation));
}

void Magick::Image::borderColor(const Color &borderColor_)
{
  modifyImage();

  if (borderColor_.isValid())
    image()->border_color=borderColor_;
  else
    image()->border_color=Color();

  options()->borderColor(borderColor_);
}

Magick::Color Magick::Image::borderColor(void) const
{
  return(constOptions()->borderColor());
}

Magick::Geometry Magick::Image::boundingBox(void) const
{
  RectangleInfo
    bbox; 
  
  GetPPException;
  bbox=GetImageBoundingBox(constImage(),exceptionInfo);
  ThrowImageException;
  return(Geometry(bbox));
}

void Magick::Image::boxColor(const Color &boxColor_)
{
  modifyImage();
  options()->boxColor(boxColor_);
}

Magick::Color Magick::Image::boxColor(void) const
{
  return(constOptions()->boxColor());
}

void Magick::Image::cacheThreshold(const size_t threshold_)
{
  ResourceLimits::memory((MagickSizeType) threshold_);
}

void Magick::Image::classType(const ClassType class_)
{
  if (classType() == PseudoClass && class_ == DirectClass)
    {
      // Use SyncImage to synchronize the DirectClass pixels with the
      // color map and then set to DirectClass type.
      modifyImage();
      SyncImage(image());
      image()->colormap=(PixelPacket *)RelinquishMagickMemory(
        image()->colormap);
      image()->storage_class=static_cast<MagickCore::ClassType>(DirectClass);
    }
  else if (classType() == DirectClass && class_ == PseudoClass)
    {
      // Quantize to create PseudoClass color map
      modifyImage();
      quantizeColors(MaxColormapSize);
      quantize();
      image()->storage_class=static_cast<MagickCore::ClassType>(PseudoClass);
    }
}

void Magick::Image::clipMask(const Magick::Image &clipMask_)
{
  modifyImage();

  if (clipMask_.isValid())
    SetImageClipMask(image(),clipMask_.constImage());
  else
    SetImageClipMask(image(),0);
}

Magick::Image Magick::Image::clipMask(void) const
{
  MagickCore::Image
    *image;

  GetPPException;
  image=GetImageClipMask(constImage(),exceptionInfo);
  ThrowImageException;

  if (image == (MagickCore::Image *) NULL)
    return(Magick::Image());
  else
    return(Magick::Image(image));
}

void Magick::Image::colorFuzz(const double fuzz_)
{
  modifyImage();
  image()->fuzz=fuzz_;
  options()->colorFuzz(fuzz_);
}

double Magick::Image::colorFuzz(void) const
{
  return(constOptions()->colorFuzz());
}

void Magick::Image::colorMapSize(const size_t entries_)
{
  if (entries_ > MaxColormapSize)
    throwExceptionExplicit(OptionError,
      "Colormap entries must not exceed MaxColormapSize");

  modifyImage();
  (void) AcquireImageColormap(image(),entries_);
}

size_t Magick::Image::colorMapSize(void) const
{
  if (!constImage()->colormap)
    throwExceptionExplicit(OptionError,"Image does not contain a colormap");

  return(constImage()->colors);
}

void Magick::Image::colorSpace(const ColorspaceType colorSpace_)
{
  if (image()->colorspace == colorSpace_)
    return;

  modifyImage();
  TransformImageColorspace(image(),colorSpace_);
  throwImageException();
}

Magick::ColorspaceType Magick::Image::colorSpace(void) const
{
  return(constImage()->colorspace);
}

void Magick::Image::colorspaceType(const ColorspaceType colorSpace_)
{
  modifyImage();
  SetImageColorspace(image(),colorSpace_);
  throwImageException();
  options()->colorspaceType(colorSpace_);
}

Magick::ColorspaceType Magick::Image::colorspaceType(void) const
{
  return(constOptions()->colorspaceType());
}

void Magick::Image::comment(const std::string &comment_)
{
  modifyImage();
  SetImageProperty(image(),"Comment",NULL);
  if (comment_.length() > 0)
    SetImageProperty(image(),"Comment",comment_.c_str());
  throwImageException();
}

std::string Magick::Image::comment(void) const
{
  const char
    *value;

  value=GetImageProperty(constImage(),"Comment");

  if (value)
    return(std::string(value));

  return(std::string()); // Intentionally no exception
}

void Magick::Image::compose(const CompositeOperator compose_)
{
  image()->compose=compose_;
}

Magick::CompositeOperator Magick::Image::compose(void) const
{
  return(constImage()->compose);
}

void Magick::Image::compressType(const CompressionType compressType_)
{
  modifyImage();
  image()->compression=compressType_;
  options()->compressType(compressType_);
}

Magick::CompressionType Magick::Image::compressType(void) const
{
  return(constImage()->compression);
}

void Magick::Image::debug(const bool flag_)
{
  modifyImage();
  options()->debug(flag_);
}

bool Magick::Image::debug(void) const
{
  return(constOptions()->debug());
}

void Magick::Image::density(const Geometry &density_)
{
  modifyImage();
  options()->density(density_);
  if (density_.isValid())
    {
      image()->x_resolution=density_.width();
      if (density_.height() != 0)
        image()->y_resolution=density_.height();
      else
        image()->y_resolution=density_.width();
    }
  else
    {
      // Reset to default
      image()->x_resolution=0;
      image()->y_resolution=0;
    }
}

Magick::Geometry Magick::Image::density(void) const
{
  if (isValid())
    {
      ssize_t
        x_resolution=72,
        y_resolution=72;

      if (constImage()->x_resolution > 0.0)
        x_resolution=static_cast<ssize_t>(constImage()->x_resolution + 0.5);

      if (constImage()->y_resolution > 0.0)
        y_resolution=static_cast<ssize_t>(constImage()->y_resolution + 0.5);

      return(Geometry(x_resolution,y_resolution));
    }

  return(constOptions()->density());
}

void Magick::Image::depth(const size_t depth_)
{
  size_t
    depth=depth_;

  if (depth > MAGICKCORE_QUANTUM_DEPTH)
    depth=MAGICKCORE_QUANTUM_DEPTH;

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

size_t Magick::Image::depth(void) const
{
  return(constImage()->depth);
}

std::string Magick::Image::directory(void) const
{
  if (constImage()->directory)
    return(std::string(constImage()->directory));

  throwExceptionExplicit(CorruptImageWarning,
    "Image does not contain a directory");

  return(std::string());
}

void Magick::Image::endian(const Magick::EndianType endian_)
{
  modifyImage();
  options()->endian(endian_);
  image()->endian=endian_;
}

Magick::EndianType Magick::Image::endian(void) const
{
  return(constImage()->endian);
}

void Magick::Image::exifProfile(const Magick::Blob &exifProfile_)
{
  if (exifProfile_.data() != 0)
    {
      StringInfo 
        *exif_profile;

      modifyImage();
      exif_profile=AcquireStringInfo(exifProfile_.length());
      SetStringInfoDatum(exif_profile,(unsigned char *) exifProfile_.data());
      (void) SetImageProfile(image(),"exif",exif_profile);
      exif_profile=DestroyStringInfo(exif_profile);
    }
}

Magick::Blob Magick::Image::exifProfile(void) const
{
  const StringInfo
    *exif_profile;

  exif_profile=GetImageProfile(constImage(),"exif");
  if (exif_profile == (StringInfo *) NULL)
    return(Blob());

  return(Blob(GetStringInfoDatum(exif_profile),GetStringInfoLength(
    exif_profile)));
} 

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

  fileName_.copy(image()->filename,sizeof(image()->filename)-1);
  image()->filename[fileName_.length()]=0; // Null terminate
  
  options()->fileName(fileName_);
}

std::string Magick::Image::fileName(void) const
{
  return(constOptions()->fileName());
}

off_t Magick::Image::fileSize(void) const
{
  return((off_t) GetBlobSize(constImage()));
}

void Magick::Image::fillColor(const Magick::Color &fillColor_)
{
  modifyImage();
  options()->fillColor(fillColor_);
}

Magick::Color Magick::Image::fillColor(void) const
{
  return(constOptions()->fillColor());
}

void Magick::Image::fillRule(const Magick::FillRule &fillRule_)
{
  modifyImage();
  options()->fillRule(fillRule_);
}

Magick::FillRule Magick::Image::fillRule(void) const
{
  return(constOptions()->fillRule());
}

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

Magick::Image Magick::Image::fillPattern(void) const
{
  // FIXME: This is inordinately innefficient
  const MagickCore::Image
    *tmpTexture;

  Image
    texture;

  tmpTexture=constOptions()->fillPattern();

  if(tmpTexture)
    {
      MagickCore::Image
        *image;

      GetPPException;
      image=CloneImage(tmpTexture,0,0,MagickTrue,exceptionInfo);
      texture.replaceImage(image);
      ThrowImageException;
    }

  return(texture);
}

void Magick::Image::filterType(const Magick::FilterTypes filterType_)
{
  modifyImage();
  image()->filter=filterType_;
}

Magick::FilterTypes Magick::Image::filterType(void) const
{
  return(constImage()->filter);
}

void Magick::Image::font(const std::string &font_)
{
  modifyImage();
  options()->font(font_);
}

std::string Magick::Image::font(void) const
{
  return(constOptions()->font());
}

void Magick::Image::fontFamily(const std::string &family_)
{
  modifyImage();
  options()->fontFamily(family_);
}

std::string Magick::Image::fontFamily(void) const
{
  return(constOptions()->fontFamily());
}


void Magick::Image::fontPointsize(const double pointSize_)
{
  modifyImage();
  options()->fontPointsize(pointSize_);
}

double Magick::Image::fontPointsize(void) const
{
  return(constOptions()->fontPointsize());
}

std::string Magick::Image::format(void) const
{
  const MagickInfo
    *magick_info;

  GetPPException;
  magick_info=GetMagickInfo(constImage()->magick,exceptionInfo);
  ThrowImageException;

  if ((magick_info != 0) && (*magick_info->description != '\0'))
    return(std::string(magick_info->description));

  throwExceptionExplicit(CorruptImageWarning,"Unrecognized image magick type");
  return(std::string());
}

void Magick::Image::fontStyle(const StyleType pointSize_)
{
  modifyImage();
  options()->fontStyle(pointSize_);
}

Magick::StyleType Magick::Image::fontStyle(void) const
{
  return(constOptions()->fontStyle());
}

void Magick::Image::fontWeight(const size_t weight_)
{
  modifyImage();
  options()->fontWeight(weight_);
}

size_t Magick::Image::fontWeight(void) const
{
  return(constOptions()->fontWeight());
}


std::string Magick::Image::formatExpression(const std::string expression)
{
  char
    *text;

  std::string
    text_string;

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

double Magick::Image::gamma(void) const
{
  return(constImage()->gamma);
}

Magick::Geometry Magick::Image::geometry(void) const
{
  if (constImage()->geometry)
    return(Geometry(constImage()->geometry));

  throwExceptionExplicit(OptionWarning,"Image does not contain a geometry");

  return(Geometry());
}

void Magick::Image::gifDisposeMethod(const size_t disposeMethod_)
{
  modifyImage();
  image()->dispose=(DisposeType) disposeMethod_;
}

size_t Magick::Image::gifDisposeMethod(void) const
{
  // FIXME: It would be better to return an enumeration
  return ((size_t) constImage()->dispose);
}

void Magick::Image::highlightColor(const Color color_)
{
  std::string
    value;

  value=color_;
  artifact("highlight-color",value);
}

void Magick::Image::iccColorProfile(const Magick::Blob &colorProfile_)
{
  profile("icc",colorProfile_);
}

Magick::Blob Magick::Image::iccColorProfile(void) const
{
  const StringInfo
    *color_profile;

  color_profile=GetImageProfile(constImage(),"icc");
  if (color_profile == (StringInfo *) NULL)
    return Blob();

  return(Blob(GetStringInfoDatum(color_profile),GetStringInfoLength(
    color_profile)));
}

void Magick::Image::interlaceType(const InterlaceType interlace_)
{
  modifyImage();
  image()->interlace=interlace_;
  options()->interlaceType(interlace_);
}

Magick::InterlaceType Magick::Image::interlaceType(void) const
{
  return constImage()->interlace;
}

void Magick::Image::interpolate(const InterpolatePixelMethod interpolate_)
{
  modifyImage();
  image()->interpolate=interpolate_;
}

Magick::InterpolatePixelMethod Magick::Image::interpolate(void) const
{
  return constImage()->interpolate;
}

void Magick::Image::iptcProfile(const Magick::Blob &iptcProfile_)
{
  modifyImage();
  if (iptcProfile_.data() != 0)
    {
      StringInfo
        *iptc_profile;

      iptc_profile=AcquireStringInfo(iptcProfile_.length());
      SetStringInfoDatum(iptc_profile,(unsigned char *) iptcProfile_.data());
      (void) SetImageProfile(image(),"iptc",iptc_profile);
      iptc_profile=DestroyStringInfo(iptc_profile );
    }
}

Magick::Blob Magick::Image::iptcProfile(void) const
{
  const StringInfo
    *iptc_profile;

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

bool Magick::Image::isOpaque(void) const
{
  MagickBooleanType
    result;

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

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

bool Magick::Image::isValid(void) const
{
  return(rows() && columns());
}

void Magick::Image::label(const std::string &label_)
{
  modifyImage();
  (void) SetImageProperty(image(),"Label",NULL);
  if (label_.length() > 0)
    (void) SetImageProperty(image(),"Label",label_.c_str());
  throwImageException();
}

std::string Magick::Image::label(void) const
{
  const char
    *value;

  value=GetImageProperty(constImage(),"Label");

  if (value)
    return(std::string(value));

  return(std::string());
}

void Magick::Image::lowlightColor(const Color color_)
{
  std::string
    value;

  value=color_;
  artifact("lowlight-color",value);
}

void Magick::Image::magick(const std::string &magick_)
{
  size_t
    length;

  modifyImage();

  length=sizeof(image()->magick)-1;
  if (magick_.length() < length)
    length=magick_.length();

  if (!magick_.empty())
    magick_.copy(image()->magick,length);
  image()->magick[length]=0;

  options()->magick(magick_);
}

std::string Magick::Image::magick(void) const
{
  if (*(constImage()->magick) != '\0')
    return(std::string(constImage()->magick));

  return(constOptions()->magick());
}

void Magick::Image::mask(const Magick::Image &mask_)
{
  modifyImage();

  if (mask_.isValid())
    SetImageMask(image(),mask_.constImage());
  else
    SetImageMask(image(),0);
}

Magick::Image Magick::Image::mask(void) const
{
  MagickCore::Image
    *image;

  GetPPException;
  image=GetImageMask(constImage(),exceptionInfo);
  ThrowImageException;

  if (image == (MagickCore::Image *) NULL)
    return(Magick::Image());
  else
    return(Magick::Image(image));
}

void Magick::Image::matte(const bool matteFlag_)
{
  modifyImage();

  // If 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.
  if ((matteFlag_ && !constImage()->matte) || (constImage()->matte &&
    !matteFlag_))
    SetImageOpacity(image(),OpaqueOpacity);

  image()->matte=(MagickBooleanType) matteFlag_;
}

bool Magick::Image::matte(void) const
{
  if (constImage()->matte)
    return true;
  else
    return false;
}

void Magick::Image::matteColor(const Color &matteColor_)
{
  modifyImage();

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

      image()->matte_color=tmpColor;
      options()->matteColor(tmpColor);
    }
}

Magick::Color Magick::Image::matteColor(void) const
{
  return(Color(constImage()->matte_color.red,constImage()->matte_color.green,
    constImage()->matte_color.blue));
}

double Magick::Image::meanErrorPerPixel(void) const
{
  return(constImage()->error.mean_error_per_pixel);
}

void Magick::Image::modulusDepth(const size_t depth_)
{
  modifyImage();
  SetImageDepth(image(),depth_);
  options()->depth(depth_);
}

size_t Magick::Image::modulusDepth(void) const
{
  size_t
    depth;

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

void Magick::Image::monochrome(const bool monochromeFlag_)
{
  modifyImage();
  options()->monochrome(monochromeFlag_);
}

bool Magick::Image::monochrome(void) const
{
  return(constOptions()->monochrome());
}

Magick::Geometry Magick::Image::montageGeometry(void) const
{
  if (constImage()->montage)
    return(Magick::Geometry(constImage()->montage));

  throwExceptionExplicit(CorruptImageWarning,
    "Image does not contain a montage");

  return(Magick::Geometry());
}

double Magick::Image::normalizedMaxError(void) const
{
  return(constImage()->error.normalized_maximum_error);
}

double Magick::Image::normalizedMeanError(void) const
{
  return (constImage()->error.normalized_mean_error);
}

void Magick::Image::orientation(const Magick::OrientationType orientation_)
{
  modifyImage();
  image()->orientation=orientation_;
}

Magick::OrientationType Magick::Image::orientation(void) const
{
  return(constImage()->orientation);
}

void Magick::Image::page(const Magick::Geometry &pageSize_)
{
  modifyImage();
  options()->page(pageSize_);
  image()->page=pageSize_;
}

Magick::Geometry Magick::Image::page(void) const
{
  return(Geometry(constImage()->page.width,constImage()->page.height,
    AbsoluteValue(constImage()->page.x),AbsoluteValue(constImage()->page.y),
    constImage()->page.x < 0 ? true : false,
    constImage()->page.y < 0 ? true : false));
}

void Magick::Image::penColor(const Color &penColor_)
{
  modifyImage();
  options()->fillColor(penColor_);
  options()->strokeColor(penColor_);
}

Magick::Color Magick::Image::penColor(void) const
{
  return(constOptions()->fillColor());
}

void Magick::Image::penTexture(const Image &penTexture_)
{
  modifyImage();
  if(penTexture_.isValid())
    options()->fillPattern(penTexture_.constImage());
  else
    options()->fillPattern(static_cast<MagickCore::Image*>(NULL));
}

Magick::Image Magick::Image::penTexture(void) const
{
  // FIXME: This is inordinately innefficient
  const MagickCore::Image
    *tmpTexture;

  Image
    texture;

  tmpTexture=constOptions()->fillPattern();

  if (tmpTexture)
    {
      MagickCore::Image
        *image;

      GetPPException;
      image=CloneImage(tmpTexture,0,0,MagickTrue,exceptionInfo);
      texture.replaceImage(image);
      ThrowImageException;
    }
  return(texture);
}

void Magick::Image::quality(const size_t quality_)
{
  modifyImage();
  image()->quality=quality_;
  options()->quality(quality_);
}

size_t Magick::Image::quality(void) const
{
  return(constImage()->quality);
}

void Magick::Image::quantizeColors(const size_t colors_)
{
  modifyImage();
  options()->quantizeColors(colors_);
}

size_t Magick::Image::quantizeColors(void) const
{
  return(constOptions()->quantizeColors());
}

void Magick::Image::quantizeColorSpace(
  const Magick::ColorspaceType colorSpace_)
{
  modifyImage();
  options()->quantizeColorSpace(colorSpace_);
}

Magick::ColorspaceType Magick::Image::quantizeColorSpace(void) const
{
  return(constOptions()->quantizeColorSpace());
}

void Magick::Image::quantizeDither(const bool ditherFlag_)
{
  modifyImage();
  options()->quantizeDither(ditherFlag_);
}

bool Magick::Image::quantizeDither(void) const
{
  return(constOptions()->quantizeDither());
}

void Magick::Image::quantizeDitherMethod(const DitherMethod ditherMethod_)
{
  modifyImage();
  options()->quantizeDitherMethod(ditherMethod_);
}

MagickCore::DitherMethod Magick::Image::quantizeDitherMethod(void) const
{
  return(constOptions()->quantizeDitherMethod());
}

void Magick::Image::quantizeTreeDepth(const size_t treeDepth_)
{
  modifyImage();
  options()->quantizeTreeDepth(treeDepth_);
}

size_t Magick::Image::quantizeTreeDepth(void) const
{
  return(constOptions()->quantizeTreeDepth());
}

void Magick::Image::quiet(const bool quiet_)
{
  modifyImage();
  options()->quiet(quiet_);
}

bool Magick::Image::quiet(void) const
{
  return(constOptions()->quiet());
}

void Magick::Image::renderingIntent(
  const Magick::RenderingIntent renderingIntent_)
{
  modifyImage();
  image()->rendering_intent=renderingIntent_;
}

Magick::RenderingIntent Magick::Image::renderingIntent(void) const
{
  return(static_cast<Magick::RenderingIntent>(
    constImage()->rendering_intent));
}

void Magick::Image::resolutionUnits(
  const Magick::ResolutionType resolutionUnits_)
{
  modifyImage();
  image()->units=resolutionUnits_;
  options()->resolutionUnits(resolutionUnits_);
}

Magick::ResolutionType Magick::Image::resolutionUnits(void) const
{
  return(static_cast<Magick::ResolutionType>(constImage()->units));
}

void Magick::Image::scene(const size_t scene_)
{
  modifyImage();
  image()->scene=scene_;
}

size_t Magick::Image::scene(void) const
{
  return(constImage()->scene);
}

void Magick::Image::size(const Geometry &geometry_)
{
  modifyImage();
  options()->size(geometry_);
  image()->rows=geometry_.height();
  image()->columns=geometry_.width();
}

Magick::Geometry Magick::Image::size(void) const
{
  return(Magick::Geometry(constImage()->columns,constImage()->rows));
}

void Magick::Image::strokeAntiAlias(const bool flag_)
{
  modifyImage();
  options()->strokeAntiAlias(flag_);
}

bool Magick::Image::strokeAntiAlias(void) const
{
  return(constOptions()->strokeAntiAlias());
}

void Magick::Image::strokeColor(const Magick::Color &strokeColor_)
{
  std::string
    value;

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

Magick::Color Magick::Image::strokeColor(void) const
{
  return(constOptions()->strokeColor());
}

void Magick::Image::strokeDashArray(const double *strokeDashArray_)
{
  modifyImage();
  options()->strokeDashArray(strokeDashArray_);
}

const double *Magick::Image::strokeDashArray(void) const
{
  return(constOptions()->strokeDashArray());
}

void Magick::Image::strokeDashOffset(const double strokeDashOffset_)
{
  modifyImage();
  options()->strokeDashOffset(strokeDashOffset_);
}

double Magick::Image::strokeDashOffset(void) const
{
  return(constOptions()->strokeDashOffset());
}

void Magick::Image::strokeLineCap(const Magick::LineCap lineCap_)
{
  modifyImage();
  options()->strokeLineCap(lineCap_);
}

Magick::LineCap Magick::Image::strokeLineCap(void) const
{
  return(constOptions()->strokeLineCap());
}

void Magick::Image::strokeLineJoin(const Magick::LineJoin lineJoin_)
{
  modifyImage();
  options()->strokeLineJoin(lineJoin_);
}

Magick::LineJoin Magick::Image::strokeLineJoin(void) const
{
  return(constOptions()->strokeLineJoin());
}

void Magick::Image::strokeMiterLimit(const size_t strokeMiterLimit_)
{
  modifyImage();
  options()->strokeMiterLimit(strokeMiterLimit_);
}

size_t Magick::Image::strokeMiterLimit(void) const
{
  return constOptions()->strokeMiterLimit();
}

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

Magick::Image Magick::Image::strokePattern(void) const
{
  const MagickCore::Image
    *tmpTexture;

  Image
    texture;

  tmpTexture=constOptions()->strokePattern();

  if (tmpTexture)
    {
      MagickCore::Image
        *image;

      GetPPException;
      image=CloneImage(tmpTexture,0,0,MagickTrue,exceptionInfo);
      texture.replaceImage(image);
      ThrowImageException;
    }
  return(texture);
}

void Magick::Image::strokeWidth(const double strokeWidth_)
{
  char
    value[MaxTextExtent];

  modifyImage();
  options()->strokeWidth(strokeWidth_);
  FormatLocaleString(value,MaxTextExtent,"%.20g",strokeWidth_);
  (void) SetImageArtifact(image(),"strokewidth",value);
}

double Magick::Image::strokeWidth(void) const
{
  return(constOptions()->strokeWidth());
}

void Magick::Image::subImage(const size_t subImage_)
{
  modifyImage();
  options()->subImage(subImage_);
}

size_t Magick::Image::subImage(void) const
{
  return(constOptions()->subImage());
}

void Magick::Image::subRange(const size_t subRange_)
{
  modifyImage();
  options()->subRange(subRange_);
}

size_t Magick::Image::subRange(void) const
{
  return(constOptions()->subRange());
}

void Magick::Image::textDirection(DirectionType direction_)
{
  modifyImage();
  options()->textDirection(direction_);
}

Magick::DirectionType Magick::Image::textDirection(void) const
{
  return(constOptions()->textDirection());
}

void Magick::Image::textEncoding(const std::string &encoding_)
{
  modifyImage();
  options()->textEncoding(encoding_);
}

std::string Magick::Image::textEncoding(void) const
{
  return(constOptions()->textEncoding());
}

void Magick::Image::textGravity(GravityType gravity_)
{
  modifyImage();
  options()->textGravity(gravity_);
}

Magick::GravityType Magick::Image::textGravity(void) const
{
  return(constOptions()->textGravity());
}

void Magick::Image::textInterlineSpacing(double spacing_)
{
  modifyImage();
  options()->textInterlineSpacing(spacing_);
}

double Magick::Image::textInterlineSpacing(void) const
{
  return(constOptions()->textInterlineSpacing());
}

void Magick::Image::textInterwordSpacing(double spacing_)
{
  modifyImage();
  options()->textInterwordSpacing(spacing_);
}

double Magick::Image::textInterwordSpacing(void) const
{
  return(constOptions()->textInterwordSpacing());
}

void Magick::Image::textKerning(double kerning_)
{
  modifyImage();
  options()->textKerning(kerning_);
}

double Magick::Image::textKerning(void) const
{
  return(constOptions()->textKerning());
}

void Magick::Image::textUnderColor(const Color &underColor_)
{
  modifyImage();
  options()->textUnderColor(underColor_);
}

Magick::Color Magick::Image::textUnderColor(void) const
{
  return(constOptions()->textUnderColor());
}

void Magick::Image::tileName(const std::string &tileName_)
{
  modifyImage();
  options()->tileName(tileName_);
}

std::string Magick::Image::tileName(void) const
{
  return(constOptions()->tileName());
}

size_t Magick::Image::totalColors(void) const
{
  size_t
    colors;

  GetPPException;
  colors=GetNumberColors(constImage(),0,exceptionInfo);
  ThrowImageException;
  return(colors);
}

void Magick::Image::transformRotation(const double angle_)
{
  modifyImage();
  options()->transformRotation(angle_);
}

void Magick::Image::transformSkewX(const double skewx_)
{
  modifyImage();
  options()->transformSkewX(skewx_);
}

void Magick::Image::transformSkewY(const double skewy_)
{
  modifyImage();
  options()->transformSkewY(skewy_);
}

void Magick::Image::type(const Magick::ImageType type_)
{
  modifyImage();
  options()->type(type_);
  SetImageType(image(),type_);
}

Magick::ImageType Magick::Image::type(void) const
{
  if (constOptions()->type() != UndefinedType)
    return(constOptions()->type());
  else if (constImage()->type != UndefinedType)
    return(constImage()->type);
  else
    return(determineType());
}

void Magick::Image::verbose(const bool verboseFlag_)
{
  modifyImage();
  options()->verbose(verboseFlag_);
}

bool Magick::Image::verbose(void) const
{
  return(constOptions()->verbose());
}

void Magick::Image::view(const std::string &view_)
{
  modifyImage();
  options()->view(view_);
}

std::string Magick::Image::view(void) const
{
  return(constOptions()->view());
}

void Magick::Image::virtualPixelMethod(
  const VirtualPixelMethod virtual_pixel_method_)
{
  modifyImage();
  SetImageVirtualPixelMethod(image(),virtual_pixel_method_);
  options()->virtualPixelMethod(virtual_pixel_method_);
}

Magick::VirtualPixelMethod Magick::Image::virtualPixelMethod(void) const
{
  return(GetImageVirtualPixelMethod(constImage()));
}

void Magick::Image::x11Display(const std::string &display_)
{
  modifyImage();
  options()->x11Display(display_);
}

std::string Magick::Image::x11Display(void) const
{
  return(constOptions()->x11Display());
}

double Magick::Image::xResolution(void) const
{
  return(constImage()->x_resolution);
}

double Magick::Image::yResolution(void) const
{
  return(constImage()->y_resolution);
}

void Magick::Image::adaptiveBlur(const double radius_,const double sigma_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=AdaptiveBlurImage(constImage(),radius_,sigma_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::adaptiveResize(const Geometry &geometry_)
{
  MagickCore::Image
    *newImage;

  size_t
    width=columns(),
    height=rows();

  ssize_t
    x=0,
    y=0;

  ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
    &height);

  GetPPException;
  newImage=AdaptiveResizeImage(constImage(),width,height,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::adaptiveSharpen(const double radius_,const double sigma_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=AdaptiveSharpenImage(constImage(),radius_,sigma_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::adaptiveSharpenChannel(const ChannelType channel_,
  const double radius_,const double sigma_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=AdaptiveSharpenImageChannel(constImage(),channel_,radius_,sigma_,
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::adaptiveThreshold(const size_t width_,const size_t height_,
  const ssize_t offset_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=AdaptiveThresholdImage(constImage(),width_,height_,offset_,
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::addNoise(const NoiseType noiseType_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=AddNoiseImage(constImage(),noiseType_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::addNoiseChannel(const ChannelType channel_,
  const NoiseType noiseType_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=AddNoiseImageChannel(constImage(),channel_,noiseType_,
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::affineTransform(const DrawableAffine &affine_ )
{
  AffineMatrix
    _affine;

  MagickCore::Image
    *newImage;

  _affine.sx = affine_.sx();
  _affine.sy = affine_.sy();
  _affine.rx = affine_.rx();
  _affine.ry = affine_.ry();
  _affine.tx = affine_.tx();
  _affine.ty = affine_.ty();

  GetPPException;
  newImage=AffineTransformImage(constImage(),&_affine,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::alphaChannel(AlphaChannelType alphaType_)
{
  modifyImage();
  SetImageAlphaChannel(image(), alphaType_);
  throwImageException();
}

void Magick::Image::annotate(const std::string &text_,
  const Geometry &location_)
{
  annotate(text_,location_,NorthWestGravity,0.0);
}

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

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

  char
    boundingArea[MaxTextExtent];

  DrawInfo
    *drawInfo;

  modifyImage();

  drawInfo=options()->drawInfo();
  drawInfo->text=const_cast<char *>(text_.c_str());
  drawInfo->geometry=0;

  if (boundingArea_.isValid())
    {
      if (boundingArea_.width() == 0 || boundingArea_.height() == 0)
        {
          FormatLocaleString(boundingArea,MaxTextExtent,"%+.20g%+.20g",
            (double) boundingArea_.xOff(),(double) boundingArea_.yOff());
        }
      else
        {
          (void) CopyMagickString(boundingArea,
            std::string(boundingArea_).c_str(), MaxTextExtent);
        }
      drawInfo->geometry=boundingArea;
    }

  drawInfo->gravity=gravity_;

  oaffine=drawInfo->affine;
  if (degrees_ != 0.0)
    {
       AffineMatrix
         affine,
         current;

       affine.sx=1.0;
       affine.rx=0.0;
       affine.ry=0.0;
       affine.sy=1.0;
       affine.tx=0.0;
       affine.ty=0.0;

       current=drawInfo->affine;
       affine.sx=cos(DegreesToRadians(fmod(degrees_,360.0)));
       affine.rx=sin(DegreesToRadians(fmod(degrees_,360.0)));
       affine.ry=(-sin(DegreesToRadians(fmod(degrees_,360.0))));
       affine.sy=cos(DegreesToRadians(fmod(degrees_,360.0)));

       drawInfo->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
       drawInfo->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
       drawInfo->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
       drawInfo->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
       drawInfo->affine.tx=current.sx*affine.tx+current.ry*affine.ty
         +current.tx;
    }

  AnnotateImage(image(),drawInfo);

  // Restore original values
  drawInfo->affine=oaffine;
  drawInfo->text=0;
  drawInfo->geometry=0;

  throwImageException();
}

void Magick::Image::annotate(const std::string &text_,
  const GravityType gravity_)
{
  DrawInfo
    *drawInfo;

  modifyImage();

  drawInfo=options()->drawInfo();
  drawInfo->text=const_cast<char *>(text_.c_str());
  drawInfo->gravity=gravity_;

  AnnotateImage(image(),drawInfo);

  drawInfo->gravity=NorthWestGravity;
  drawInfo->text=0;

  throwImageException();
}

void Magick::Image::artifact(const std::string &name_,
  const std::string &value_)
{
  modifyImage();
  (void) SetImageArtifact(image(),name_.c_str(),value_.c_str());
}

std::string Magick::Image::artifact(const std::string &name_) const
{
  const char
    *value;

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

void Magick::Image::attribute(const std::string name_,const std::string value_)
{
  modifyImage();
  SetImageProperty(image(),name_.c_str(),value_.c_str());
}

std::string Magick::Image::attribute(const std::string name_) const
{
  const char
    *value;

  value=GetImageProperty(constImage(),name_.c_str());

  if (value)
    return(std::string(value));

  return(std::string()); // Intentionally no exception
}

void Magick::Image::autoGamma(void)
{
  modifyImage();
  (void) AutoGammaImage(image());
  throwImageException();
}

void Magick::Image::autoGammaChannel(const ChannelType channel_)
{
  modifyImage();
  (void) AutoGammaImageChannel(image(),channel_);
  throwImageException();
}

void Magick::Image::autoLevel(void)
{
  modifyImage();
  (void) AutoLevelImage(image());
  throwImageException();
}

void Magick::Image::autoLevelChannel(const ChannelType channel_)
{
  modifyImage();
  (void) AutoLevelImageChannel(image(),channel_);
  throwImageException();
}

void Magick::Image::autoOrient(void)
{
  MagickCore::Image
    *newImage;

  if (image()->orientation == UndefinedOrientation ||
      image()->orientation == TopLeftOrientation)
    return;

  GetPPException;
  newImage=AutoOrientImage(constImage(),image()->orientation,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::blackThreshold(const std::string &threshold_)
{
  modifyImage();
  BlackThresholdImage(image(),threshold_.c_str());
  throwImageException();
}

void Magick::Image::blackThresholdChannel(const ChannelType channel_,
  const std::string &threshold_)
{
  modifyImage();
  GetPPException;
  BlackThresholdImageChannel(image(),channel_,threshold_.c_str(),
    exceptionInfo);
  ThrowImageException;
}

void Magick::Image::blueShift(const double factor_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=BlueShiftImage(constImage(),factor_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

// Blur image
void Magick::Image::blur(const double radius_, const double sigma_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=BlurImage(constImage(),radius_,sigma_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::blurChannel(const ChannelType channel_,
  const double radius_,const double sigma_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=BlurImageChannel(constImage(),channel_,radius_,sigma_,
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::border(const Geometry &geometry_)
{
  MagickCore::Image
    *newImage;

  RectangleInfo
    borderInfo=geometry_;

  GetPPException;
  newImage=BorderImage(constImage(),&borderInfo,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::brightnessContrast(const double brightness_,
  const double contrast_)
{
  modifyImage();
  BrightnessContrastImage(image(),brightness_,contrast_);
  throwImageException();
}

void Magick::Image::brightnessContrastChannel(const ChannelType channel_,
  const double brightness_,const double contrast_)
{
  modifyImage();
  BrightnessContrastImageChannel(image(),channel_,brightness_,contrast_);
  throwImageException();
}

void Magick::Image::cannyEdge(const double radius_,const double sigma_,
  const double lowerPercent_,const double upperPercent_)
{
  MagickCore::Image
    *newImage;

  modifyImage();
  GetPPException;
  newImage=CannyEdgeImage(constImage(),radius_,sigma_,lowerPercent_,
    upperPercent_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::cdl(const std::string &cdl_)
{
  modifyImage();
  (void) ColorDecisionListImage(image(),cdl_.c_str());
  throwImageException();
}

void Magick::Image::channel(const ChannelType channel_)
{
  modifyImage();
  SeparateImageChannel(image(),channel_);
  throwImageException();
}

void Magick::Image::channelDepth(const ChannelType channel_,
  const size_t depth_)
{
  modifyImage();
  SetImageChannelDepth(image(),channel_,depth_);
  throwImageException();
}

size_t Magick::Image::channelDepth(const ChannelType channel_)
{
  size_t
    channel_depth;

  GetPPException;
  channel_depth=GetImageChannelDepth(constImage(), channel_,exceptionInfo);
  ThrowImageException;
  return channel_depth;
}

void Magick::Image::charcoal(const double radius_,const double sigma_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=CharcoalImage(constImage(),radius_,sigma_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::chop(const Geometry &geometry_)
{
  MagickCore::Image
    *newImage;
  
  RectangleInfo
    chopInfo=geometry_;

  GetPPException;
  newImage=ChopImage(constImage(),&chopInfo,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::chromaBluePrimary(const double x_,const double y_)
{
  modifyImage();
  image()->chromaticity.blue_primary.x=x_;
  image()->chromaticity.blue_primary.y=y_;
}

void Magick::Image::chromaBluePrimary(double *x_,double *y_) const
{
  *x_=constImage()->chromaticity.blue_primary.x;
  *y_=constImage()->chromaticity.blue_primary.y;
}

void Magick::Image::chromaGreenPrimary(const double x_,const double y_)
{
  modifyImage();
  image()->chromaticity.green_primary.x=x_;
  image()->chromaticity.green_primary.y=y_;
}

void Magick::Image::chromaGreenPrimary(double *x_,double *y_) const
{
  *x_=constImage()->chromaticity.green_primary.x;
  *y_=constImage()->chromaticity.green_primary.y;
}

void Magick::Image::chromaRedPrimary(const double x_,const double y_)
{
  modifyImage();
  image()->chromaticity.red_primary.x=x_;
  image()->chromaticity.red_primary.y=y_;
}

void Magick::Image::chromaRedPrimary(double *x_,double *y_) const
{
  *x_=constImage()->chromaticity.red_primary.x;
  *y_=constImage()->chromaticity.red_primary.y;
}

void Magick::Image::chromaWhitePoint(const double x_,const double y_)
{
  modifyImage();
  image()->chromaticity.white_point.x=x_;
  image()->chromaticity.white_point.y=y_;
}

void Magick::Image::chromaWhitePoint(double *x_,double *y_) const
{
  *x_=constImage()->chromaticity.white_point.x;
  *y_=constImage()->chromaticity.white_point.y;
}

void Magick::Image::clamp(void)
{
  modifyImage();
  ClampImage(image());
  throwImageException();
}

void Magick::Image::clampChannel(const ChannelType channel_)
{
  modifyImage();
  ClampImageChannel(image(),channel_);
  throwImageException();
}

void Magick::Image::clip(void )
{
  modifyImage();
  ClipImage(image());
  throwImageException();
}

void Magick::Image::clipPath(const std::string pathname_,const bool inside_)
{
  modifyImage();
  ClipImagePath(image(),pathname_.c_str(),(MagickBooleanType) inside_);
  throwImageException();
}

void Magick::Image::clut(const Image &clutImage_)
{
  modifyImage();
  ClutImage(image(),clutImage_.constImage());
  throwImageException();
}

void Magick::Image::clutChannel(const ChannelType channel_,
  const Image &clutImage_)
{
  modifyImage();
  ClutImageChannel(image(),channel_,clutImage_.constImage());
  throwImageException();
}

void Magick::Image::colorize(const unsigned int opacityRed_,
  const unsigned int opacityGreen_,const unsigned int opacityBlue_,
  const Color &penColor_)
{
  char
    opacity[MaxTextExtent];

  MagickCore::Image
    *newImage;

  if (!penColor_.isValid())
    throwExceptionExplicit( OptionError, "Pen color argument is invalid" );

  FormatLocaleString(opacity,MaxTextExtent,"%u/%u/%u",opacityRed_,
    opacityGreen_,opacityBlue_);

  GetPPException;
  newImage=ColorizeImage(image(),opacity,penColor_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::colorize(const unsigned int opacity_,
  const Color &penColor_)
{
  colorize(opacity_,opacity_,opacity_,penColor_);
}

void Magick::Image::colorMap(const size_t index_,const Color &color_)
{
  if (index_ > (MaxColormapSize-1) )
    throwExceptionExplicit(OptionError,
      "Colormap index must be less than MaxColormapSize");
  
  if (!color_.isValid())
    throwExceptionExplicit(OptionError,"Color argument is invalid");

  modifyImage();

  // Ensure that colormap size is large enough
  if (colorMapSize() < (index_+1))
    colorMapSize(index_+1);

  // Set color at index in colormap
  (image()->colormap)[index_]=color_;
}

Magick::Color Magick::Image::colorMap(const size_t index_) const
{
  if (!constImage()->colormap)
    {
      throwExceptionExplicit(OptionError,"Image does not contain a colormap");
      return(Color());
    }

  if (index_ > constImage()->colors-1)
    throwExceptionExplicit(OptionError,"Index out of range");

  return(Color((constImage()->colormap)[index_]));
}

void Magick::Image::colorMatrix(const size_t order_,
  const double *color_matrix_)
{
  KernelInfo
    *kernel_info;

  MagickCore::Image
    *newImage;

  GetPPException;
  
  kernel_info=AcquireKernelInfo("1");
  if (kernel_info != (KernelInfo *) NULL)
    {
      kernel_info->width=order_;
      kernel_info->height=order_;
      kernel_info->values=(double *) color_matrix_;
      newImage=ColorMatrixImage(constImage(),kernel_info,exceptionInfo);
      kernel_info->values=(double *) NULL;
      kernel_info=DestroyKernelInfo(kernel_info);
      replaceImage(newImage);
      ThrowImageException;
    }
}

bool Magick::Image::compare(const Image &reference_)
{
  bool
    status;

  Image
    ref=reference_;

  modifyImage();
  ref.modifyImage();
  status=static_cast<bool>(IsImagesEqual(image(),ref.constImage()));
  throwImageException();
  return(status);
}

double Magick::Image::compare(const Image &reference_,const MetricType metric_)
{
  double
    distortion=0.0;

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

double Magick::Image::compareChannel(const ChannelType channel_,
  const Image &reference_,const MetricType metric_)
{
  double
    distortion=0.0;

  GetPPException;
  GetImageChannelDistortion(image(),reference_.constImage(),channel_,metric_,
    &distortion,exceptionInfo);
  ThrowImageException;
  return(distortion);
}

Magick::Image Magick::Image::compare(const Image &reference_,
  const MetricType metric_,double *distortion)
{
  MagickCore::Image
    *newImage;

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

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

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

void Magick::Image::composite(const Image &compositeImage_,
  const Geometry &offset_,const CompositeOperator compose_)
{
  size_t
    height=rows(),
    width=columns();

  ssize_t
    x=offset_.xOff(),
    y=offset_.yOff();

  modifyImage();
  ParseMetaGeometry(static_cast<std::string>(offset_).c_str(),&x,&y,&width,
    &height);

  CompositeImage(image(),compose_,compositeImage_.constImage(),x,y);
  throwImageException();
}

void Magick::Image::composite(const Image &compositeImage_,
  const GravityType gravity_,const CompositeOperator compose_)
{
  RectangleInfo
    geometry;

  modifyImage();

  SetGeometry(compositeImage_.constImage(),&geometry);
  GravityAdjustGeometry(columns(),rows(),gravity_,&geometry);

  CompositeImage(image(),compose_,compositeImage_.constImage(),geometry.x,
    geometry.y);
  throwImageException();
}

void Magick::Image::composite(const Image &compositeImage_,
  const ssize_t xOffset_,const ssize_t yOffset_,
  const CompositeOperator compose_)
{
  // Image supplied as compositeImage is composited with current image and
  // results in updating current image.
  modifyImage();

  CompositeImage(image(),compose_,compositeImage_.constImage(),xOffset_,
    yOffset_);
  throwImageException();
}

void Magick::Image::connectedComponents(const size_t connectivity_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=ConnectedComponentsImage(constImage(),connectivity_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::contrast(const size_t sharpen_)
{
  modifyImage();
  ContrastImage(image(),(MagickBooleanType) sharpen_);
  throwImageException();
}

void Magick::Image::contrastStretch(const double black_point_,
  const double white_point_)
{
  modifyImage();
  ContrastStretchImageChannel(image(),DefaultChannels,black_point_,
    white_point_);
  throwImageException();
}

void Magick::Image::contrastStretchChannel(const ChannelType channel_,
  const double black_point_,const double white_point_)
{
  modifyImage();
  ContrastStretchImageChannel(image(),channel_,black_point_,white_point_);
  throwImageException();
}

void Magick::Image::convolve(const size_t order_,const double *kernel_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=ConvolveImage(constImage(),order_,kernel_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::copyPixels(const Image &source_,const Geometry &geometry_,
  const Offset &offset_)
{
  const OffsetInfo
    offset=offset_;

  const RectangleInfo
    geometry=geometry_;

  GetPPException;
  (void) CopyImagePixels(image(),source_.constImage(),&geometry,&offset,
    exceptionInfo);
  ThrowImageException;
}


void Magick::Image::crop(const Geometry &geometry_)
{
  MagickCore::Image
    *newImage;

  RectangleInfo
    cropInfo=geometry_;

  GetPPException;
  newImage=CropImage(constImage(),&cropInfo,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::cycleColormap(const ssize_t amount_)
{
  modifyImage();
  CycleColormapImage(image(),amount_);
  throwImageException();
}

void Magick::Image::decipher(const std::string &passphrase_)
{
  modifyImage();
  GetPPException;
  DecipherImage(image(),passphrase_.c_str(),exceptionInfo);
  ThrowImageException;
}

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

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

bool Magick::Image::defineSet(const std::string &magick_,
  const std::string &key_) const
{
  const char
    *option;

  std::string
    key;

  key=magick_ + ":" + key_;
  option=GetImageOption(constImageInfo(),key.c_str());
  if (option)
    return(true);
  return(false);
}

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

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

std::string Magick::Image::defineValue(const std::string &magick_,
  const std::string &key_) const
{
  const char
    *option;

  std::string
    definition;

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

void Magick::Image::deskew(const double threshold_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=DeskewImage(constImage(),threshold_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::despeckle(void)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=DespeckleImage(constImage(),exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

Magick::ImageType Magick::Image::determineType(void) const
{
  ImageType
    image_type;

  GetPPException;
  image_type=GetImageType(constImage(),exceptionInfo);
  ThrowImageException;
  return(image_type);
}

void Magick::Image::display(void)
{
  DisplayImages(imageInfo(),image());
}

void Magick::Image::distort(const DistortImageMethod method_,
  const size_t number_arguments_,const double *arguments_,const bool bestfit_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=DistortImage(constImage(),method_,number_arguments_,arguments_,
    bestfit_ == true ? MagickTrue : MagickFalse,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::draw(const Magick::Drawable &drawable_)
{
  DrawingWand
    *wand;

  modifyImage();

  wand=AcquireDrawingWand(options()->drawInfo(),image());

  if(wand)
    {
      drawable_.operator()(wand);

      if (constImage()->exception.severity == UndefinedException)
        DrawRender(wand);

      wand=DestroyDrawingWand(wand);
    }

  throwImageException();
}

void Magick::Image::draw(const std::list<Magick::Drawable> &drawable_)
{
  DrawingWand
    *wand;

  modifyImage();

  wand=AcquireDrawingWand(options()->drawInfo(),image());

  if(wand)
    {
      for (std::list<Magick::Drawable>::const_iterator p = drawable_.begin();
           p != drawable_.end(); p++)
        {
          p->operator()(wand);
          if (constImage()->exception.severity != UndefinedException)
            break;
        }

      if (constImage()->exception.severity == UndefinedException)
        DrawRender(wand);

      wand=DestroyDrawingWand(wand);
    }

  throwImageException();
}

void Magick::Image::edge(const double radius_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=EdgeImage(constImage(),radius_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::emboss(const double radius_,const double sigma_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=EmbossImage(constImage(),radius_,sigma_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::encipher(const std::string &passphrase_)
{
  modifyImage();
  GetPPException;
  EncipherImage(image(),passphrase_.c_str(),exceptionInfo);
  ThrowImageException;
}

void Magick::Image::enhance(void)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=EnhanceImage(constImage(),exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::equalize(void)
{
  modifyImage();
  EqualizeImage(image());
  throwImageException();
}

void Magick::Image::erase(void)
{
  modifyImage();
  (void) SetImageBackgroundColor(image());
  throwImageException();
}

void Magick::Image::extent(const Geometry &geometry_)
{
  MagickCore::Image
    *newImage;

  RectangleInfo
    extentInfo;

  modifyImage();

  GetPPException;
  extentInfo=geometry_;
  extentInfo.x=geometry_.xOff();
  extentInfo.y=geometry_.yOff();
  newImage=ExtentImage(constImage(),&extentInfo,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::extent(const Geometry &geometry_,
  const Color &backgroundColor_)
{
  backgroundColor(backgroundColor_);
  extent(geometry_);
}

void Magick::Image::extent(const Geometry &geometry_,
  const Color &backgroundColor_,const GravityType gravity_)
{
  image()->gravity=gravity_;
  backgroundColor(backgroundColor_);
  extent(geometry_,gravity_);
}

void Magick::Image::extent(const Geometry &geometry_,
  const GravityType gravity_)
{
  RectangleInfo
    geometry;

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

void Magick::Image::flip(void)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=FlipImage(constImage(),exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::floodFillColor(const Geometry &point_,
  const Magick::Color &fillColor_)
{
  floodFillColor(point_.xOff(),point_.yOff(),fillColor_,false);
}

void Magick::Image::floodFillColor(const Geometry &point_,
  const Magick::Color &fillColor_,const bool invert_)
{
  floodFillColor(point_.xOff(),point_.yOff(),fillColor_,invert_);
}

void Magick::Image::floodFillColor(const ssize_t x_,const ssize_t y_,
  const Magick::Color &fillColor_)
{
  floodFillColor(x_,y_,fillColor_,false);
}

void Magick::Image::floodFillColor(const ssize_t x_,const ssize_t y_,
  const Magick::Color &fillColor_,const bool invert_)
{
  PixelPacket
    pixel;

  modifyImage();

  pixel=pixelColor(x_,y_);
  floodFill(x_,y_,(Magick::Image *)NULL,fillColor_,&pixel,invert_);
}

void Magick::Image::floodFillColor(const Geometry &point_,
  const Magick::Color &fillColor_,const Magick::Color &borderColor_)
{
  floodFillColor(point_.xOff(),point_.yOff(),fillColor_,borderColor_,false);
}

void Magick::Image::floodFillColor(const Geometry &point_,
  const Magick::Color &fillColor_,const Magick::Color &borderColor_,
  const bool invert_)
{
  floodFillColor(point_.xOff(),point_.yOff(),fillColor_,borderColor_,invert_);
}

void Magick::Image::floodFillColor(const ssize_t x_,const ssize_t y_,
  const Magick::Color &fillColor_,const Magick::Color &borderColor_)
{
  floodFillColor(x_,y_,fillColor_,borderColor_,false);
}

void Magick::Image::floodFillColor(const ssize_t x_,const ssize_t y_,
  const Magick::Color &fillColor_,const Magick::Color &borderColor_,
  const bool invert_)
{
  PixelPacket
    pixel;

  modifyImage();

  pixel=static_cast<PixelPacket>(borderColor_);
  floodFill(x_,y_,(Magick::Image *)NULL,fillColor_,&pixel,invert_);
}

void Magick::Image::floodFillOpacity(const ssize_t x_,const ssize_t y_,
  const unsigned int opacity_,const bool invert_)
{
  MagickPixelPacket
    target;

  PixelPacket
    pixel;

  modifyImage();

  GetMagickPixelPacket(constImage(),&target);
  pixel=static_cast<PixelPacket>(pixelColor(x_,y_));
  target.red=pixel.red;
  target.green=pixel.green;
  target.blue=pixel.blue;
  target.opacity=opacity_;
  (void) FloodfillPaintImage(image(),OpacityChannel,options()->drawInfo(),
    &target,x_,y_,(MagickBooleanType)invert_);
  throwImageException();
}

void Magick::Image::floodFillOpacity(const ssize_t x_,const ssize_t y_,
  const unsigned int opacity_,const PaintMethod method_)
{
  floodFillOpacity(x_,y_,opacity_,method_ == FloodfillMethod ? false : true);
}

void Magick::Image::floodFillOpacity(const ::ssize_t x_,const ::ssize_t y_,
  const unsigned int opacity_,const Color &target_,const bool invert_)
{
  MagickPixelPacket
    target;

  PixelPacket
    pixel;

  modifyImage();

  GetMagickPixelPacket(constImage(),&target);
  pixel=static_cast<PixelPacket>(target_);
  target.red=pixel.red;
  target.green=pixel.green;
  target.blue=pixel.blue;
  target.opacity=opacity_;
  (void) FloodfillPaintImage(image(),OpacityChannel,options()->drawInfo(),
    &target,x_,y_,(MagickBooleanType)invert_);
  throwImageException();
}

void Magick::Image::floodFillTexture(const Magick::Geometry &point_,
  const Magick::Image &texture_)
{
  floodFillTexture(point_.xOff(),point_.yOff(),texture_,false);
}

void Magick::Image::floodFillTexture(const Magick::Geometry &point_,
  const Magick::Image &texture_,const bool invert_)
{
  floodFillTexture(point_.xOff(),point_.yOff(),texture_,invert_);
}

void Magick::Image::floodFillTexture(const ssize_t x_,const ssize_t y_,
  const Magick::Image &texture_)
{
  floodFillTexture(x_,y_,texture_,false);
}

void Magick::Image::floodFillTexture(const ssize_t x_,const ssize_t y_,
  const Magick::Image &texture_,const bool invert_)
{
  PixelPacket
    pixel;

  modifyImage();

  pixel=static_cast<PixelPacket>(pixelColor(x_,y_));
  floodFill(x_,y_,&texture_,Magick::Color(),&pixel,invert_);
}

void Magick::Image::floodFillTexture(const Magick::Geometry &point_,
  const Magick::Image &texture_,const Magick::Color &borderColor_)
{
  floodFillTexture(point_.xOff(),point_.yOff(),texture_,borderColor_,false);
}

void Magick::Image::floodFillTexture(const Magick::Geometry &point_,
  const Magick::Image &texture_,const Magick::Color &borderColor_,
  const bool invert_)
{
  floodFillTexture(point_.xOff(),point_.yOff(),texture_,borderColor_,invert_);
}

void Magick::Image::floodFillTexture(const ssize_t x_,const ssize_t y_,
  const Magick::Image &texture_,const Magick::Color &borderColor_)
{
  floodFillTexture(x_,y_,texture_,borderColor_,false);
}

void Magick::Image::floodFillTexture(const ssize_t x_,const ssize_t y_,
  const Magick::Image &texture_,const Magick::Color &borderColor_,
  const bool invert_)
{
  PixelPacket
    pixel;

  modifyImage();

  pixel=static_cast<PixelPacket>(borderColor_);
  floodFill(x_,y_,&texture_,Magick::Color(),&pixel,invert_);
}

void Magick::Image::flop(void)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=FlopImage(constImage(),exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

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

  drawInfo=options()->drawInfo();
  drawInfo->text=const_cast<char *>(text_.c_str());
  if (GetTypeMetrics(image(),drawInfo,&(metrics->_typeMetric)) == MagickFalse)
    throwImageException();
  drawInfo->text=0;
}

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

  drawInfo=options()->drawInfo();
  drawInfo->text=const_cast<char *>(text_.c_str());
  GetMultilineTypeMetrics(image(),drawInfo,&(metrics->_typeMetric));
  drawInfo->text=0;
}

void Magick::Image::frame(const Geometry &geometry_)
{
  FrameInfo
    info;

  MagickCore::Image
    *newImage;

  info.x=static_cast<ssize_t>(geometry_.width());
  info.y=static_cast<ssize_t>(geometry_.height());
  info.width=columns() + ( static_cast<size_t>(info.x) << 1 );
  info.height=rows() + ( static_cast<size_t>(info.y) << 1 );
  info.outer_bevel=geometry_.xOff();
  info.inner_bevel=geometry_.yOff();

  GetPPException;
  newImage=FrameImage(constImage(),&info,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::frame(const size_t width_,const size_t height_,
  const ssize_t innerBevel_,const ssize_t outerBevel_)
{
  FrameInfo
    info;

  MagickCore::Image
    *newImage;

  info.x=static_cast<ssize_t>(width_);
  info.y=static_cast<ssize_t>(height_);
  info.width=columns() + ( static_cast<size_t>(info.x) << 1 );
  info.height=rows() + ( static_cast<size_t>(info.y) << 1 );
  info.outer_bevel=static_cast<ssize_t>(outerBevel_);
  info.inner_bevel=static_cast<ssize_t>(innerBevel_);

  GetPPException;
  newImage=FrameImage(constImage(),&info,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::fx(const std::string expression)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=FxImageChannel(constImage(),DefaultChannels,expression.c_str(),
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::fx(const std::string expression,
  const Magick::ChannelType channel)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=FxImageChannel(constImage(),channel,expression.c_str(),
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::gamma(const double gamma_)
{
  char
    gamma[MaxTextExtent + 1];

  FormatLocaleString(gamma,MaxTextExtent,"%3.6f",gamma_);

  modifyImage();
  GammaImage(image(),gamma);
}

void Magick::Image::gamma(const double gammaRed_,const double gammaGreen_,
  const double gammaBlue_)
{
  char
    gamma[MaxTextExtent + 1];

  FormatLocaleString(gamma,MaxTextExtent,"%3.6f/%3.6f/%3.6f/",gammaRed_,
    gammaGreen_,gammaBlue_);

  modifyImage();
  GammaImage(image(),gamma);
  throwImageException();
}

void Magick::Image::gaussianBlur(const double width_,const double sigma_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=GaussianBlurImage(constImage(),width_,sigma_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::gaussianBlurChannel(const ChannelType channel_,
  const double width_,const double sigma_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=GaussianBlurImageChannel(constImage(),channel_,width_,sigma_,
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

const Magick::IndexPacket* Magick::Image::getConstIndexes(void) const
{
  const Magick::IndexPacket
    *result;

  result=GetVirtualIndexQueue(constImage());
  if (!result)
    throwImageException();

  return(result);
}

const Magick::PixelPacket* Magick::Image::getConstPixels(const ssize_t x_,
  const ssize_t y_,const size_t columns_,const size_t rows_) const
{
  const PixelPacket
    *result;

  GetPPException;
  result=GetVirtualPixels(constImage(),x_,y_,columns_,rows_,exceptionInfo);
  ThrowImageException;
  return(result);
}

Magick::IndexPacket *Magick::Image::getIndexes(void)
{
  Magick::IndexPacket
    *result;

  result=GetAuthenticIndexQueue(image());

  if(!result)
    throwImageException();

  return(result);
}

Magick::PixelPacket *Magick::Image::getPixels(const ssize_t x_,
  const ssize_t y_,const size_t columns_,const size_t rows_)
{
  PixelPacket
    *result;

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

void Magick::Image::grayscale(const PixelIntensityMethod method_)
{
  modifyImage();
  (void) GrayscaleImage(image(),method_);
  throwImageException();
}

void Magick::Image::haldClut(const Image &clutImage_)
{
  modifyImage();
  (void) HaldClutImage(image(),clutImage_.constImage());
  throwImageException();
}

void Magick::Image::houghLine(const size_t width_,const size_t height_,
  const size_t threshold_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=HoughLineImage(constImage(),width_,height_,threshold_,
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::implode(const double factor_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=ImplodeImage(constImage(),factor_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::inverseFourierTransform(const Image &phase_)
{
  inverseFourierTransform(phase_,true);
}

void Magick::Image::inverseFourierTransform(const Image &phase_,
  const bool magnitude_)
{
  MagickCore::Image
    *newImage;

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

void Magick::Image::kuwahara(const double radius_,const double sigma_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=KuwaharaImage(constImage(),radius_,sigma_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::kuwaharaChannel(const ChannelType channel_,
  const double radius_,const double sigma_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=KuwaharaImageChannel(constImage(),channel_,radius_,sigma_,
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::level(const double black_point,const double white_point,
  const double gamma)
{
  char
    levels[MaxTextExtent];

  modifyImage();
  FormatLocaleString(levels,MaxTextExtent,"%g,%g,%g",black_point,white_point,
    gamma);
  (void) LevelImage(image(),levels);
  throwImageException();
}

void Magick::Image::levelChannel(const Magick::ChannelType channel,
  const double black_point,const double white_point,const double gamma)
{
  modifyImage();
  (void) LevelImageChannel(image(),channel,black_point,white_point,gamma);
  throwImageException();
}

void Magick::Image::levelColors(const Color &blackColor_,
  const Color &whiteColor_,const bool invert_)
{
  MagickPixelPacket
    black,
    white;

  PixelPacket
    pixel;

  modifyImage();

  GetMagickPixelPacket(image(),&black);
  pixel=static_cast<PixelPacket>(blackColor_);
  black.red=pixel.red;
  black.green=pixel.green;
  black.blue=pixel.blue;
  black.opacity=pixel.opacity;

  GetMagickPixelPacket(image(),&white);
  pixel=static_cast<PixelPacket>(whiteColor_);
  white.red=pixel.red;
  white.green=pixel.green;
  white.blue=pixel.blue;
  white.opacity=pixel.opacity;

  (void) LevelColorsImage(image(),&black,&white,
    invert_ == true ? MagickTrue : MagickFalse);
  throwImageException();
}

void Magick::Image::levelColorsChannel(const ChannelType channel_,
  const Color &blackColor_,const Color &whiteColor_,const bool invert_)
{
  MagickPixelPacket
    black,
    white;

  PixelPacket
    pixel;

  modifyImage();

  GetMagickPixelPacket(image(),&black);
  pixel=static_cast<PixelPacket>(blackColor_);
  black.red=pixel.red;
  black.green=pixel.green;
  black.blue=pixel.blue;
  black.opacity=pixel.opacity;

  GetMagickPixelPacket(image(),&white);
  pixel=static_cast<PixelPacket>(whiteColor_);
  white.red=pixel.red;
  white.green=pixel.green;
  white.blue=pixel.blue;
  white.opacity=pixel.opacity;

  (void) LevelColorsImageChannel(image(),channel_,&black,&white,
    invert_ == true ? MagickTrue : MagickFalse);
  throwImageException();
}

void Magick::Image::levelize(const double blackPoint_,const double whitePoint_,
  const double gamma_)
{
  modifyImage();
  (void) LevelizeImage(image(),blackPoint_,whitePoint_,gamma_);
  throwImageException();
}

void Magick::Image::levelizeChannel(const ChannelType channel_,
  const double blackPoint_,const double whitePoint_,const double gamma_)
{
  modifyImage();
  (void) LevelizeImageChannel(image(),channel_,blackPoint_,whitePoint_,gamma_);
  throwImageException();
}

void Magick::Image::linearStretch(const double blackPoint_,
  const double whitePoint_)
{
  modifyImage();
  LinearStretchImage(image(),blackPoint_,whitePoint_);
  throwImageException();
}

void Magick::Image::liquidRescale(const Geometry &geometry_)
{
  MagickCore::Image
    *newImage;

  size_t
    height=rows(),
    width=columns();

  ssize_t
    x=0,
    y=0;

  ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
    &height);

  GetPPException;
  newImage=LiquidRescaleImage(constImage(),width,height,x,y,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::localContrast(const double radius_,const double strength_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=LocalContrastImage(constImage(),radius_,strength_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::magnify(void)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=MagnifyImage(constImage(),exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::map(const Image &mapImage_,const bool dither_)
{
  modifyImage();
  options()->quantizeDither(dither_);
  RemapImage(options()->quantizeInfo(),image(),mapImage_.constImage());
  throwImageException();
}

void Magick::Image::matteFloodfill(const Color &target_,
  const unsigned int opacity_,const ssize_t x_,const ssize_t y_,
  const Magick::PaintMethod method_)
{
  floodFillOpacity(x_,y_,opacity_,target_,
    method_ == FloodfillMethod ? false : true);
}

void Magick::Image::medianFilter(const double radius_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=StatisticImage(constImage(),MedianStatistic,(size_t) radius_,
    (size_t) radius_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::mergeLayers(const ImageLayerMethod layerMethod_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=MergeImageLayers(image(),layerMethod_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::minify(void)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=MinifyImage(constImage(),exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::modulate(const double brightness_,const double saturation_,
  const double hue_)
{
  char
    modulate[MaxTextExtent + 1];

  FormatLocaleString(modulate,MaxTextExtent,"%3.6f,%3.6f,%3.6f",brightness_,
    saturation_,hue_);

  modifyImage();
  ModulateImage(image(),modulate);
  throwImageException();
}

Magick::ImageMoments Magick::Image::moments(void) const
{
  return(ImageMoments(*this));
}

void Magick::Image::morphology(const MorphologyMethod method_,
  const std::string kernel_,const ssize_t iterations_)
{
  KernelInfo
    *kernel;

  MagickCore::Image
    *newImage;

  kernel=AcquireKernelInfo(kernel_.c_str());
  if (kernel == (KernelInfo *)NULL)
    throwExceptionExplicit(OptionError,"Unable to parse kernel.");

  GetPPException;
  newImage=MorphologyImage(constImage(),method_,iterations_,kernel,
    exceptionInfo);
  replaceImage(newImage);
  kernel=DestroyKernelInfo(kernel);
  ThrowImageException;
}

void Magick::Image::morphology(const MorphologyMethod method_,
  const KernelInfoType kernel_,const std::string arguments_,
  const ssize_t iterations_)
{
  const char
    *option;

  std::string
    kernel;

  option=CommandOptionToMnemonic(MagickKernelOptions,kernel_);
  if (option == (const char *)NULL)
    {
      throwExceptionExplicit(OptionError,"Unable to determine kernel type.");
      return;
    }

  kernel=std::string(option);
  if (!arguments_.empty())
    kernel+=":"+arguments_;

  morphology(method_,kernel,iterations_);
}

void Magick::Image::morphologyChannel(const ChannelType channel_,
  const MorphologyMethod method_,const std::string kernel_,
  const ssize_t iterations_)
{
  KernelInfo
    *kernel;

  MagickCore::Image
    *newImage;

  kernel=AcquireKernelInfo(kernel_.c_str());
  if (kernel == (KernelInfo *)NULL)
    {
      throwExceptionExplicit(OptionError,"Unable to parse kernel.");
      return;
    }

  GetPPException;
  newImage=MorphologyImageChannel(constImage(),channel_,method_,iterations_,
    kernel,exceptionInfo);
  replaceImage(newImage);
  kernel=DestroyKernelInfo(kernel);
  ThrowImageException;
}

void Magick::Image::morphologyChannel(const ChannelType channel_,
  const MorphologyMethod method_,const KernelInfoType kernel_,
  const std::string arguments_,const ssize_t iterations_)
{
  const char
    *option;

  std::string
    kernel;

  option=CommandOptionToMnemonic(MagickKernelOptions,kernel_);
  if (option == (const char *)NULL)
    throwExceptionExplicit(OptionError,"Unable to determine kernel type.");

  kernel=std::string(option);
  if (!arguments_.empty())
    kernel+=":"+arguments_;

  morphologyChannel(channel_,method_,kernel,iterations_);
}

void Magick::Image::motionBlur(const double radius_,const double sigma_,
  const double angle_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=MotionBlurImage(constImage(),radius_,sigma_,angle_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::negate(const bool grayscale_)
{
  modifyImage();
  NegateImage(image(),(MagickBooleanType) grayscale_);
  throwImageException();
}

void Magick::Image::negateChannel(const ChannelType channel_,
  const bool grayscale_)
{
  modifyImage();
  NegateImageChannel(image(),channel_,(MagickBooleanType) grayscale_);
  throwImageException();
}

void Magick::Image::normalize(void)
{
  modifyImage();
  NormalizeImage(image());
  throwImageException();
}

void Magick::Image::oilPaint(const double radius_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=OilPaintImage(constImage(),radius_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::opacity(const unsigned int opacity_)
{
  modifyImage();
  SetImageOpacity(image(),opacity_);
}
void Magick::Image::opaque(const Color &opaqueColor_,const Color &penColor_,
  const bool invert_)
{
  MagickPixelPacket
    opaque,
    pen;

  std::string
    opaqueColor,
    penColor;

  if (!opaqueColor_.isValid())
    throwExceptionExplicit(OptionError,"Opaque color argument is invalid");
  
  if (!penColor_.isValid())
    throwExceptionExplicit(OptionError,"Pen color argument is invalid");

  opaqueColor=opaqueColor_;
  penColor=penColor_;

  (void) QueryMagickColor(opaqueColor.c_str(),&opaque,&image()->exception);
  (void) QueryMagickColor(penColor.c_str(),&pen,&image()->exception);
  modifyImage();
  OpaquePaintImage(image(),&opaque,&pen,invert_ ? MagickTrue : MagickFalse);
  throwImageException();
}

void Magick::Image::orderedDither(std::string thresholdMap_)
{
  modifyImage();
  GetPPException;
  (void) OrderedPosterizeImage(image(),thresholdMap_.c_str(),exceptionInfo);
  ThrowImageException;
}

void Magick::Image::orderedDitherChannel(const ChannelType channel_,
  std::string thresholdMap_)
{
  modifyImage();
  GetPPException;
  (void) OrderedPosterizeImageChannel(image(),channel_,thresholdMap_.c_str(),
    exceptionInfo);
  ThrowImageException;
}

void Magick::Image::perceptible(const double epsilon_)
{
  modifyImage();
  PerceptibleImage(image(),epsilon_);
  throwImageException();
}

void Magick::Image::perceptibleChannel(const ChannelType channel_,
  const double epsilon_)
{
  modifyImage();
  PerceptibleImageChannel(image(),channel_,epsilon_);
  throwImageException();
}

void Magick::Image::ping(const Blob& blob_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=PingBlob(imageInfo(),blob_.data(),blob_.length(),exceptionInfo);
  read(newImage,exceptionInfo);
}

void Magick::Image::ping(const std::string &imageSpec_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  options()->fileName(imageSpec_);
  newImage=PingImage(imageInfo(),exceptionInfo);
  read(newImage,exceptionInfo);
}

void Magick::Image::pixelColor(const ssize_t x_,const ssize_t y_,
  const Color &color_)
{
  // Test arguments to ensure they are within the image.
  if (y_ > (ssize_t) rows() || x_ > (ssize_t) columns())
    throwExceptionExplicit(OptionError,"Access outside of image boundary");

  modifyImage();

  // Set image to DirectClass
  classType(DirectClass);

  // Get pixel view
  Pixels pixels(*this);
  // Set pixel value
  *(pixels.get(x_,y_,1,1))=color_;
  // Tell ImageMagick that pixels have been updated
  pixels.sync();
}

Magick::Color Magick::Image::pixelColor(const ssize_t x_,
  const ssize_t y_) const
{
  ClassType
    storage_class;

  storage_class=classType();
  if (storage_class == DirectClass)
    {
      const PixelPacket
        *pixel;

      pixel=getConstPixels(x_,y_,1,1);
      if (pixel)
        return(Color(*pixel));
    }
  else if (storage_class == PseudoClass)
    {
      const IndexPacket
        *indexes;

      indexes=getConstIndexes();
      if(indexes)
        return(colorMap((size_t) *indexes));
    }

  return(Color()); // invalid
}

void Magick::Image::polaroid(const std::string &caption_,const double angle_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  (void) SetImageProperty(image(),"Caption",caption_.c_str());
  newImage=PolaroidImage(constImage(),options()->drawInfo(),angle_,
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::posterize(const size_t levels_,const bool dither_)
{
  modifyImage();
  PosterizeImage(image(),levels_,(MagickBooleanType) dither_);
  throwImageException();
}

void Magick::Image::posterizeChannel(const ChannelType channel_,
  const size_t levels_,const bool dither_)
{
  modifyImage();
  PosterizeImageChannel(image(),channel_,levels_,
    (MagickBooleanType) dither_);
  throwImageException();
}

void Magick::Image::process(std::string name_,const ssize_t argc,
  const char **argv)
{
  size_t
    status;

  modifyImage();

  status=InvokeDynamicImageFilter(name_.c_str(),&image(),argc, argv,
    &image()->exception);

  if (status == false)
    throwImageException();
}

void Magick::Image::profile(const std::string name_,
  const Magick::Blob &profile_)
{
  ssize_t
    result;

  modifyImage();
  result=ProfileImage(image(),name_.c_str(),(unsigned char *)profile_.data(),
    profile_.length(),MagickTrue);

  if (!result)
    throwImageException();
}

Magick::Blob Magick::Image::profile(const std::string name_) const
{
  const StringInfo
    *profile;

  profile=GetImageProfile(constImage(),name_.c_str());

  if (profile == (StringInfo *) NULL)
    return(Blob());
  return(Blob((void*) GetStringInfoDatum(profile),GetStringInfoLength(
    profile)));
}

void Magick::Image::quantize(const bool measureError_)
{
  modifyImage();
 
  if (measureError_)
    options()->quantizeInfo()->measure_error=MagickTrue;
  else
    options()->quantizeInfo()->measure_error=MagickFalse;

  QuantizeImage(options()->quantizeInfo(),image());

  throwImageException();
}

void Magick::Image::quantumOperator(const ChannelType channel_,
  const MagickEvaluateOperator operator_,double rvalue_)
{
  GetPPException;
  EvaluateImageChannel(image(),channel_,operator_,rvalue_,exceptionInfo);
  ThrowImageException;
}

void Magick::Image::quantumOperator(const ChannelType channel_,
  const MagickFunction function_,const size_t number_parameters_,
  const double *parameters_)
{
  GetPPException;
  FunctionImageChannel(image(),channel_,function_,number_parameters_,
    parameters_,exceptionInfo);
  ThrowImageException;
}

void Magick::Image::quantumOperator(const ssize_t x_,const ssize_t y_,
  const size_t columns_,const size_t rows_,const ChannelType channel_,
  const MagickEvaluateOperator operator_,const double rvalue_)
{
  MagickCore::Image
    *cropImage;

  RectangleInfo
    geometry;

  GetPPException;
  geometry.width=columns_;
  geometry.height=rows_;
  geometry.x=x_;
  geometry.y=y_;
  cropImage=CropImage(image(),&geometry,exceptionInfo);
  EvaluateImageChannel(cropImage,channel_,operator_,rvalue_,exceptionInfo);
  (void) CompositeImage(image(),image()->matte != MagickFalse ?
    OverCompositeOp : CopyCompositeOp,cropImage,geometry.x, geometry.y);
  cropImage=DestroyImageList(cropImage);
  ThrowImageException;
}

void Magick::Image::raise(const Geometry &geometry_,const bool raisedFlag_)
{
  RectangleInfo
    raiseInfo;

  raiseInfo=geometry_;
  modifyImage();
  RaiseImage(image(),&raiseInfo,raisedFlag_ == true ?
    MagickTrue : MagickFalse);
  throwImageException();
}

void Magick::Image::randomThreshold( const Geometry &thresholds_ )
{
  GetPPException;
  modifyImage();
  (void) RandomThresholdImage(image(),static_cast<std::string>(
    thresholds_).c_str(),exceptionInfo);
  ThrowImageException;
}

void Magick::Image::randomThresholdChannel(const Geometry &thresholds_,
  const ChannelType channel_)
{
  GetPPException;
  modifyImage();
  (void) RandomThresholdImageChannel(image(),channel_,static_cast<std::string>(
    thresholds_).c_str(),exceptionInfo);
  ThrowImageException;
}

void Magick::Image::read(const Blob &blob_)
{
  MagickCore::Image
    *newImage;

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

void Magick::Image::read(const Blob &blob_,const Geometry &size_)
{
  size(size_);
  read(blob_);
}

void Magick::Image::read(const Blob &blob_,const Geometry &size_,
  const size_t depth_)
{
  size(size_);
  depth(depth_);
  read(blob_);
}

void Magick::Image::read(const Blob &blob_,const Geometry &size_,
  const size_t depth_,const std::string &magick_)
{
  size(size_);
  depth(depth_);
  magick(magick_);
  fileName(magick_ + ':');
  read(blob_);
}

void Magick::Image::read(const Blob &blob_,const Geometry &size_,
  const std::string &magick_)
{
  size(size_);
  magick(magick_);
  fileName(magick_ + ':');
  read(blob_);
}

void Magick::Image::read(const Geometry &size_,const std::string &imageSpec_)
{
  size(size_);
  read(imageSpec_);
}

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

  GetPPException;
  newImage=ConstituteImage(width_,height_,map_.c_str(),type_,pixels_,
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
  if (newImage)
    throwException(&newImage->exception,quiet());
}

void Magick::Image::read(const std::string &imageSpec_)
{
  MagickCore::Image
    *newImage;

  options()->fileName(imageSpec_);

  GetPPException;
  newImage=ReadImage(imageInfo(),exceptionInfo);
  read(newImage,exceptionInfo);
}

void Magick::Image::readPixels(const Magick::QuantumType quantum_,
  const unsigned char *source_)
{
  QuantumInfo
    *quantum_info;

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

void Magick::Image::reduceNoise(const double order_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=StatisticImage(constImage(),NonpeakStatistic,(size_t) order_,
    (size_t) order_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::repage()
{
  modifyImage();
  options()->page(Geometry());
  image()->page.width = 0;
  image()->page.height = 0;
  image()->page.x = 0;
  image()->page.y = 0;
}

void Magick::Image::resample(const Geometry &geometry_)
{
  MagickCore::Image
    *newImage;

  size_t
    width=columns(),
    height=rows();

  ssize_t
    x=0,
    y=0;

  ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x, &y,&width,
    &height);

  GetPPException;
  newImage=ResampleImage(constImage(),width,height,image()->filter,1.0,
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::resize(const Geometry &geometry_)
{
  MagickCore::Image
    *newImage;

  size_t
    width=columns(),
    height=rows();

  ssize_t
    x=0,
    y=0;

  ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x, &y,&width,
    &height);

  GetPPException;
  newImage=ResizeImage(constImage(),width,height,image()->filter,1.0,
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::roll(const Geometry &roll_)
{
  MagickCore::Image
    *newImage;

  ssize_t
    xOff=roll_.xOff(),
    yOff=roll_.yOff();

  if (roll_.xNegative())
    xOff=0-xOff;
  if (roll_.yNegative())
    yOff=0-yOff;

  GetPPException;
  newImage=RollImage(constImage(),xOff,yOff,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::roll(const size_t columns_,const size_t rows_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=RollImage(constImage(),static_cast<ssize_t>(columns_),
    static_cast<ssize_t>(rows_),exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::rotate(const double degrees_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=RotateImage(constImage(),degrees_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::rotationalBlur(const double angle_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=RotationalBlurImage(constImage(),angle_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::rotationalBlurChannel(const ChannelType channel_,
  const double angle_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=RotationalBlurImageChannel(constImage(),channel_,angle_,
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::sample(const Geometry &geometry_)
{
  MagickCore::Image
    *newImage;

  size_t
    height=rows(),
    width=columns();

  ssize_t
    x=0,
    y=0;

  ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
    &height);

  GetPPException;
  newImage=SampleImage(constImage(),width,height,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::scale(const Geometry &geometry_)
{
  MagickCore::Image
    *newImage;

  size_t
    height=rows(),
    width=columns();

  ssize_t
    x=0,
    y=0;

  ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
    &height);

  GetPPException;
  newImage=ScaleImage(constImage(),width,height,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::segment(const double clusterThreshold_,
  const double smoothingThreshold_)
{
  modifyImage();
  SegmentImage(image(),options()->quantizeColorSpace(),
    (MagickBooleanType) options()->verbose(),clusterThreshold_,
    smoothingThreshold_);
  throwImageException();
  SyncImage(image());
  throwImageException();
}

void Magick::Image::selectiveBlur(const double radius_,const double sigma_,
  const double threshold_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=SelectiveBlurImage(constImage(),radius_,sigma_,threshold_,
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::selectiveBlurChannel(const ChannelType channel_,
  const double radius_,const double sigma_,const double threshold_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=SelectiveBlurImageChannel(constImage(),channel_,radius_,sigma_,
    threshold_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

Magick::Image Magick::Image::separate(const ChannelType channel_) const
{
  MagickCore::Image
    *image;

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

void Magick::Image::sepiaTone(const double threshold_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=SepiaToneImage(constImage(),threshold_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

Magick::PixelPacket *Magick::Image::setPixels(const ssize_t x_,
  const ssize_t y_,const size_t columns_,const size_t rows_)
{
  PixelPacket
    *result;

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

void Magick::Image::shade(const double azimuth_,const double elevation_,
  const bool colorShading_)
{
  MagickCore::Image
    *newImage;

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

void Magick::Image::shadow(const double percent_opacity_,const double sigma_,
  const ssize_t x_,const ssize_t y_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=ShadowImage(constImage(),percent_opacity_,sigma_,x_,y_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::sharpen(const double radius_,const double sigma_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=SharpenImage(constImage(),radius_,sigma_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::sharpenChannel(const ChannelType channel_,
  const double radius_,const double sigma_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=SharpenImageChannel(constImage(),channel_,radius_,sigma_,
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::shave(const Geometry &geometry_)
{
  MagickCore::Image
    *newImage;
  
  RectangleInfo
    shaveInfo=geometry_;

  GetPPException;
  newImage=ShaveImage(constImage(),&shaveInfo,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::shear(const double xShearAngle_,const double yShearAngle_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=ShearImage(constImage(),xShearAngle_,yShearAngle_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::sigmoidalContrast(const size_t sharpen_,
  const double contrast,const double midpoint)
{
  modifyImage();
  (void) SigmoidalContrastImageChannel(image(),DefaultChannels,
    (MagickBooleanType) sharpen_,contrast,midpoint);
  throwImageException();
}

std::string Magick::Image::signature(const bool force_) const
{
  const char
    *property;

  Lock lock(&_imgRef->_mutexLock);

  // Re-calculate image signature if necessary
  if (force_ ||  !GetImageProperty(constImage(), "Signature") ||
    constImage()->taint)
    SignatureImage(const_cast<MagickCore::Image *>(constImage()));

  property=GetImageProperty(constImage(),"Signature");

  return(std::string(property));
}

void Magick::Image::sketch(const double radius_,const double sigma_,
  const double angle_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=SketchImage(constImage(),radius_,sigma_,angle_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::solarize(const double factor_)
{
  modifyImage();
  SolarizeImage(image(),factor_);
  throwImageException();
}

void Magick::Image::sparseColor(const ChannelType channel,
  const SparseColorMethod method,const size_t number_arguments,
  const double *arguments)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=SparseColorImage(constImage(),channel,method,number_arguments,
    arguments,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::splice(const Geometry &geometry_)
{
  MagickCore::Image
    *newImage;

  RectangleInfo
    spliceInfo=geometry_;

  GetPPException;
  newImage=SpliceImage(constImage(),&spliceInfo,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::splice(const Geometry &geometry_,
  const Color &backgroundColor_)
{
  backgroundColor(backgroundColor_);
  splice(geometry_);
}

void Magick::Image::splice(const Geometry &geometry_,
  const Color &backgroundColor_,const GravityType gravity_)
{
  backgroundColor(backgroundColor_);
  image()->gravity=gravity_;
  splice(geometry_);
}

void Magick::Image::spread(const size_t amount_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=SpreadImage(constImage(),amount_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::statistics(ImageStatistics *statistics) const
{
  double
    maximum,
    minimum;

  GetPPException;
  (void) GetImageChannelRange(constImage(),RedChannel,&minimum,&maximum,
    exceptionInfo);
  statistics->red.minimum=minimum;
  statistics->red.maximum=maximum;
  (void) GetImageChannelMean(constImage(),RedChannel,&statistics->red.mean,
    &statistics->red.standard_deviation,exceptionInfo);
  (void) GetImageChannelKurtosis(constImage(),RedChannel,
    &statistics->red.kurtosis,&statistics->red.skewness,exceptionInfo);
  (void) GetImageChannelRange(constImage(),GreenChannel,&minimum,&maximum,
    exceptionInfo);
  statistics->green.minimum=minimum;
  statistics->green.maximum=maximum;
  (void) GetImageChannelMean(constImage(),GreenChannel,&statistics->green.mean,
    &statistics->green.standard_deviation,exceptionInfo);
  (void) GetImageChannelKurtosis(constImage(),GreenChannel,
    &statistics->green.kurtosis,&statistics->green.skewness,exceptionInfo);
  (void) GetImageChannelRange(constImage(),BlueChannel,&minimum,&maximum,
    exceptionInfo);
  statistics->blue.minimum=minimum;
  statistics->blue.maximum=maximum;
  (void) GetImageChannelMean(constImage(),BlueChannel,&statistics->blue.mean,
    &statistics->blue.standard_deviation,exceptionInfo);
  (void) GetImageChannelKurtosis(constImage(),BlueChannel,
    &statistics->blue.kurtosis,&statistics->blue.skewness,exceptionInfo);
  (void) GetImageChannelRange(constImage(),OpacityChannel,&minimum,&maximum,
    exceptionInfo);
  statistics->opacity.minimum=minimum;
  statistics->opacity.maximum=maximum;
  (void) GetImageChannelMean(constImage(),OpacityChannel,
    &statistics->opacity.mean,&statistics->opacity.standard_deviation,
    exceptionInfo);
  (void) GetImageChannelKurtosis(constImage(),OpacityChannel,
    &statistics->opacity.kurtosis,&statistics->opacity.skewness,
    exceptionInfo);
  ThrowImageException;
}

void Magick::Image::stegano(const Image &watermark_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=SteganoImage(constImage(),watermark_.constImage(),exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::stereo(const Image &rightImage_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=StereoImage(constImage(),rightImage_.constImage(),exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::strip(void)
{
  modifyImage();
  StripImage(image());
  throwImageException();
}

Magick::Image Magick::Image::subImageSearch(const Image &reference_,
  const MetricType metric_,Geometry *offset_,double *similarityMetric_,
  const double similarityThreshold)
{
  char
    artifact[MaxTextExtent];

  MagickCore::Image
    *newImage;

  RectangleInfo
    offset;

  modifyImage();
  (void) FormatLocaleString(artifact,MaxTextExtent,"%g",similarityThreshold);
  (void) SetImageArtifact(image(),"compare:similarity-threshold",artifact);

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

void Magick::Image::swirl(const double degrees_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=SwirlImage(constImage(),degrees_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::syncPixels(void)
{
  GetPPException;
  (void) SyncAuthenticPixels(image(),exceptionInfo);
  ThrowImageException;
}

void Magick::Image::texture(const Image &texture_)
{
  modifyImage();
  TextureImage(image(),texture_.constImage());
  throwImageException();
}

void Magick::Image::threshold(const double threshold_)
{
  modifyImage();
  BilevelImage(image(),threshold_);
  throwImageException();
}

void Magick::Image::thumbnail(const Geometry &geometry_)
{
  MagickCore::Image
    *newImage;

  size_t
    height=rows(),
    width=columns();

  ssize_t
    x=0,
    y=0;

  ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
    &height);

  GetPPException;
  newImage=ThumbnailImage(constImage(),width,height,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::tint(const std::string opacity_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=TintImage(constImage(),opacity_.c_str(),constOptions()->fillColor(),
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::transform(const Geometry &imageGeometry_)
{
  modifyImage();
  TransformImage(&(image()),0,std::string(imageGeometry_).c_str());
  throwImageException();
}

void Magick::Image::transform(const Geometry &imageGeometry_,
  const Geometry &cropGeometry_)
{
  modifyImage();
  TransformImage(&(image()),std::string(cropGeometry_).c_str(),
    std::string(imageGeometry_).c_str());
  throwImageException();
}

void Magick::Image::transformOrigin(const double x_,const double y_)
{
  modifyImage();
  options()->transformOrigin(x_,y_);
}

void Magick::Image::transformReset(void)
{
  modifyImage();
  options()->transformReset();
}

void Magick::Image::transformScale(const double sx_,const double sy_)
{
  modifyImage();
  options()->transformScale(sx_,sy_);
}

void Magick::Image::transparent(const Color &color_)
{
  MagickPixelPacket
    target;

  std::string
    color;

  if (!color_.isValid())
    throwExceptionExplicit(OptionError,"Color argument is invalid");

  color=color_;

  (void) QueryMagickColor(std::string(color_).c_str(),&target,
    &image()->exception);
  modifyImage();
  TransparentPaintImage(image(),&target,TransparentOpacity,MagickFalse);
  throwImageException();
}

void Magick::Image::transparentChroma(const Color &colorLow_,
  const Color &colorHigh_)
{
  MagickPixelPacket
    targetHigh,
    targetLow;

  std::string
    colorHigh,
    colorLow;

  if (!colorLow_.isValid() || !colorHigh_.isValid())
    throwExceptionExplicit(OptionError,"Color argument is invalid");

  colorLow=colorLow_;
  colorHigh=colorHigh_;

  (void) QueryMagickColor(colorLow.c_str(),&targetLow,&image()->exception);
  (void) QueryMagickColor(colorHigh.c_str(),&targetHigh,&image()->exception);
  modifyImage();
  TransparentPaintImageChroma(image(),&targetLow,&targetHigh,
    TransparentOpacity,MagickFalse);
  throwImageException();
}

void Magick::Image::transpose(void)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=TransposeImage(constImage(),exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::transverse(void)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=TransverseImage(constImage(),exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::trim(void)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=TrimImage(constImage(),exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

Magick::Image Magick::Image::uniqueColors(void) const
{
  MagickCore::Image
    *image;

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

void Magick::Image::unsharpmask(const double radius_,const double sigma_,
  const double amount_,const double threshold_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=UnsharpMaskImage(constImage(),radius_,sigma_,amount_,threshold_,
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::unsharpmaskChannel(const ChannelType channel_,
  const double radius_,const double sigma_,const double amount_,
  const double threshold_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=UnsharpMaskImageChannel(constImage(),channel_,radius_,sigma_,
    amount_,threshold_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::vignette(const double radius_,const double sigma_,
  const ssize_t x_,const ssize_t y_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=VignetteImage(constImage(),radius_,sigma_,x_,y_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::wave(const double amplitude_,const double wavelength_)
{
  MagickCore::Image
    *newImage;

  GetPPException;
  newImage=WaveImage(constImage(),amplitude_,wavelength_,exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

void Magick::Image::whiteThreshold(const std::string &threshold_)
{
  modifyImage();
  WhiteThresholdImage(image(),threshold_.c_str());
  throwImageException();
}

void Magick::Image::whiteThresholdChannel(const ChannelType channel_,
  const std::string &threshold_)
{
  modifyImage();
  GetPPException;
  WhiteThresholdImageChannel(image(),channel_,threshold_.c_str(),
    exceptionInfo);
  ThrowImageException;
}

void Magick::Image::write(Blob *blob_)
{
  size_t
    length=0;

  void
    *data;

  modifyImage();
  GetPPException;
  data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
  if (length > 0)
    blob_->updateNoCopy(data,length,Blob::MallocAllocator);
  ThrowImageException;
  throwImageException();
}

void Magick::Image::write(Blob *blob_,const std::string &magick_)
{
  size_t
    length=0;

  void
    *data;

  modifyImage();
  magick(magick_);
  GetPPException;
  data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
  if (length > 0)
    blob_->updateNoCopy(data,length,Blob::MallocAllocator);
  ThrowImageException;
  throwImageException();
}

void Magick::Image::write(Blob *blob_,const std::string &magick_,
  const size_t depth_)
{
  size_t
    length=0;

  void
    *data;

  modifyImage();
  magick(magick_);
  depth(depth_);
  GetPPException;
  data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
  if (length > 0)
    blob_->updateNoCopy(data,length,Blob::MallocAllocator);
  ThrowImageException;
  throwImageException();
}

void Magick::Image::write(const ssize_t x_,const ssize_t y_,
  const size_t columns_,const size_t rows_,const std::string &map_,
  const StorageType type_,void *pixels_)
{
  GetPPException;
  ExportImagePixels(constImage(),x_,y_,columns_,rows_,map_.c_str(),type_,
    pixels_,exceptionInfo);
  ThrowImageException;
}

void Magick::Image::write(const std::string &imageSpec_)
{
  modifyImage();
  fileName(imageSpec_);
  WriteImage(constImageInfo(),image());
  throwImageException();
}

void Magick::Image::writePixels(const Magick::QuantumType quantum_,
  unsigned char *destination_)
{
  QuantumInfo
    *quantum_info;

  quantum_info=AcquireQuantumInfo(imageInfo(),image());
  GetPPException;
  ExportQuantumPixels(constImage(),(MagickCore::CacheView *) NULL,quantum_info,
    quantum_,destination_,exceptionInfo);
  quantum_info=DestroyQuantumInfo(quantum_info);
  ThrowImageException;
}

void Magick::Image::zoom(const Geometry &geometry_)
{
  MagickCore::Image
    *newImage;

  size_t
    height=rows(),
    width=columns();

  ssize_t
    x=0,
    y=0;

  ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
    &height);

  GetPPException;
  newImage=ResizeImage(constImage(),width,height,image()->filter,image()->blur,
    exceptionInfo);
  replaceImage(newImage);
  ThrowImageException;
}

Magick::Image::Image(MagickCore::Image *image_)
  : _imgRef(new ImageRef(image_))
{
}

MagickCore::Image *&Magick::Image::image(void)
{
  return(_imgRef->image());
}

const MagickCore::Image *Magick::Image::constImage(void) const
{
  return(_imgRef->image());
}

MagickCore::ImageInfo *Magick::Image::imageInfo(void)
{
  return(_imgRef->options()->imageInfo());
}

const MagickCore::ImageInfo *Magick::Image::constImageInfo(void) const
{
  return(_imgRef->options()->imageInfo());
}

Magick::Options *Magick::Image::options(void)
{
  return(_imgRef->options());
}

const Magick::Options *Magick::Image::constOptions(void) const
{
  return(_imgRef->options());
}

MagickCore::QuantizeInfo *Magick::Image::quantizeInfo(void)
{
  return(_imgRef->options()->quantizeInfo());
}

const MagickCore::QuantizeInfo *Magick::Image::constQuantizeInfo(void) const
{
  return(_imgRef->options()->quantizeInfo());
}

void Magick::Image::modifyImage(void)
{
  {
    Lock lock(&_imgRef->_mutexLock);
    if (_imgRef->_refCount == 1)
      return;
  }

  GetPPException;
  replaceImage(CloneImage(constImage(),0,0,MagickTrue,exceptionInfo));
  ThrowImageException;
  return;
}

MagickCore::Image *Magick::Image::replaceImage(MagickCore::Image *replacement_)
{
  MagickCore::Image
    *image;
  
  if (replacement_)
    image=replacement_;
  else
    image=AcquireImage(constImageInfo());

  {
    Lock lock(&_imgRef->_mutexLock);

    if (_imgRef->_refCount == 1)
      {
        // We own the image, just replace it, and de-register
        _imgRef->image(image);
      }
    else
      {
        // We don't own the image, dereference and replace with copy
        --_imgRef->_refCount;
        _imgRef=new ImageRef(image,constOptions());
      }
  }

  return(_imgRef->_image);
}

void Magick::Image::throwImageException(void) const
{
  // Throw C++ exception while resetting Image exception to default state
  throwException(&const_cast<MagickCore::Image*>(constImage())->exception,
    quiet());
}

void Magick::Image::read(MagickCore::Image *image,
  MagickCore::ExceptionInfo *exceptionInfo)
{
  // 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);
      throwExceptionExplicit(ImageWarning,"No image was loaded.");
    }
  ThrowImageException;
  if (image != (MagickCore::Image *) NULL)
    throwException(&image->exception,quiet());
}

void Magick::Image::floodFill(const ssize_t x_,const ssize_t y_,
  const Magick::Image *fillPattern_,const Magick::Color &fill_,
  const MagickCore::PixelPacket *target_,const bool invert_)
{
  Magick::Color
    fillColor;

  MagickCore::Image
    *fillPattern;

  MagickPixelPacket
    target;

  // 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());

  GetMagickPixelPacket(image(),&target);
  target.red=target_->red;
  target.green=target_->green;
  target.blue=target_->blue;

  (void) FloodfillPaintImage(image(),DefaultChannels,options()->drawInfo(),
    &target,static_cast<ssize_t>(x_),static_cast<ssize_t>(y_),
    (MagickBooleanType) invert_);

  options()->fillColor(fillColor);
  options()->fillPattern(fillPattern);
  throwImageException();
}

/* [<][>][^][v][top][bottom][index][help] */