| Server IP : 170.10.162.208 / Your IP : 216.73.216.181 Web Server : LiteSpeed System : Linux altar19.supremepanel19.com 4.18.0-553.69.1.lve.el8.x86_64 #1 SMP Wed Aug 13 19:53:59 UTC 2025 x86_64 User : deltahospital ( 1806) PHP Version : 7.4.33 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : OFF | Pkexec : OFF Directory : /home/deltahospital/test.delta-hospital.com/ |
Upload File : |
Magick++/ChannelMoments.h 0000644 00000004171 15051111170 0011144 0 ustar 00 // This may look like C code, but it is really -*- C++ -*-
//
// Copyright Dirk Lemstra 2014-2015
//
// Definition of channel moments.
//
#if !defined (Magick_ChannelMoments_header)
#define Magick_ChannelMoments_header
#include "Magick++/Include.h"
#include <vector>
namespace Magick
{
class Image;
class MagickPPExport ChannelMoments
{
public:
// Default constructor
ChannelMoments(void);
// Copy constructor
ChannelMoments(const ChannelMoments &channelMoments_);
// Destroy channel moments
~ChannelMoments(void);
//
// Implemementation methods
//
ChannelMoments(const ChannelType channel_,
const MagickCore::ChannelMoments *channelMoments_);
// X position of centroid
double centroidX(void) const;
// Y position of centroid
double centroidY(void) const;
// The channel
ChannelType channel(void) const;
// X position of ellipse axis
double ellipseAxisX(void) const;
// Y position of ellipse axis
double ellipseAxisY(void) const;
// Ellipse angle
double ellipseAngle(void) const;
// Ellipse eccentricity
double ellipseEccentricity(void) const;
// Ellipse intensity
double ellipseIntensity(void) const;
// Hu invariants (valid range for index is 0-7)
double huInvariants(const size_t index_) const;
private:
std::vector<double> _huInvariants;
ChannelType _channel;
double _centroidX;
double _centroidY;
double _ellipseAxisX;
double _ellipseAxisY;
double _ellipseAngle;
double _ellipseEccentricity;
double _ellipseIntensity;
};
class MagickPPExport ImageMoments
{
public:
// Default constructor
ImageMoments(void);
// Copy constructor
ImageMoments(const ImageMoments &imageMoments_);
// Destroy image moments
~ImageMoments(void);
// Returns the moments for the specified channel
ChannelMoments channel(const ChannelType channel_=CompositeChannels) const;
//
// Implemementation methods
//
ImageMoments(const Image &image_);
private:
std::vector<ChannelMoments> _channels;
};
}
#endif // Magick_ChannelMoments_header
Magick++/ResourceLimits.h 0000644 00000004722 15051111170 0011204 0 ustar 00 // This may look like C code, but it is really -*- C++ -*-
//
// Copyright Dirk Lemstra 2014-2018
//
// Definition of resource limits.
//
#if !defined(Magick_ResourceLimits_header)
#define Magick_ResourceLimits_header
#include "Magick++/Include.h"
namespace Magick
{
class MagickPPExport ResourceLimits
{
public:
// Pixel cache limit in bytes. Requests for memory above this limit
// are automagically allocated on disk.
static void area(const MagickSizeType limit_);
static MagickSizeType area(void);
// Pixel cache limit in bytes. Requests for memory above this limit
// will fail.
static void disk(const MagickSizeType limit_);
static MagickSizeType disk(void);
// The maximum number of open pixel cache files. When this limit is
// exceeded, any subsequent pixels cached to disk are closed and reopened
// on demand. This behavior permits a large number of images to be accessed
// simultaneously on disk, but with a speed penalty due to repeated
// open/close calls.
static void file(const MagickSizeType limit_);
static MagickSizeType file(void);
// The maximum height of an image.
static void height(const MagickSizeType limit_);
static MagickSizeType height(void);
// The maximum number of images in an image list.
static void listLength(const MagickSizeType limit_);
static MagickSizeType listLength();
// Pixel cache limit in bytes. Once this memory limit is exceeded,
// all subsequent pixels cache operations are to/from disk.
static void map(const MagickSizeType limit_);
static MagickSizeType map(void);
// Pixel cache limit in bytes. Once this memory limit is exceeded,
// all subsequent pixels cache operations are to/from disk or to/from
// memory mapped files.
static void memory(const MagickSizeType limit_);
static MagickSizeType memory(void);
// Limits the number of threads used in multithreaded operations.
static void thread(const MagickSizeType limit_);
static MagickSizeType thread(void);
// Periodically yield the CPU for at least the time specified in
// milliseconds.
static void throttle(const MagickSizeType limit_);
static MagickSizeType throttle(void);
// The maximum width of an image.
static void width(const MagickSizeType limit_);
static MagickSizeType width(void);
private:
ResourceLimits(void);
}; // class ResourceLimits
} // Magick namespace
#endif // Magick_ResourceLimits_header
Magick++/Pixels.h 0000644 00000007475 15051111170 0007507 0 ustar 00 // This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002
// Copyright Dirk Lemstra 2014
//
// Representation of a pixel view.
//
#if !defined(Magick_Pixels_header)
#define Magick_Pixels_header
#include "Magick++/Include.h"
#include "Magick++/Color.h"
#include "Magick++/Image.h"
namespace Magick
{
class MagickPPExport Pixels
{
public:
// Construct pixel view using specified image.
Pixels(Magick::Image &image_);
// Destroy pixel view
~Pixels(void);
// Transfer pixels from the image to the pixel view as defined by
// the specified region. Modified pixels may be subsequently
// transferred back to the image via sync.
PixelPacket *get(const ::ssize_t x_, const ::ssize_t y_,
const size_t columns_,const size_t rows_ );
// Transfer read-only pixels from the image to the pixel view as
// defined by the specified region.
const PixelPacket *getConst(const ::ssize_t x_,const ::ssize_t y_,
const size_t columns_,const size_t rows_);
// Allocate a pixel view region to store image pixels as defined
// by the region rectangle. This area is subsequently transferred
// from the pixel view to the image via sync.
PixelPacket *set(const ::ssize_t x_,const ::ssize_t y_,
const size_t columns_,const size_t rows_);
// Transfers the image view pixels to the image.
void sync(void);
// Width of view
size_t columns(void) const;
// Return pixel colormap index array
IndexPacket *indexes(void);
// Height of view
size_t rows (void) const;
// Left ordinate of view
::ssize_t x(void) const;
// Top ordinate of view
::ssize_t y(void) const;
private:
// Copying and assigning Pixels is not supported.
Pixels(const Pixels& pixels_);
const Pixels& operator=(const Pixels& pixels_);
Magick::Image _image; // Image reference
MagickCore::CacheView *_view; // Image view handle
::ssize_t _x; // Left ordinate of view
::ssize_t _y; // Top ordinate of view
size_t _columns; // Width of view
size_t _rows; // Height of view
}; // class Pixels
class MagickPPExport PixelData
{
public:
// Construct pixel data using specified image
PixelData(Magick::Image &image_,std::string map_,const StorageType type_);
// Construct pixel data using specified image
PixelData(Magick::Image &image_,const ::ssize_t x_,const ::ssize_t y_,
const size_t width_,const size_t height_,std::string map_,
const StorageType type_);
// Destroy pixel data
~PixelData(void);
// Pixel data buffer
const void *data(void) const;
// Length of the buffer
::ssize_t length(void) const;
// Size of the buffer in bytes
::ssize_t size(void) const;
private:
// Copying and assigning PixelData is not supported
PixelData(const PixelData& pixels_);
const PixelData& operator=(const PixelData& pixels_);
void init(Magick::Image &image_,const ::ssize_t x_,const ::ssize_t y_,
const size_t width_,const size_t height_,std::string map_,
const StorageType type_);
void relinquish(void) throw();
void *_data; // The pixel data
::ssize_t _length; // Length of the data
::ssize_t _size; // Size of the data
}; // class PixelData
} // Magick namespace
//
// Inline methods
//
// Left ordinate of view
inline ::ssize_t Magick::Pixels::x(void) const
{
return _x;
}
// Top ordinate of view
inline ::ssize_t Magick::Pixels::y(void) const
{
return _y;
}
// Width of view
inline size_t Magick::Pixels::columns(void) const
{
return _columns;
}
// Height of view
inline size_t Magick::Pixels::rows(void) const
{
return _rows;
}
#endif // Magick_Pixels_header
Magick++/Geometry.h 0000644 00000017030 15051111170 0010022 0 ustar 00 // This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002
// Copyright Dirk Lemstra 2014
//
// Geometry Definition
//
// Representation of an ImageMagick geometry specification
// X11 geometry specification plus hints
#if !defined (Magick_Geometry_header)
#define Magick_Geometry_header
#include "Magick++/Include.h"
#include <string>
namespace Magick
{
class MagickPPExport Geometry;
// Compare two Geometry objects regardless of LHS/RHS
MagickPPExport int operator ==
(const Magick::Geometry& left_,const Magick::Geometry& right_);
MagickPPExport int operator !=
(const Magick::Geometry& left_,const Magick::Geometry& right_);
MagickPPExport int operator >
(const Magick::Geometry& left_,const Magick::Geometry& right_);
MagickPPExport int operator <
(const Magick::Geometry& left_,const Magick::Geometry& right_);
MagickPPExport int operator >=
(const Magick::Geometry& left_,const Magick::Geometry& right_);
MagickPPExport int operator <=
(const Magick::Geometry& left_,const Magick::Geometry& right_);
class MagickPPExport Geometry
{
public:
// Default constructor
Geometry();
// Construct Geometry from specified string
Geometry(const char *geometry_);
// Copy constructor
Geometry(const Geometry &geometry_);
// Construct Geometry from specified string
Geometry(const std::string &geometry_);
// Construct Geometry from specified dimensions
Geometry(size_t width_,size_t height_,::ssize_t xOff_=0,
::ssize_t yOff_=0,bool xNegative_=false,bool yNegative_=false);
// Destructor
~Geometry(void);
// Set via geometry string
const Geometry& operator=(const char *geometry_);
// Assignment operator
Geometry& operator=(const Geometry& Geometry_);
// Set via geometry string
const Geometry& operator=(const std::string &geometry_ );
// Return geometry string
operator std::string() const;
// Resize without preserving aspect ratio (!)
void aspect(bool aspect_);
bool aspect(void) const;
// Resize the image based on the smallest fitting dimension (^)
void fillArea(bool fillArea_);
bool fillArea(void) const;
// Resize if image is greater than size (>)
void greater(bool greater_);
bool greater(void) const;
// Height
void height(size_t height_);
size_t height(void) const;
// Does object contain valid geometry?
void isValid(bool isValid_);
bool isValid(void) const;
// Resize if image is less than size (<)
void less(bool less_);
bool less(void) const;
// Resize using a pixel area count limit (@)
void limitPixels(bool limitPixels_);
bool limitPixels(void) const;
// Width and height are expressed as percentages
void percent(bool percent_);
bool percent(void) const;
// Width
void width(size_t width_);
size_t width(void) const;
// Sign of X offset negative? (X origin at right)
void xNegative(bool xNegative_);
bool xNegative(void) const;
// X offset from origin
void xOff(::ssize_t xOff_);
::ssize_t xOff(void) const;
// Sign of Y offset negative? (Y origin at bottom)
void yNegative(bool yNegative_);
bool yNegative(void) const;
// Y offset from origin
void yOff(::ssize_t yOff_);
::ssize_t yOff(void) const;
//
// Public methods below this point are for Magick++ use only.
//
// Construct from RectangleInfo
Geometry(const MagickCore::RectangleInfo &rectangle_);
// Set via RectangleInfo
const Geometry& operator=(const MagickCore::RectangleInfo &rectangle_);
// Return an ImageMagick RectangleInfo struct
operator MagickCore::RectangleInfo() const;
private:
size_t _width;
size_t _height;
::ssize_t _xOff;
::ssize_t _yOff;
bool _xNegative;
bool _yNegative;
bool _isValid;
bool _percent; // Interpret width & height as percentages (%)
bool _aspect; // Force exact size (!)
bool _greater; // Resize only if larger than geometry (>)
bool _less; // Resize only if smaller than geometry (<)
bool _fillArea; // Resize the image based on the smallest fitting dimension (^)
bool _limitPixels; // Resize using a pixel area count limit (@)
};
class MagickPPExport Offset;
// Compare two Offset objects
MagickPPExport int operator ==
(const Magick::Offset& left_,const Magick::Offset& right_);
MagickPPExport int operator !=
(const Magick::Offset& left_,const Magick::Offset& right_);
class MagickPPExport Offset
{
public:
// Default constructor
Offset();
// Construct Offset from specified string
Offset(const char *offset_);
// Copy constructor
Offset(const Offset &offset_);
// Construct Offset from specified string
Offset(const std::string &offset_);
// Construct Offset from specified x and y
Offset(ssize_t x_,ssize_t y_);
// Destructor
~Offset(void);
// Set via offset string
const Offset& operator=(const char *offset_);
// Assignment operator
Offset& operator=(const Offset& offset_);
// Set via offset string
const Offset& operator=(const std::string &offset_);
// X offset from origin
ssize_t x(void) const;
// Y offset from origin
ssize_t y(void) const;
//
// Public methods below this point are for Magick++ use only.
//
// Return an ImageMagick OffsetInfo struct
operator MagickCore::OffsetInfo() const;
private:
ssize_t _x;
ssize_t _y;
};
} // namespace Magick
//
// Inlines
//
inline void Magick::Geometry::aspect(bool aspect_)
{
_aspect=aspect_;
}
inline bool Magick::Geometry::aspect(void) const
{
return(_aspect);
}
inline void Magick::Geometry::fillArea(bool fillArea_)
{
_fillArea=fillArea_;
}
inline bool Magick::Geometry::fillArea(void) const
{
return(_fillArea);
}
inline void Magick::Geometry::greater(bool greater_)
{
_greater=greater_;
}
inline bool Magick::Geometry::greater(void) const
{
return(_greater);
}
inline void Magick::Geometry::height(size_t height_)
{
_height=height_;
}
inline size_t Magick::Geometry::height(void) const
{
return(_height);
}
inline void Magick::Geometry::isValid(bool isValid_)
{
_isValid=isValid_;
}
inline bool Magick::Geometry::isValid(void) const
{
return(_isValid);
}
inline void Magick::Geometry::less(bool less_)
{
_less=less_;
}
inline bool Magick::Geometry::less(void) const
{
return(_less);
}
inline void Magick::Geometry::limitPixels(bool limitPixels_)
{
_limitPixels=limitPixels_;
}
inline bool Magick::Geometry::limitPixels(void) const
{
return(_limitPixels);
}
inline void Magick::Geometry::width(size_t width_)
{
_width=width_;
isValid(true);
}
inline void Magick::Geometry::percent(bool percent_)
{
_percent = percent_;
}
inline bool Magick::Geometry::percent(void) const
{
return(_percent);
}
inline size_t Magick::Geometry::width(void) const
{
return(_width);
}
inline void Magick::Geometry::xNegative(bool xNegative_)
{
_xNegative=xNegative_;
}
inline bool Magick::Geometry::xNegative(void) const
{
return(_xNegative);
}
inline void Magick::Geometry::xOff(::ssize_t xOff_)
{
_xOff=xOff_;
}
inline ::ssize_t Magick::Geometry::xOff(void) const
{
return(_xOff);
}
inline void Magick::Geometry::yNegative(bool yNegative_)
{
_yNegative=yNegative_;
}
inline bool Magick::Geometry::yNegative(void) const
{
return(_yNegative);
}
inline void Magick::Geometry::yOff(::ssize_t yOff_)
{
_yOff=yOff_;
}
inline ::ssize_t Magick::Geometry::yOff(void) const
{
return(_yOff);
}
#endif // Magick_Geometry_header
Magick++/Color.h 0000644 00000027611 15051111170 0007313 0 ustar 00 // This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003, 2008
//
// Color Implementation
//
#if !defined (Magick_Color_header)
#define Magick_Color_header
#include "Magick++/Include.h"
#include <string>
namespace Magick
{
class MagickPPExport Color;
// Compare two Color objects regardless of LHS/RHS
MagickPPExport int operator ==
(const Magick::Color &left_,const Magick::Color &right_);
MagickPPExport int operator !=
(const Magick::Color &left_,const Magick::Color &right_);
MagickPPExport int operator >
(const Magick::Color &left_,const Magick::Color &right_);
MagickPPExport int operator <
(const Magick::Color &left_,const Magick::Color &right_);
MagickPPExport int operator >=
(const Magick::Color &left_,const Magick::Color &right_);
MagickPPExport int operator <=
(const Magick::Color &left_,const Magick::Color &right_);
// Base color class stores RGB components scaled to fit Quantum
class MagickPPExport Color
{
public:
// Default constructor
Color(void);
// Construct Color using the specified RGB values
Color(Magick::Quantum red_,Magick::Quantum green_,Magick::Quantum blue_);
// Construct Color using the specified RGBA values
Color(Magick::Quantum red_,Magick::Quantum green_,Magick::Quantum blue_,Magick::Quantum alpha_);
// Construct Color using the specified color string
Color(const char *x11color_);
// Copy constructor
Color(const Color &color_);
// Construct color via ImageMagick PixelPacket
Color(const PixelPacket &color_);
// Constructor Color using the specified color string
Color(const std::string &x11color_);
// Destructor
virtual ~Color(void);
// Assignment operator
Color& operator=(const Color& color_);
// Set color via X11 color specification string
const Color& operator=(const char *x11color);
// Set color via X11 color specification string
const Color& operator=(const std::string &x11color_);
// Set color via ImageMagick PixelPacket
const Color& operator=(const PixelPacket &color_);
// Return ImageMagick PixelPacket
operator PixelPacket() const;
// Return X11 color specification string
operator std::string() const;
// Scaled (to 1.0) version of alpha for use in sub-classes
// (range opaque=0 to transparent=1.0)
void alpha(double alpha_);
double alpha(void) const;
// Alpha level (range OpaqueOpacity=0 to TransparentOpacity=QuantumRange)
void alphaQuantum(Quantum alpha_);
Quantum alphaQuantum(void) const;
// Blue color (range 0 to QuantumRange)
void blueQuantum(Quantum blue_);
Quantum blueQuantum (void) const;
// Green color (range 0 to QuantumRange)
void greenQuantum(Quantum green_);
Quantum greenQuantum(void) const;
// Does object contain valid color?
void isValid(bool valid_);
bool isValid(void) const;
// Red color (range 0 to QuantumRange)
void redQuantum(Quantum red_);
Quantum redQuantum (void) const;
//
// Public methods beyond this point are for Magick++ use only.
//
// Obtain pixel intensity as a double
double intensity(void) const
{
return (0.299*(_pixel->red)+0.587*(_pixel->green)+0.114*(_pixel->blue));
}
// Scale a value expressed as a double (0-1) to Quantum range (0-QuantumRange)
static Quantum scaleDoubleToQuantum(const double double_)
{
return (static_cast<Magick::Quantum>(double_*QuantumRange));
}
// Scale a value expressed as a Quantum (0-QuantumRange) to double range (0-1)
#if (MAGICKCORE_QUANTUM_DEPTH < 32) && (MAGICKCORE_SIZEOF_FLOAT_T != MAGICKCORE_SIZEOF_DOUBLE || !defined(MAGICKCORE_HDRI_SUPPORT))
static double scaleQuantumToDouble(const Quantum quantum_)
{
return (static_cast<double>(quantum_)/QuantumRange);
}
#else
static double scaleQuantumToDouble(const double quantum_)
{
return (quantum_/QuantumRange);
}
#endif
protected:
// PixelType specifies the interpretation of PixelPacket members
// RGBPixel:
// Red = red;
// Green = green;
// Blue = blue;
// RGBAPixel:
// Red = red;
// Green = green;
// Blue = blue;
// Alpha = opacity;
// CYMKPixel:
// Cyan = red
// Yellow = green
// Magenta = blue
// Black(K) = opacity
enum PixelType
{
RGBPixel,
RGBAPixel,
CYMKPixel
};
// Constructor to construct with PixelPacket*
// Used to point Color at a pixel in an image
Color(PixelPacket *rep_,PixelType pixelType_);
// Set pixel
// Used to point Color at a pixel in an image
void pixel(PixelPacket *rep_,PixelType pixelType_);
// PixelPacket represents a color pixel:
// red = red (range 0 to QuantumRange)
// green = green (range 0 to QuantumRange)
// blue = blue (range 0 to QuantumRange)
// opacity = alpha (range OpaqueOpacity=0 to TransparentOpacity=QuantumRange)
// index = PseudoColor colormap index
PixelPacket *_pixel;
private:
bool _isValid; // Set true if pixel is "valid"
bool _pixelOwn; // Set true if we allocated pixel
PixelType _pixelType; // Color type supported by _pixel
// Common initializer for PixelPacket representation
void initPixel();
};
//
// Grayscale RGB color
//
// Grayscale is simply RGB with equal parts of red, green, and blue
// All double arguments have a valid range of 0.0 - 1.0.
class MagickPPExport ColorGray : public Color
{
public:
// Default constructor
ColorGray(void);
// Copy constructor
ColorGray(const Color & color_);
// Construct ColorGray using the specified shade
ColorGray(double shade_);
// Destructor
~ColorGray();
void shade(double shade_);
double shade(void) const;
// Assignment operator from base class
ColorGray& operator=(const Color& color_);
protected:
// Constructor to construct with PixelPacket*
ColorGray(PixelPacket *rep_,PixelType pixelType_);
};
//
// HSL Colorspace colors
//
class MagickPPExport ColorHSL: public Color
{
public:
// Default constructor
ColorHSL(void);
// Copy constructor
ColorHSL(const Color &color_);
// Construct ColorHSL using the specified HSL values
ColorHSL(double hue_,double saturation_,double luminosity_);
// Destructor
~ColorHSL();
// Assignment operator from base class
ColorHSL& operator=(const Color& color_);
// Hue color
void hue(double hue_);
double hue(void) const;
// Luminosity color
void luminosity(double luminosity_);
double luminosity(void) const;
// Saturation color
void saturation(double saturation_);
double saturation(void) const;
protected:
// Constructor to construct with PixelPacket*
ColorHSL(PixelPacket *rep_,PixelType pixelType_);
};
//
// Monochrome color
//
// Color arguments are constrained to 'false' (black pixel) and 'true'
// (white pixel)
class MagickPPExport ColorMono : public Color
{
public:
// Default constructor
ColorMono(void);
// Construct ColorMono (false=black, true=white)
ColorMono(bool mono_);
// Copy constructor
ColorMono(const Color & color_);
// Destructor
~ColorMono();
// Assignment operator from base class
ColorMono& operator=(const Color& color_);
// Mono color
void mono(bool mono_);
bool mono(void) const;
protected:
// Constructor to construct with PixelPacket*
ColorMono(PixelPacket *rep_,PixelType pixelType_);
};
//
// RGB color
//
// All color arguments have a valid range of 0.0 - 1.0.
class MagickPPExport ColorRGB: public Color
{
public:
// Default constructor
ColorRGB(void);
// Copy constructor
ColorRGB(const Color &color_);
// Construct ColorRGB using the specified RGB values
ColorRGB(double red_,double green_,double blue_);
// Destructor
~ColorRGB(void);
// Assignment operator from base class
ColorRGB& operator=(const Color& color_);
// Blue color
void blue(double blue_);
double blue(void) const;
// Green color
void green(double green_);
double green(void) const;
// Red color
void red(double red_);
double red(void) const;
protected:
// Constructor to construct with PixelPacket*
ColorRGB(PixelPacket *rep_,PixelType pixelType_);
};
//
// YUV Colorspace color
//
// Argument ranges:
// Y: 0.0 through 1.0
// U: -0.5 through 0.5
// V: -0.5 through 0.5
class MagickPPExport ColorYUV: public Color
{
public:
// Default constructor
ColorYUV(void);
// Copy constructor
ColorYUV(const Color &color_);
// Construct ColorYUV using the specified YUV values
ColorYUV(double y_,double u_,double v_);
// Destructor
~ColorYUV(void);
// Assignment operator from base class
ColorYUV& operator=(const Color& color_);
// Color U (0.0 through 1.0)
void u(double u_);
double u(void) const;
// Color V (-0.5 through 0.5)
void v(double v_);
double v(void) const;
// Color Y (-0.5 through 0.5)
void y(double y_);
double y(void) const;
protected:
// Constructor to construct with PixelInfo*
ColorYUV(PixelPacket *rep_,PixelType pixelType_);
};
} // namespace Magick
//
// Inlines
//
//
// Color
//
inline void Magick::Color::alpha(double alpha_)
{
alphaQuantum(scaleDoubleToQuantum(alpha_));
}
inline double Magick::Color::alpha(void) const
{
return scaleQuantumToDouble(alphaQuantum());
}
inline void Magick::Color::alphaQuantum(Magick::Quantum alpha_)
{
_pixel->opacity=alpha_;
_isValid=true ;
}
inline Magick::Quantum Magick::Color::alphaQuantum(void) const
{
return _pixel->opacity;
}
inline void Magick::Color::blueQuantum(Magick::Quantum blue_)
{
_pixel->blue=blue_;
_isValid=true;
}
inline Magick::Quantum Magick::Color::blueQuantum(void) const
{
return _pixel->blue;
}
inline void Magick::Color::greenQuantum(Magick::Quantum green_)
{
_pixel->green=green_;
_isValid=true;
}
inline Magick::Quantum Magick::Color::greenQuantum(void) const
{
return _pixel->green;
}
inline void Magick::Color::redQuantum(Magick::Quantum red_)
{
_pixel->red=red_;
_isValid=true;
}
inline Magick::Quantum Magick::Color::redQuantum(void) const
{
return _pixel->red;
}
inline void Magick::Color::initPixel()
{
_pixel->red=0;
_pixel->green=0;
_pixel->blue=0;
_pixel->opacity=TransparentOpacity;
}
inline Magick::Color::operator MagickCore::PixelPacket() const
{
return *_pixel;
}
//
// ColorGray
//
inline Magick::ColorGray::ColorGray(Magick::PixelPacket *rep_,
Magick::Color::PixelType pixelType_)
: Color(rep_,pixelType_)
{
}
//
// ColorHSL
//
inline Magick::ColorHSL::ColorHSL(Magick::PixelPacket *rep_,
Magick::Color::PixelType pixelType_)
: Color(rep_,pixelType_)
{
}
//
// ColorMono
//
inline Magick::ColorMono::ColorMono(Magick::PixelPacket *rep_,
Magick::Color::PixelType pixelType_)
: Color(rep_,pixelType_)
{
}
//
// ColorRGB
//
inline Magick::ColorRGB::ColorRGB(Magick::PixelPacket *rep_,
Magick::Color::PixelType pixelType_)
: Color(rep_,pixelType_)
{
}
inline void Magick::ColorRGB::blue(double blue_)
{
blueQuantum(scaleDoubleToQuantum(blue_));
}
inline double Magick::ColorRGB::blue(void) const
{
return scaleQuantumToDouble(blueQuantum());
}
inline void Magick::ColorRGB::green(double green_)
{
greenQuantum(scaleDoubleToQuantum(green_));
}
inline double Magick::ColorRGB::green(void) const
{
return scaleQuantumToDouble(greenQuantum());
}
inline void Magick::ColorRGB::red(double red_)
{
redQuantum(scaleDoubleToQuantum(red_));
}
inline double Magick::ColorRGB::red(void) const
{
return scaleQuantumToDouble(redQuantum());
}
//
// ColorYUV
//
inline Magick::ColorYUV::ColorYUV(Magick::PixelPacket *rep_,
Magick::Color::PixelType pixelType_)
: Color(rep_,pixelType_)
{
}
#endif // Magick_Color_header
Magick++/Blob.h 0000644 00000004407 15051111170 0007111 0 ustar 00 // This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002
// Copyright Dirk Lemstra 2015
//
// Reference counted container class for Binary Large Objects (BLOBs)
//
#if !defined(Magick_BlobRef_header)
#define Magick_BlobRef_header
#include "Magick++/Include.h"
#include <string>
namespace Magick
{
// Forward decl
class BlobRef;
class MagickPPExport Blob
{
public:
enum Allocator
{
MallocAllocator,
NewAllocator
};
// Default constructor
Blob(void);
// Construct object with data, making a copy of the supplied data.
Blob(const void* data_,const size_t length_);
// Copy constructor (reference counted)
Blob(const Blob& blob_);
// Destructor (reference counted)
virtual ~Blob();
// Assignment operator (reference counted)
Blob& operator=(const Blob& blob_ );
// Update object contents from Base64-encoded string representation.
void base64(const std::string base64_);
// Return Base64-encoded string representation.
std::string base64(void);
// Obtain pointer to data. The user should never try to modify or
// free this data since the Blob class manages its own data. The
// user must be finished with the data before allowing the Blob to
// be destroyed since the pointer is invalid once the Blob is
// destroyed.
const void* data(void) const;
// Obtain data length
size_t length(void) const;
// Update object contents, making a copy of the supplied data.
// Any existing data in the object is deallocated.
void update(const void* data_,const size_t length_);
// Update object contents, using supplied pointer directly (no
// copy). Any existing data in the object is deallocated. The user
// must ensure that the pointer supplied is not deleted or
// otherwise modified after it has been supplied to this method.
// Specify allocator_ as "MallocAllocator" if memory is allocated
// via the C language malloc() function, or "NewAllocator" if
// memory is allocated via C++ 'new'.
void updateNoCopy(void* data_,const size_t length_,
Allocator allocator_=NewAllocator);
private:
BlobRef *_blobRef;
};
} // namespace Magick
#endif // Magick_BlobRef_header
Magick++/Montage.h 0000644 00000017040 15051111170 0007622 0 ustar 00 // This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003
//
// Definition of Montage class used to specify montage options.
//
#if !defined(Magick_Montage_header)
#define Magick_Montage_header
#include "Magick++/Include.h"
#include <string>
#include "Magick++/Color.h"
#include "Magick++/Geometry.h"
//
// Basic (Un-framed) Montage
//
namespace Magick
{
class MagickPPExport Montage
{
public:
Montage(void);
virtual ~Montage(void);
// Color that thumbnails are composed on
void backgroundColor(const Color &backgroundColor_);
Color backgroundColor(void) const;
// Composition algorithm to use (e.g. ReplaceCompositeOp)
void compose(CompositeOperator compose_);
CompositeOperator compose(void) const;
// Filename to save montages to
void fileName(const std::string &fileName_);
std::string fileName(void) const;
// Fill color
void fillColor(const Color &fill_);
Color fillColor(void) const;
// Label font
void font(const std::string &font_);
std::string font(void) const;
// Thumbnail width & height plus border width & height
void geometry(const Geometry &geometry_);
Geometry geometry(void) const;
// Thumbnail position (e.g. SouthWestGravity)
void gravity(GravityType gravity_);
GravityType gravity(void) const;
// Thumbnail label (applied to image prior to montage)
void label(const std::string &label_);
std::string label(void) const;
// Same as fill color
void penColor(const Color &pen_);
Color penColor(void) const;
// Font point size
void pointSize(size_t pointSize_);
size_t pointSize(void) const;
// Enable drop-shadows on thumbnails
void shadow(bool shadow_);
bool shadow(void) const;
// Outline color
void strokeColor(const Color &stroke_);
Color strokeColor(void) const;
// Background texture image
void texture(const std::string &texture_);
std::string texture(void) const;
// Thumbnail rows and columns
void tile(const Geometry &tile_);
Geometry tile(void) const;
// Montage title
void title(const std::string &title_);
std::string title(void) const;
// Transparent color
void transparentColor(const Color &transparentColor_);
Color transparentColor(void) const;
//
// Implementation methods/members
//
// Update elements in existing MontageInfo structure
virtual void updateMontageInfo(MagickCore::MontageInfo &montageInfo_) const;
private:
Color _backgroundColor;
CompositeOperator _compose;
std::string _fileName;
Color _fill;
std::string _font;
Geometry _geometry;
GravityType _gravity;
std::string _label;
size_t _pointSize;
bool _shadow;
Color _stroke;
std::string _texture;
Geometry _tile;
std::string _title;
Color _transparentColor;
};
//
// Montage With Frames (Extends Basic Montage)
//
class MagickPPExport MontageFramed : public Montage
{
public:
MontageFramed(void);
~MontageFramed(void);
// Frame border color
void borderColor(const Color &borderColor_);
Color borderColor(void) const;
// Pixels between thumbnail and surrounding frame
void borderWidth(size_t borderWidth_);
size_t borderWidth(void) const;
// Frame geometry (width & height frame thickness)
void frameGeometry(const Geometry &frame_);
Geometry frameGeometry(void) const;
// Frame foreground color
void matteColor(const Color &matteColor_);
Color matteColor(void) const;
//
// Implementation methods/members
//
// Update elements in existing MontageInfo structure
void updateMontageInfo(MagickCore::MontageInfo &montageInfo_) const;
private:
Color _borderColor;
size_t _borderWidth;
Geometry _frame;
Color _matteColor;
};
} // namespace Magick
//
// Inlines
//
//
// Implementation of Montage
//
inline void Magick::Montage::backgroundColor(const Magick::Color &backgroundColor_)
{
_backgroundColor=backgroundColor_;
}
inline Magick::Color Magick::Montage::backgroundColor(void) const
{
return(_backgroundColor);
}
inline void Magick::Montage::compose(Magick::CompositeOperator compose_)
{
_compose=compose_;
}
inline Magick::CompositeOperator Magick::Montage::compose(void) const
{
return(_compose);
}
inline void Magick::Montage::fileName(const std::string &fileName_)
{
_fileName=fileName_;
}
inline std::string Magick::Montage::fileName(void) const
{
return(_fileName);
}
inline void Magick::Montage::fillColor(const Color &fill_)
{
_fill=fill_;
}
inline Magick::Color Magick::Montage::fillColor(void) const
{
return(_fill);
}
inline void Magick::Montage::font(const std::string &font_)
{
_font=font_;
}
inline std::string Magick::Montage::font(void) const
{
return(_font);
}
inline void Magick::Montage::geometry(const Magick::Geometry &geometry_)
{
_geometry=geometry_;
}
inline Magick::Geometry Magick::Montage::geometry(void) const
{
return(_geometry);
}
inline void Magick::Montage::gravity(Magick::GravityType gravity_)
{
_gravity=gravity_;
}
inline Magick::GravityType Magick::Montage::gravity(void) const
{
return(_gravity);
}
inline void Magick::Montage::label(const std::string &label_)
{
_label=label_;
}
inline std::string Magick::Montage::label(void) const
{
return(_label);
}
inline void Magick::Montage::penColor(const Color &pen_)
{
_fill=pen_;
_stroke=Color("none");
}
inline Magick::Color Magick::Montage::penColor(void) const
{
return _fill;
}
inline void Magick::Montage::pointSize(size_t pointSize_)
{
_pointSize=pointSize_;
}
inline size_t Magick::Montage::pointSize(void) const
{
return(_pointSize);
}
inline void Magick::Montage::shadow(bool shadow_)
{
_shadow=shadow_;
}
inline bool Magick::Montage::shadow(void) const
{
return(_shadow);
}
inline void Magick::Montage::strokeColor(const Color &stroke_)
{
_stroke=stroke_;
}
inline Magick::Color Magick::Montage::strokeColor(void) const
{
return(_stroke);
}
inline void Magick::Montage::texture(const std::string &texture_)
{
_texture=texture_;
}
inline std::string Magick::Montage::texture(void) const
{
return(_texture);
}
inline void Magick::Montage::tile(const Geometry &tile_)
{
_tile=tile_;
}
inline Magick::Geometry Magick::Montage::tile(void) const
{
return(_tile);
}
inline void Magick::Montage::title(const std::string &title_)
{
_title=title_;
}
inline std::string Magick::Montage::title(void) const
{
return(_title);
}
inline void Magick::Montage::transparentColor(const Magick::Color &transparentColor_)
{
_transparentColor=transparentColor_;
}
inline Magick::Color Magick::Montage::transparentColor(void) const
{
return(_transparentColor);
}
//
// Implementation of MontageFramed
//
inline void Magick::MontageFramed::borderColor(const Magick::Color &borderColor_)
{
_borderColor=borderColor_;
}
inline Magick::Color Magick::MontageFramed::borderColor(void) const
{
return(_borderColor);
}
inline void Magick::MontageFramed::borderWidth(size_t borderWidth_)
{
_borderWidth=borderWidth_;
}
inline size_t Magick::MontageFramed::borderWidth(void) const
{
return(_borderWidth);
}
inline void Magick::MontageFramed::frameGeometry(const Magick::Geometry &frame_)
{
_frame=frame_;
}
inline Magick::Geometry Magick::MontageFramed::frameGeometry(void) const
{
return(_frame);
}
inline void Magick::MontageFramed::matteColor(const Magick::Color &matteColor_)
{
_matteColor=matteColor_;
}
inline Magick::Color Magick::MontageFramed::matteColor(void) const
{
return(_matteColor);
}
#endif // Magick_Montage_header
Magick++/Exception.h 0000644 00000027125 15051111170 0010173 0 ustar 00 // This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003
// Copyright Dirk Lemstra 2014-2015
//
// Definition of Magick::Exception and derived classes
// Magick::Warning* and Magick::Error*. Derived from C++ STD
// 'exception' class for convenience.
//
// These classes form part of the Magick++ user interface.
//
#if !defined(Magick_Exception_header)
#define Magick_Exception_header
#include "Magick++/Include.h"
#include <string>
#include <exception>
namespace Magick
{
class MagickPPExport Exception: public std::exception
{
public:
// Construct with message string
Exception(const std::string& what_);
// Construct with message string and nested exception
Exception(const std::string& what_, Exception* nested_);
// Copy constructor
Exception(const Exception& original_);
// Destructor
virtual ~Exception() throw();
// Assignment operator
Exception& operator=(const Exception& original_);
// Get string identifying exception
virtual const char* what() const throw();
// Get nested exception
const Exception* nested() const throw();
//////////////////////////////////////////////////////////////////////
//
// No user-serviceable parts beyond this point
//
//////////////////////////////////////////////////////////////////////
void nested(Exception* nested_) throw();
private:
std::string _what;
Exception* _nested;
};
//
// Error exceptions
//
class MagickPPExport Error: public Exception
{
public:
explicit Error(const std::string& what_);
explicit Error(const std::string& what_,Exception *nested_);
~Error() throw();
};
class MagickPPExport ErrorBlob: public Error
{
public:
explicit ErrorBlob(const std::string& what_);
explicit ErrorBlob(const std::string& what_,Exception *nested_);
~ErrorBlob() throw();
};
class MagickPPExport ErrorCache: public Error
{
public:
explicit ErrorCache(const std::string& what_);
explicit ErrorCache(const std::string& what_,Exception *nested_);
~ErrorCache() throw();
};
class MagickPPExport ErrorCoder: public Error
{
public:
explicit ErrorCoder(const std::string& what_);
explicit ErrorCoder(const std::string& what_,Exception *nested_);
~ErrorCoder() throw();
};
class MagickPPExport ErrorConfigure: public Error
{
public:
explicit ErrorConfigure(const std::string& what_);
explicit ErrorConfigure(const std::string& what_,Exception *nested_);
~ErrorConfigure() throw();
};
class MagickPPExport ErrorCorruptImage: public Error
{
public:
explicit ErrorCorruptImage(const std::string& what_);
explicit ErrorCorruptImage(const std::string& what_,Exception *nested_);
~ErrorCorruptImage() throw();
};
class MagickPPExport ErrorDelegate: public Error
{
public:
explicit ErrorDelegate(const std::string& what_);
explicit ErrorDelegate(const std::string& what_,Exception *nested_);
~ErrorDelegate() throw();
};
class MagickPPExport ErrorDraw: public Error
{
public:
explicit ErrorDraw(const std::string& what_);
explicit ErrorDraw(const std::string& what_,Exception *nested_);
~ErrorDraw() throw();
};
class MagickPPExport ErrorFileOpen: public Error
{
public:
explicit ErrorFileOpen(const std::string& what_);
explicit ErrorFileOpen(const std::string& what_,Exception *nested_);
~ErrorFileOpen() throw();
};
class MagickPPExport ErrorImage: public Error
{
public:
explicit ErrorImage(const std::string& what_);
explicit ErrorImage(const std::string& what_,Exception *nested_);
~ErrorImage() throw();
};
class MagickPPExport ErrorMissingDelegate: public Error
{
public:
explicit ErrorMissingDelegate(const std::string& what_);
explicit ErrorMissingDelegate(const std::string& what_,Exception *nested_);
~ErrorMissingDelegate() throw();
};
class MagickPPExport ErrorModule: public Error
{
public:
explicit ErrorModule(const std::string& what_);
explicit ErrorModule(const std::string& what_,Exception *nested_);
~ErrorModule() throw();
};
class MagickPPExport ErrorMonitor: public Error
{
public:
explicit ErrorMonitor(const std::string& what_);
explicit ErrorMonitor(const std::string& what_,Exception *nested_);
~ErrorMonitor() throw();
};
class MagickPPExport ErrorOption: public Error
{
public:
explicit ErrorOption(const std::string& what_);
explicit ErrorOption(const std::string& what_,Exception *nested_);
~ErrorOption() throw();
};
class MagickPPExport ErrorPolicy: public Error
{
public:
explicit ErrorPolicy(const std::string& what_);
explicit ErrorPolicy(const std::string& what_,Exception *nested_);
~ErrorPolicy() throw();
};
class MagickPPExport ErrorRegistry: public Error
{
public:
explicit ErrorRegistry(const std::string& what_);
explicit ErrorRegistry(const std::string& what_,Exception *nested_);
~ErrorRegistry() throw();
};
class MagickPPExport ErrorResourceLimit: public Error
{
public:
explicit ErrorResourceLimit(const std::string& what_);
explicit ErrorResourceLimit(const std::string& what_,Exception *nested_);
~ErrorResourceLimit() throw();
};
class MagickPPExport ErrorStream: public Error
{
public:
explicit ErrorStream(const std::string& what_);
explicit ErrorStream(const std::string& what_,Exception *nested_);
~ErrorStream() throw();
};
class MagickPPExport ErrorType: public Error
{
public:
explicit ErrorType(const std::string& what_);
explicit ErrorType(const std::string& what_,Exception *nested_);
~ErrorType() throw();
};
class MagickPPExport ErrorUndefined: public Error
{
public:
explicit ErrorUndefined(const std::string& what_);
explicit ErrorUndefined(const std::string& what_,Exception *nested_);
~ErrorUndefined() throw();
};
class MagickPPExport ErrorXServer: public Error
{
public:
explicit ErrorXServer(const std::string& what_);
explicit ErrorXServer(const std::string& what_,Exception *nested_);
~ErrorXServer() throw();
};
//
// Warnings
//
class MagickPPExport Warning: public Exception
{
public:
explicit Warning(const std::string& what_);
explicit Warning(const std::string& what_,Exception *nested_);
~Warning() throw();
};
class MagickPPExport WarningBlob: public Warning
{
public:
explicit WarningBlob(const std::string& what_);
explicit WarningBlob(const std::string& what_,Exception *nested_);
~WarningBlob() throw();
};
class MagickPPExport WarningCache: public Warning
{
public:
explicit WarningCache(const std::string& what_);
explicit WarningCache(const std::string& what_,Exception *nested_);
~WarningCache() throw();
};
class MagickPPExport WarningCoder: public Warning
{
public:
explicit WarningCoder(const std::string& what_);
explicit WarningCoder(const std::string& what_,Exception *nested_);
~WarningCoder() throw();
};
class MagickPPExport WarningConfigure: public Warning
{
public:
explicit WarningConfigure(const std::string& what_);
explicit WarningConfigure(const std::string& what_,Exception *nested_);
~WarningConfigure() throw();
};
class MagickPPExport WarningCorruptImage: public Warning
{
public:
explicit WarningCorruptImage(const std::string& what_);
explicit WarningCorruptImage(const std::string& what_,Exception *nested_);
~WarningCorruptImage() throw();
};
class MagickPPExport WarningDelegate: public Warning
{
public:
explicit WarningDelegate(const std::string& what_);
explicit WarningDelegate(const std::string& what_,Exception *nested_);
~WarningDelegate() throw();
};
class MagickPPExport WarningDraw : public Warning
{
public:
explicit WarningDraw(const std::string& what_);
explicit WarningDraw(const std::string& what_,Exception *nested_);
~WarningDraw() throw();
};
class MagickPPExport WarningFileOpen: public Warning
{
public:
explicit WarningFileOpen(const std::string& what_);
explicit WarningFileOpen(const std::string& what_,Exception *nested_);
~WarningFileOpen() throw();
};
class MagickPPExport WarningImage: public Warning
{
public:
explicit WarningImage(const std::string& what_);
explicit WarningImage(const std::string& what_,Exception *nested_);
~WarningImage() throw();
};
class MagickPPExport WarningMissingDelegate: public Warning
{
public:
explicit WarningMissingDelegate(const std::string& what_);
explicit WarningMissingDelegate(const std::string& what_,
Exception *nested_);
~WarningMissingDelegate() throw();
};
class MagickPPExport WarningModule: public Warning
{
public:
explicit WarningModule(const std::string& what_);
explicit WarningModule(const std::string& what_,Exception *nested_);
~WarningModule() throw();
};
class MagickPPExport WarningMonitor: public Warning
{
public:
explicit WarningMonitor(const std::string& what_);
explicit WarningMonitor(const std::string& what_,Exception *nested_);
~WarningMonitor() throw();
};
class MagickPPExport WarningOption: public Warning
{
public:
explicit WarningOption(const std::string& what_);
explicit WarningOption(const std::string& what_,Exception *nested_);
~WarningOption() throw();
};
class MagickPPExport WarningPolicy: public Warning
{
public:
explicit WarningPolicy(const std::string& what_);
explicit WarningPolicy(const std::string& what_,Exception *nested_);
~WarningPolicy() throw();
};
class MagickPPExport WarningRegistry: public Warning
{
public:
explicit WarningRegistry(const std::string& what_);
explicit WarningRegistry(const std::string& what_,Exception *nested_);
~WarningRegistry() throw();
};
class MagickPPExport WarningResourceLimit: public Warning
{
public:
explicit WarningResourceLimit(const std::string& what_);
explicit WarningResourceLimit(const std::string& what_,Exception *nested_);
~WarningResourceLimit() throw();
};
class MagickPPExport WarningStream: public Warning
{
public:
explicit WarningStream(const std::string& what_);
explicit WarningStream(const std::string& what_,Exception *nested_);
~WarningStream() throw();
};
class MagickPPExport WarningType: public Warning
{
public:
explicit WarningType(const std::string& what_);
explicit WarningType(const std::string& what_,Exception *nested_);
~WarningType() throw();
};
class MagickPPExport WarningUndefined: public Warning
{
public:
explicit WarningUndefined(const std::string& what_);
explicit WarningUndefined(const std::string& what_,Exception *nested_);
~WarningUndefined() throw();
};
class MagickPPExport WarningXServer: public Warning
{
public:
explicit WarningXServer(const std::string& what_);
explicit WarningXServer(const std::string& what_,Exception *nested_);
~WarningXServer() throw();
};
//
// No user-serviceable components beyond this point.
//
std::string formatExceptionMessage(
const MagickCore::ExceptionInfo *exception_);
Exception* createException(const MagickCore::ExceptionInfo *exception_);
// Throw exception based on raw data
extern MagickPPExport void throwExceptionExplicit(
const MagickCore::ExceptionType severity_,const char* reason_,
const char* description_=(char *) NULL);
// Thow exception based on ImageMagick's ExceptionInfo
extern MagickPPExport void throwException(
MagickCore::ExceptionInfo *exception_,const bool quiet_=false);
} // namespace Magick
#endif // Magick_Exception_header
Magick++/TypeMetric.h 0000644 00000002463 15051111170 0010320 0 ustar 00 // This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 2001, 2002
// Copyright Dirk Lemstra 2014
//
// TypeMetric Definition
//
// Container for font type metrics
//
#if !defined (Magick_TypeMetric_header)
#define Magick_TypeMetric_header
#include "Magick++/Include.h"
namespace Magick
{
class MagickPPExport TypeMetric
{
friend class Image;
public:
// Default constructor
TypeMetric(void);
// Destructor
~TypeMetric(void);
// Ascent, the distance in pixels from the text baseline to the
// highest/upper grid coordinate used to place an outline point.
double ascent(void) const;
// Descent, the distance in pixels from the baseline to the lowest
// grid coordinate used to place an outline point. Always a
// negative value.
double descent(void) const;
// Maximum horizontal advance in pixels.
double maxHorizontalAdvance(void) const;
// Text height in pixels.
double textHeight(void) const;
// Text width in pixels.
double textWidth(void) const;
// Underline position.
double underlinePosition(void) const;
// Underline thickness.
double underlineThickness(void) const;
private:
MagickCore::TypeMetric _typeMetric;
};
} // namespace Magick
#endif // Magick_TypeMetric_header
Magick++/Functions.h 0000644 00000002174 15051111170 0010202 0 ustar 00 // This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2003
// Copyright Dirk Lemstra 2014
//
// Simple C++ function wrappers for often used or otherwise
// inconvenient ImageMagick equivalents
//
#if !defined(Magick_Functions_header)
#define Magick_Functions_header
#include "Magick++/Include.h"
#include <string>
namespace Magick
{
// Clone C++ string as allocated C string, de-allocating any existing string
MagickPPExport void CloneString(char **destination_,
const std::string &source_);
// Disable OpenCL acceleration (only works when build with OpenCL support)
MagickPPExport void DisableOpenCL(void);
// Enable OpenCL acceleration (only works when build with OpenCL support)
MagickPPExport bool EnableOpenCL(const bool useCache_=true);
// C library initialization routine
MagickPPExport void InitializeMagick(const char *path_);
// Seed a new sequence of pseudo-random numbers
MagickPPExport void SetRandomSeed(const unsigned long seed);
// C library initialization routine
MagickPPExport void TerminateMagick();
}
#endif // Magick_Functions_header
Magick++/STL.h 0000644 00000213346 15051111170 0006701 0 ustar 00 // This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003
// Copyright Dirk Lemstra 2013-2014
//
// Definition and implementation of template functions for using
// Magick::Image with STL containers.
//
#ifndef Magick_STL_header
#define Magick_STL_header
#include "Magick++/Include.h"
#include <algorithm>
#include <functional>
#include <iterator>
#include <map>
#include <utility>
#include "Magick++/CoderInfo.h"
#include "Magick++/Drawable.h"
#include "Magick++/Exception.h"
#include "Magick++/Montage.h"
namespace Magick
{
//
// STL function object declarations/definitions
//
// Function objects provide the means to invoke an operation on one
// or more image objects in an STL-compatable container. The
// arguments to the function object constructor(s) are compatable
// with the arguments to the equivalent Image class method and
// provide the means to supply these options when the function
// object is invoked.
// For example, to read a GIF animation, set the color red to
// transparent for all frames, and write back out:
//
// list<image> images;
// readImages( &images, "animation.gif" );
// for_each( images.begin(), images.end(), transparentImage( "red" ) );
// writeImages( images.begin(), images.end(), "animation.gif" );
// Adaptive-blur image with specified blur factor
class MagickPPExport adaptiveBlurImage
{
public:
adaptiveBlurImage( const double radius_ = 1, const double sigma_ = 0.5 );
void operator()( Image &image_ ) const;
private:
double _radius;
double _sigma;
};
// Local adaptive threshold image
// http://www.dai.ed.ac.uk/HIPR2/adpthrsh.htm
// Width x height define the size of the pixel neighborhood
// offset = constant to subtract from pixel neighborhood mean
class MagickPPExport adaptiveThresholdImage
{
public:
adaptiveThresholdImage( const size_t width_,
const size_t height_,
const ::ssize_t offset_ = 0 );
void operator()( Image &image_ ) const;
private:
size_t _width;
size_t _height;
::ssize_t _offset;
};
// Add noise to image with specified noise type
class MagickPPExport addNoiseImage
{
public:
addNoiseImage ( NoiseType noiseType_ );
void operator()( Image &image_ ) const;
private:
NoiseType _noiseType;
};
// Transform image by specified affine (or free transform) matrix.
class MagickPPExport affineTransformImage
{
public:
affineTransformImage( const DrawableAffine &affine_ );
void operator()( Image &image_ ) const;
private:
DrawableAffine _affine;
};
// Annotate image (draw text on image)
class MagickPPExport annotateImage
{
public:
// Annotate using specified text, and placement location
annotateImage ( const std::string &text_,
const Geometry &geometry_ );
// Annotate using specified text, bounding area, and placement
// gravity
annotateImage ( const std::string &text_,
const Geometry &geometry_,
const GravityType gravity_ );
// Annotate with text using specified text, bounding area,
// placement gravity, and rotation.
annotateImage ( const std::string &text_,
const Geometry &geometry_,
const GravityType gravity_,
const double degrees_ );
// Annotate with text (bounding area is entire image) and
// placement gravity.
annotateImage ( const std::string &text_,
const GravityType gravity_ );
void operator()( Image &image_ ) const;
private:
const std::string _text;
const Geometry _geometry;
const GravityType _gravity;
const double _degrees;
};
// Blur image with specified blur factor
class MagickPPExport blurImage
{
public:
blurImage( const double radius_ = 1, const double sigma_ = 0.5 );
void operator()( Image &image_ ) const;
private:
double _radius;
double _sigma;
};
// Border image (add border to image)
class MagickPPExport borderImage
{
public:
borderImage( const Geometry &geometry_ = borderGeometryDefault );
void operator()( Image &image_ ) const;
private:
Geometry _geometry;
};
// Extract channel from image
class MagickPPExport channelImage
{
public:
channelImage( const ChannelType channel_ );
void operator()( Image &image_ ) const;
private:
ChannelType _channel;
};
// Charcoal effect image (looks like charcoal sketch)
class MagickPPExport charcoalImage
{
public:
charcoalImage( const double radius_ = 1, const double sigma_ = 0.5 );
void operator()( Image &image_ ) const;
private:
double _radius;
double _sigma;
};
// Chop image (remove vertical or horizontal subregion of image)
class MagickPPExport chopImage
{
public:
chopImage( const Geometry &geometry_ );
void operator()( Image &image_ ) const;
private:
Geometry _geometry;
};
// Accepts a lightweight Color Correction Collection (CCC) file which solely
// contains one or more color corrections and applies the correction to the
// image.
class MagickPPExport cdlImage
{
public:
cdlImage( const std::string &cdl_ );
void operator()( Image &image_ ) const;
private:
std::string _cdl;
};
// Colorize image using pen color at specified percent opacity
class MagickPPExport colorizeImage
{
public:
colorizeImage( const unsigned int opacityRed_,
const unsigned int opacityGreen_,
const unsigned int opacityBlue_,
const Color &penColor_ );
colorizeImage( const unsigned int opacity_,
const Color &penColor_ );
void operator()( Image &image_ ) const;
private:
unsigned int _opacityRed;
unsigned int _opacityGreen;
unsigned int _opacityBlue;
Color _penColor;
};
// Apply a color matrix to the image channels. The user supplied
// matrix may be of order 1 to 5 (1x1 through 5x5).
class MagickPPExport colorMatrixImage
{
public:
colorMatrixImage( const size_t order_,
const double *color_matrix_ );
void operator()( Image &image_ ) const;
private:
size_t _order;
const double *_color_matrix;
};
// Convert the image colorspace representation
class MagickPPExport colorSpaceImage
{
public:
colorSpaceImage( ColorspaceType colorSpace_ );
void operator()( Image &image_ ) const;
private:
ColorspaceType _colorSpace;
};
// Comment image (add comment string to image)
class MagickPPExport commentImage
{
public:
commentImage( const std::string &comment_ );
void operator()( Image &image_ ) const;
private:
std::string _comment;
};
// Compose an image onto another at specified offset and using
// specified algorithm
class MagickPPExport compositeImage
{
public:
compositeImage( const Image &compositeImage_,
::ssize_t xOffset_,
::ssize_t yOffset_,
CompositeOperator compose_ = InCompositeOp );
compositeImage( const Image &compositeImage_,
const Geometry &offset_,
CompositeOperator compose_ = InCompositeOp );
void operator()( Image &image_ ) const;
private:
Image _compositeImage;
::ssize_t _xOffset;
::ssize_t _yOffset;
CompositeOperator _compose;
};
// Contrast image (enhance intensity differences in image)
class MagickPPExport contrastImage
{
public:
contrastImage( const size_t sharpen_ );
void operator()( Image &image_ ) const;
private:
size_t _sharpen;
};
// Crop image (subregion of original image)
class MagickPPExport cropImage
{
public:
cropImage( const Geometry &geometry_ );
void operator()( Image &image_ ) const;
private:
Geometry _geometry;
};
// Cycle image colormap
class MagickPPExport cycleColormapImage
{
public:
cycleColormapImage( const ::ssize_t amount_ );
void operator()( Image &image_ ) const;
private:
::ssize_t _amount;
};
// Despeckle image (reduce speckle noise)
class MagickPPExport despeckleImage
{
public:
despeckleImage( void );
void operator()( Image &image_ ) const;
private:
};
// Distort image. distorts an image using various distortion methods, by
// mapping color lookups of the source image to a new destination image
// usually of the same size as the source image, unless 'bestfit' is set to
// true.
class MagickPPExport distortImage
{
public:
distortImage( const Magick::DistortImageMethod method_,
const size_t number_arguments_,
const double *arguments_,
const bool bestfit_ );
distortImage( const Magick::DistortImageMethod method_,
const size_t number_arguments_,
const double *arguments_ );
void operator()( Image &image_ ) const;
private:
DistortImageMethod _method;
size_t _number_arguments;
const double *_arguments;
bool _bestfit;
};
// Draw on image
class MagickPPExport drawImage
{
public:
// Draw on image using a single drawable
// Store in list to make implementation easier
drawImage( const Drawable &drawable_ );
// Draw on image using a drawable list
drawImage( const DrawableList &drawable_ );
void operator()( Image &image_ ) const;
private:
DrawableList _drawableList;
};
// Edge image (highlight edges in image)
class MagickPPExport edgeImage
{
public:
edgeImage( const double radius_ = 0.0 );
void operator()( Image &image_ ) const;
private:
double _radius;
};
// Emboss image (highlight edges with 3D effect)
class MagickPPExport embossImage
{
public:
embossImage( void );
embossImage( const double radius_, const double sigma_ );
void operator()( Image &image_ ) const;
private:
double _radius;
double _sigma;
};
// Enhance image (minimize noise)
class MagickPPExport enhanceImage
{
public:
enhanceImage( void );
void operator()( Image &image_ ) const;
private:
};
// Equalize image (histogram equalization)
class MagickPPExport equalizeImage
{
public:
equalizeImage( void );
void operator()( Image &image_ ) const;
private:
};
// Color to use when filling drawn objects
class MagickPPExport fillColorImage
{
public:
fillColorImage( const Color &fillColor_ );
void operator()( Image &image_ ) const;
private:
Color _fillColor;
};
// Flip image (reflect each scanline in the vertical direction)
class MagickPPExport flipImage
{
public:
flipImage( void );
void operator()( Image &image_ ) const;
private:
};
// Flood-fill image with color
class MagickPPExport floodFillColorImage
{
public:
// Flood-fill color across pixels starting at target-pixel and
// stopping at pixels matching specified border color.
// Uses current fuzz setting when determining color match.
floodFillColorImage( const ::ssize_t x_,
const ::ssize_t y_,
const Color &fillColor_ );
floodFillColorImage( const Geometry &point_,
const Color &fillColor_ );
// Flood-fill color across pixels starting at target-pixel and
// stopping at pixels matching specified border color.
// Uses current fuzz setting when determining color match.
floodFillColorImage( const ::ssize_t x_,
const ::ssize_t y_,
const Color &fillColor_,
const Color &borderColor_ );
floodFillColorImage( const Geometry &point_,
const Color &fillColor_,
const Color &borderColor_ );
void operator()( Image &image_ ) const;
private:
::ssize_t _x;
::ssize_t _y;
Color _fillColor;
Color _borderColor;
};
// Flood-fill image with texture
class MagickPPExport floodFillTextureImage
{
public:
// Flood-fill texture across pixels that match the color of the
// target pixel and are neighbors of the target pixel.
// Uses current fuzz setting when determining color match.
floodFillTextureImage( const ::ssize_t x_,
const ::ssize_t y_,
const Image &texture_ );
floodFillTextureImage( const Geometry &point_,
const Image &texture_ );
// Flood-fill texture across pixels starting at target-pixel and
// stopping at pixels matching specified border color.
// Uses current fuzz setting when determining color match.
floodFillTextureImage( const ::ssize_t x_,
const ::ssize_t y_,
const Image &texture_,
const Color &borderColor_ );
floodFillTextureImage( const Geometry &point_,
const Image &texture_,
const Color &borderColor_ );
void operator()( Image &image_ ) const;
private:
::ssize_t _x;
::ssize_t _y;
Image _texture;
Color _borderColor;
};
// Flop image (reflect each scanline in the horizontal direction)
class MagickPPExport flopImage
{
public:
flopImage( void );
void operator()( Image &image_ ) const;
private:
};
// Frame image
class MagickPPExport frameImage
{
public:
frameImage( const Geometry &geometry_ = frameGeometryDefault );
frameImage( const size_t width_, const size_t height_,
const ::ssize_t innerBevel_ = 6, const ::ssize_t outerBevel_ = 6 );
void operator()( Image &image_ ) const;
private:
size_t _width;
size_t _height;
::ssize_t _outerBevel;
::ssize_t _innerBevel;
};
// Gamma correct image
class MagickPPExport gammaImage
{
public:
gammaImage( const double gamma_ );
gammaImage ( const double gammaRed_,
const double gammaGreen_,
const double gammaBlue_ );
void operator()( Image &image_ ) const;
private:
double _gammaRed;
double _gammaGreen;
double _gammaBlue;
};
// Gaussian blur image
// The number of neighbor pixels to be included in the convolution
// mask is specified by 'width_'. The standard deviation of the
// gaussian bell curve is specified by 'sigma_'.
class MagickPPExport gaussianBlurImage
{
public:
gaussianBlurImage( const double width_, const double sigma_ );
void operator()( Image &image_ ) const;
private:
double _width;
double _sigma;
};
// Apply a color lookup table (Hald CLUT) to the image.
class MagickPPExport haldClutImage
{
public:
haldClutImage( const Image &haldClutImage_ );
void operator()( Image &image_ ) const;
private:
Image _haldClutImage;
};
// Implode image (special effect)
class MagickPPExport implodeImage
{
public:
implodeImage( const double factor_ = 50 );
void operator()( Image &image_ ) const;
private:
double _factor;
};
// implements the inverse discrete Fourier transform (IFT) of the image
// either as a magnitude / phase or real / imaginary image pair.
class MagickPPExport inverseFourierTransformImage
{
public:
inverseFourierTransformImage( const Image &phaseImage_ );
void operator()( Image &image_ ) const;
private:
Image _phaseImage;
};
// Set image validity. Valid images become empty (inValid) if
// argument is false.
class MagickPPExport isValidImage
{
public:
isValidImage( const bool isValid_ );
void operator()( Image &image_ ) const;
private:
bool _isValid;
};
// Label image
class MagickPPExport labelImage
{
public:
labelImage( const std::string &label_ );
void operator()( Image &image_ ) const;
private:
std::string _label;
};
// Level image
class MagickPPExport levelImage
{
public:
levelImage( const double black_point,
const double white_point,
const double mid_point=1.0 );
void operator()( Image &image_ ) const;
private:
double _black_point;
double _white_point;
double _mid_point;
};
// Level image channel
class MagickPPExport levelChannelImage
{
public:
levelChannelImage( const Magick::ChannelType channel,
const double black_point,
const double white_point,
const double mid_point=1.0 );
void operator()( Image &image_ ) const;
private:
Magick::ChannelType _channel;
double _black_point;
double _white_point;
double _mid_point;
};
// Magnify image by integral size
class MagickPPExport magnifyImage
{
public:
magnifyImage( void );
void operator()( Image &image_ ) const;
private:
};
// Remap image colors with closest color from reference image
class MagickPPExport mapImage
{
public:
mapImage( const Image &mapImage_ ,
const bool dither_ = false );
void operator()( Image &image_ ) const;
private:
Image _mapImage;
bool _dither;
};
// Floodfill designated area with a matte value
class MagickPPExport matteFloodfillImage
{
public:
matteFloodfillImage( const Color &target_ ,
const unsigned int matte_,
const ::ssize_t x_, const ::ssize_t y_,
const PaintMethod method_ );
void operator()( Image &image_ ) const;
private:
Color _target;
unsigned int _matte;
::ssize_t _x;
::ssize_t _y;
PaintMethod _method;
};
// Filter image by replacing each pixel component with the median
// color in a circular neighborhood
class MagickPPExport medianFilterImage
{
public:
medianFilterImage( const double radius_ = 0.0 );
void operator()( Image &image_ ) const;
private:
double _radius;
};
// Merge image layers
class MagickPPExport mergeLayersImage
{
public:
mergeLayersImage ( ImageLayerMethod layerMethod_ );
void operator()( Image &image_ ) const;
private:
ImageLayerMethod _layerMethod;
};
// Reduce image by integral size
class MagickPPExport minifyImage
{
public:
minifyImage( void );
void operator()( Image &image_ ) const;
private:
};
// Modulate percent hue, saturation, and brightness of an image
class MagickPPExport modulateImage
{
public:
modulateImage( const double brightness_,
const double saturation_,
const double hue_ );
void operator()( Image &image_ ) const;
private:
double _brightness;
double _saturation;
double _hue;
};
// Negate colors in image. Set grayscale to only negate grayscale
// values in image.
class MagickPPExport negateImage
{
public:
negateImage( const bool grayscale_ = false );
void operator()( Image &image_ ) const;
private:
bool _grayscale;
};
// Normalize image (increase contrast by normalizing the pixel
// values to span the full range of color values)
class MagickPPExport normalizeImage
{
public:
normalizeImage( void );
void operator()( Image &image_ ) const;
private:
};
// Oilpaint image (image looks like oil painting)
class MagickPPExport oilPaintImage
{
public:
oilPaintImage( const double radius_ = 3 );
void operator()( Image &image_ ) const;
private:
double _radius;
};
// Set or attenuate the image opacity channel. If the image pixels
// are opaque then they are set to the specified opacity value,
// otherwise they are blended with the supplied opacity value. The
// value of opacity_ ranges from 0 (completely opaque) to
// QuantumRange. The defines OpaqueOpacity and TransparentOpacity are
// available to specify completely opaque or completely transparent,
// respectively.
class MagickPPExport opacityImage
{
public:
opacityImage( const unsigned int opacity_ );
void operator()( Image &image_ ) const;
private:
unsigned int _opacity;
};
// Change color of opaque pixel to specified pen color.
class MagickPPExport opaqueImage
{
public:
opaqueImage( const Color &opaqueColor_,
const Color &penColor_ );
void operator()( Image &image_ ) const;
private:
Color _opaqueColor;
Color _penColor;
};
// Quantize image (reduce number of colors)
class MagickPPExport quantizeImage
{
public:
quantizeImage( const bool measureError_ = false );
void operator()( Image &image_ ) const;
private:
bool _measureError;
};
// Raise image (lighten or darken the edges of an image to give a
// 3-D raised or lowered effect)
class MagickPPExport raiseImage
{
public:
raiseImage( const Geometry &geometry_ = raiseGeometryDefault,
const bool raisedFlag_ = false );
void operator()( Image &image_ ) const;
private:
Geometry _geometry;
bool _raisedFlag;
};
class MagickPPExport ReadOptions
{
public:
// Default constructor
ReadOptions(void);
// Copy constructor
ReadOptions(const ReadOptions& options_);
// Destructor
~ReadOptions();
// Vertical and horizontal resolution in pixels of the image
void density(const Geometry &geometry_);
Geometry density(void) const;
// Image depth (8 or 16)
void depth(size_t depth_);
size_t depth(void) const;
// Suppress all warning messages. Error messages are still reported.
void quiet(const bool quiet_);
bool quiet(void) const;
// Image size (required for raw formats)
void size(const Geometry &geometry_);
Geometry size(void) const;
//
// Internal implementation methods. Please do not use.
//
MagickCore::ImageInfo *imageInfo(void);
private:
// Assignment not supported
ReadOptions& operator=(const ReadOptions&);
MagickCore::ImageInfo *_imageInfo;
bool _quiet;
};
// Reduce noise in image using a noise peak elimination filter
class MagickPPExport reduceNoiseImage
{
public:
reduceNoiseImage( void );
reduceNoiseImage (const size_t order_ );
void operator()( Image &image_ ) const;
private:
size_t _order;
};
// Resize image to specified size.
class MagickPPExport resizeImage
{
public:
resizeImage( const Geometry &geometry_ );
void operator()( Image &image_ ) const;
private:
Geometry _geometry;
};
// Roll image (rolls image vertically and horizontally) by specified
// number of columns and rows)
class MagickPPExport rollImage
{
public:
rollImage( const Geometry &roll_ );
rollImage( const ::ssize_t columns_, const ::ssize_t rows_ );
void operator()( Image &image_ ) const;
private:
size_t _columns;
size_t _rows;
};
// Rotate image counter-clockwise by specified number of degrees.
class MagickPPExport rotateImage
{
public:
rotateImage( const double degrees_ );
void operator()( Image &image_ ) const;
private:
double _degrees;
};
// Resize image by using pixel sampling algorithm
class MagickPPExport sampleImage
{
public:
sampleImage( const Geometry &geometry_ );
void operator()( Image &image_ ) const;
private:
Geometry _geometry;
};
// Resize image by using simple ratio algorithm
class MagickPPExport scaleImage
{
public:
scaleImage( const Geometry &geometry_ );
void operator()( Image &image_ ) const;
private:
Geometry _geometry;
};
// Segment (coalesce similar image components) by analyzing the
// histograms of the color components and identifying units that are
// homogeneous with the fuzzy c-means technique.
// Also uses QuantizeColorSpace and Verbose image attributes
class MagickPPExport segmentImage
{
public:
segmentImage( const double clusterThreshold_ = 1.0,
const double smoothingThreshold_ = 1.5 );
void operator()( Image &image_ ) const;
private:
double _clusterThreshold;
double _smoothingThreshold;
};
// Shade image using distant light source
class MagickPPExport shadeImage
{
public:
shadeImage( const double azimuth_ = 30,
const double elevation_ = 30,
const bool colorShading_ = false );
void operator()( Image &image_ ) const;
private:
double _azimuth;
double _elevation;
bool _colorShading;
};
// Shadow effect image (simulate an image shadow)
class MagickPPExport shadowImage
{
public:
shadowImage( const double percent_opacity_ = 80, const double sigma_ = 0.5,
const ssize_t x_ = 5, const ssize_t y_ = 5 );
void operator()( Image &image_ ) const;
private:
double _percent_opacity;
double _sigma;
ssize_t _x;
ssize_t _y;
};
// Sharpen pixels in image
class MagickPPExport sharpenImage
{
public:
sharpenImage( const double radius_ = 1, const double sigma_ = 0.5 );
void operator()( Image &image_ ) const;
private:
double _radius;
double _sigma;
};
// Shave pixels from image edges.
class MagickPPExport shaveImage
{
public:
shaveImage( const Geometry &geometry_ );
void operator()( Image &image_ ) const;
private:
Geometry _geometry;
};
// Shear image (create parallelogram by sliding image by X or Y axis)
class MagickPPExport shearImage
{
public:
shearImage( const double xShearAngle_,
const double yShearAngle_ );
void operator()( Image &image_ ) const;
private:
double _xShearAngle;
double _yShearAngle;
};
// Solarize image (similar to effect seen when exposing a
// photographic film to light during the development process)
class MagickPPExport solarizeImage
{
public:
solarizeImage( const double factor_ );
void operator()( Image &image_ ) const;
private:
double _factor;
};
// Splice the background color into the image.
class MagickPPExport spliceImage
{
public:
spliceImage( const Geometry &geometry_ );
void operator()( Image &image_ ) const;
private:
Geometry _geometry;
};
// Spread pixels randomly within image by specified amount
class MagickPPExport spreadImage
{
public:
spreadImage( const size_t amount_ = 3 );
void operator()( Image &image_ ) const;
private:
size_t _amount;
};
// Add a digital watermark to the image (based on second image)
class MagickPPExport steganoImage
{
public:
steganoImage( const Image &waterMark_ );
void operator()( Image &image_ ) const;
private:
Image _waterMark;
};
// Create an image which appears in stereo when viewed with red-blue glasses
// (Red image on left, blue on right)
class MagickPPExport stereoImage
{
public:
stereoImage( const Image &rightImage_ );
void operator()( Image &image_ ) const;
private:
Image _rightImage;
};
// Color to use when drawing object outlines
class MagickPPExport strokeColorImage
{
public:
strokeColorImage( const Color &strokeColor_ );
void operator()( Image &image_ ) const;
private:
Color _strokeColor;
};
// Swirl image (image pixels are rotated by degrees)
class MagickPPExport swirlImage
{
public:
swirlImage( const double degrees_ );
void operator()( Image &image_ ) const;
private:
double _degrees;
};
// Channel a texture on image background
class MagickPPExport textureImage
{
public:
textureImage( const Image &texture_ );
void operator()( Image &image_ ) const;
private:
Image _texture;
};
// Threshold image
class MagickPPExport thresholdImage
{
public:
thresholdImage( const double threshold_ );
void operator()( Image &image_ ) const;
private:
double _threshold;
};
// Transform image based on image and crop geometries
class MagickPPExport transformImage
{
public:
transformImage( const Geometry &imageGeometry_ );
transformImage( const Geometry &imageGeometry_,
const Geometry &cropGeometry_ );
void operator()( Image &image_ ) const;
private:
Geometry _imageGeometry;
Geometry _cropGeometry;
};
// Set image color to transparent
class MagickPPExport transparentImage
{
public:
transparentImage( const Color& color_ );
void operator()( Image &image_ ) const;
private:
Color _color;
};
// Trim edges that are the background color from the image
class MagickPPExport trimImage
{
public:
trimImage( void );
void operator()( Image &image_ ) const;
private:
};
// Map image pixels to a sine wave
class MagickPPExport waveImage
{
public:
waveImage( const double amplitude_ = 25.0,
const double wavelength_ = 150.0 );
void operator()( Image &image_ ) const;
private:
double _amplitude;
double _wavelength;
};
// Zoom image to specified size.
class MagickPPExport zoomImage
{
public:
zoomImage( const Geometry &geometry_ );
void operator()( Image &image_ ) const;
private:
Geometry _geometry;
};
//
// Function object image attribute accessors
//
// Anti-alias Postscript and TrueType fonts (default true)
class MagickPPExport antiAliasImage
{
public:
antiAliasImage( const bool flag_ );
void operator()( Image &image_ ) const;
private:
bool _flag;
};
// Join images into a single multi-image file
class MagickPPExport adjoinImage
{
public:
adjoinImage( const bool flag_ );
void operator()( Image &image_ ) const;
private:
bool _flag;
};
// Time in 1/100ths of a second which must expire before displaying
// the next image in an animated sequence.
class MagickPPExport animationDelayImage
{
public:
animationDelayImage( const size_t delay_ );
void operator()( Image &image_ ) const;
private:
size_t _delay;
};
// Number of iterations to loop an animation (e.g. Netscape loop
// extension) for.
class MagickPPExport animationIterationsImage
{
public:
animationIterationsImage( const size_t iterations_ );
void operator()( Image &image_ ) const;
private:
size_t _iterations;
};
// Image background color
class MagickPPExport backgroundColorImage
{
public:
backgroundColorImage( const Color &color_ );
void operator()( Image &image_ ) const;
private:
Color _color;
};
// Name of texture image to tile onto the image background
class MagickPPExport backgroundTextureImage
{
public:
backgroundTextureImage( const std::string &backgroundTexture_ );
void operator()( Image &image_ ) const;
private:
std::string _backgroundTexture;
};
// Image border color
class MagickPPExport borderColorImage
{
public:
borderColorImage( const Color &color_ );
void operator()( Image &image_ ) const;
private:
Color _color;
};
// Text bounding-box base color (default none)
class MagickPPExport boxColorImage
{
public:
boxColorImage( const Color &boxColor_ );
void operator()( Image &image_ ) const;
private:
Color _boxColor;
};
// Chromaticity blue primary point (e.g. x=0.15, y=0.06)
class MagickPPExport chromaBluePrimaryImage
{
public:
chromaBluePrimaryImage( const double x_, const double y_ );
void operator()( Image &image_ ) const;
private:
double _x;
double _y;
};
// Chromaticity green primary point (e.g. x=0.3, y=0.6)
class MagickPPExport chromaGreenPrimaryImage
{
public:
chromaGreenPrimaryImage( const double x_, const double y_ );
void operator()( Image &image_ ) const;
private:
double _x;
double _y;
};
// Chromaticity red primary point (e.g. x=0.64, y=0.33)
class MagickPPExport chromaRedPrimaryImage
{
public:
chromaRedPrimaryImage( const double x_, const double y_ );
void operator()( Image &image_ ) const;
private:
double _x;
double _y;
};
// Chromaticity white point (e.g. x=0.3127, y=0.329)
class MagickPPExport chromaWhitePointImage
{
public:
chromaWhitePointImage( const double x_, const double y_ );
void operator()( Image &image_ ) const;
private:
double _x;
double _y;
};
// Colors within this distance are considered equal
class MagickPPExport colorFuzzImage
{
public:
colorFuzzImage( const double fuzz_ );
void operator()( Image &image_ ) const;
private:
double _fuzz;
};
// Color at colormap position index_
class MagickPPExport colorMapImage
{
public:
colorMapImage( const size_t index_, const Color &color_ );
void operator()( Image &image_ ) const;
private:
size_t _index;
Color _color;
};
// Composition operator to be used when composition is implicitly used
// (such as for image flattening).
class MagickPPExport composeImage
{
public:
composeImage( const CompositeOperator compose_ );
void operator()( Image &image_ ) const;
private:
CompositeOperator _compose;
};
// Compression type
class MagickPPExport compressTypeImage
{
public:
compressTypeImage( const CompressionType compressType_ );
void operator()( Image &image_ ) const;
private:
CompressionType _compressType;
};
// Vertical and horizontal resolution in pixels of the image
class MagickPPExport densityImage
{
public:
densityImage( const Geometry &geomery_ );
void operator()( Image &image_ ) const;
private:
Geometry _geomery;
};
// Image depth (bits allocated to red/green/blue components)
class MagickPPExport depthImage
{
public:
depthImage( const size_t depth_ );
void operator()( Image &image_ ) const;
private:
size_t _depth;
};
// Endianness (LSBEndian like Intel or MSBEndian like SPARC) for image
// formats which support endian-specific options.
class MagickPPExport endianImage
{
public:
endianImage( const EndianType endian_ );
void operator()( Image &image_ ) const;
private:
EndianType _endian;
};
// Image file name
class MagickPPExport fileNameImage
{
public:
fileNameImage( const std::string &fileName_ );
void operator()( Image &image_ ) const;
private:
std::string _fileName;
};
// Filter to use when resizing image
class MagickPPExport filterTypeImage
{
public:
filterTypeImage( const FilterTypes filterType_ );
void operator()( Image &image_ ) const;
private:
FilterTypes _filterType;
};
// Text rendering font
class MagickPPExport fontImage
{
public:
fontImage( const std::string &font_ );
void operator()( Image &image_ ) const;
private:
std::string _font;
};
// Font point size
class MagickPPExport fontPointsizeImage
{
public:
fontPointsizeImage( const size_t pointsize_ );
void operator()( Image &image_ ) const;
private:
size_t _pointsize;
};
// GIF disposal method
class MagickPPExport gifDisposeMethodImage
{
public:
gifDisposeMethodImage( const size_t disposeMethod_ );
void operator()( Image &image_ ) const;
private:
size_t _disposeMethod;
};
// Type of interlacing to use
class MagickPPExport interlaceTypeImage
{
public:
interlaceTypeImage( const InterlaceType interlace_ );
void operator()( Image &image_ ) const;
private:
InterlaceType _interlace;
};
// Linewidth for drawing vector objects (default one)
class MagickPPExport lineWidthImage
{
public:
lineWidthImage( const double lineWidth_ );
void operator()( Image &image_ ) const;
private:
double _lineWidth;
};
// File type magick identifier (.e.g "GIF")
class MagickPPExport magickImage
{
public:
magickImage( const std::string &magick_ );
void operator()( Image &image_ ) const;
private:
std::string _magick;
};
// Image supports transparent color
class MagickPPExport matteImage
{
public:
matteImage( const bool matteFlag_ );
void operator()( Image &image_ ) const;
private:
bool _matteFlag;
};
// Transparent color
class MagickPPExport matteColorImage
{
public:
matteColorImage( const Color &matteColor_ );
void operator()( Image &image_ ) const;
private:
Color _matteColor;
};
// Indicate that image is black and white
class MagickPPExport monochromeImage
{
public:
monochromeImage( const bool monochromeFlag_ );
void operator()( Image &image_ ) const;
private:
bool _monochromeFlag;
};
// Pen color
class MagickPPExport penColorImage
{
public:
penColorImage( const Color &penColor_ );
void operator()( Image &image_ ) const;
private:
Color _penColor;
};
// Pen texture image.
class MagickPPExport penTextureImage
{
public:
penTextureImage( const Image &penTexture_ );
void operator()( Image &image_ ) const;
private:
Image _penTexture;
};
// Set pixel color at location x & y.
class MagickPPExport pixelColorImage
{
public:
pixelColorImage( const ::ssize_t x_,
const ::ssize_t y_,
const Color &color_);
void operator()( Image &image_ ) const;
private:
::ssize_t _x;
::ssize_t _y;
Color _color;
};
// Postscript page size.
class MagickPPExport pageImage
{
public:
pageImage( const Geometry &pageSize_ );
void operator()( Image &image_ ) const;
private:
Geometry _pageSize;
};
// JPEG/MIFF/PNG compression level (default 75).
class MagickPPExport qualityImage
{
public:
qualityImage( const size_t quality_ );
void operator()( Image &image_ ) const;
private:
size_t _quality;
};
// Maximum number of colors to quantize to
class MagickPPExport quantizeColorsImage
{
public:
quantizeColorsImage( const size_t colors_ );
void operator()( Image &image_ ) const;
private:
size_t _colors;
};
// Colorspace to quantize in.
class MagickPPExport quantizeColorSpaceImage
{
public:
quantizeColorSpaceImage( const ColorspaceType colorSpace_ );
void operator()( Image &image_ ) const;
private:
ColorspaceType _colorSpace;
};
// Dither image during quantization (default true).
class MagickPPExport quantizeDitherImage
{
public:
quantizeDitherImage( const bool ditherFlag_ );
void operator()( Image &image_ ) const;
private:
bool _ditherFlag;
};
// Quantization tree-depth
class MagickPPExport quantizeTreeDepthImage
{
public:
quantizeTreeDepthImage( const size_t treeDepth_ );
void operator()( Image &image_ ) const;
private:
size_t _treeDepth;
};
// The type of rendering intent
class MagickPPExport renderingIntentImage
{
public:
renderingIntentImage( const RenderingIntent renderingIntent_ );
void operator()( Image &image_ ) const;
private:
RenderingIntent _renderingIntent;
};
// Units of image resolution
class MagickPPExport resolutionUnitsImage
{
public:
resolutionUnitsImage( const ResolutionType resolutionUnits_ );
void operator()( Image &image_ ) const;
private:
ResolutionType _resolutionUnits;
};
// Image scene number
class MagickPPExport sceneImage
{
public:
sceneImage( const size_t scene_ );
void operator()( Image &image_ ) const;
private:
size_t _scene;
};
// adjust the image contrast with a non-linear sigmoidal contrast algorithm
class MagickPPExport sigmoidalContrastImage
{
public:
sigmoidalContrastImage( const size_t sharpen_,
const double contrast,
const double midpoint = QuantumRange / 2.0 );
void operator()( Image &image_ ) const;
private:
size_t _sharpen;
double contrast;
double midpoint;
};
// Width and height of a raw image
class MagickPPExport sizeImage
{
public:
sizeImage( const Geometry &geometry_ );
void operator()( Image &image_ ) const;
private:
Geometry _geometry;
};
// stripImage strips an image of all profiles and comments.
class MagickPPExport stripImage
{
public:
stripImage( void );
void operator()( Image &image_ ) const;
private:
};
// Subimage of an image sequence
class MagickPPExport subImageImage
{
public:
subImageImage( const size_t subImage_ );
void operator()( Image &image_ ) const;
private:
size_t _subImage;
};
// Number of images relative to the base image
class MagickPPExport subRangeImage
{
public:
subRangeImage( const size_t subRange_ );
void operator()( Image &image_ ) const;
private:
size_t _subRange;
};
// Tile name
class MagickPPExport tileNameImage
{
public:
tileNameImage( const std::string &tileName_ );
void operator()( Image &image_ ) const;
private:
std::string _tileName;
};
// Image storage type
class MagickPPExport typeImage
{
public:
typeImage( const ImageType type_ );
void operator()( Image &image_ ) const;
private:
Magick::ImageType _type;
};
// Print detailed information about the image
class MagickPPExport verboseImage
{
public:
verboseImage( const bool verbose_ );
void operator()( Image &image_ ) const;
private:
bool _verbose;
};
// FlashPix viewing parameters
class MagickPPExport viewImage
{
public:
viewImage( const std::string &view_ );
void operator()( Image &image_ ) const;
private:
std::string _view;
};
// X11 display to display to, obtain fonts from, or to capture
// image from
class MagickPPExport x11DisplayImage
{
public:
x11DisplayImage( const std::string &display_ );
void operator()( Image &image_ ) const;
private:
std::string _display;
};
//////////////////////////////////////////////////////////
//
// Implementation template definitions. Not for end-use.
//
//////////////////////////////////////////////////////////
// Link images together into an image list based on the ordering of
// the container implied by the iterator. This step is done in
// preparation for use with ImageMagick functions which operate on
// lists of images.
// Images are selected by range, first_ to last_ so that a subset of
// the container may be selected. Specify first_ via the
// container's begin() method and last_ via the container's end()
// method in order to specify the entire container.
template <class InputIterator>
bool linkImages( InputIterator first_,
InputIterator last_ ) {
MagickCore::Image* previous = 0;
::ssize_t scene = 0;
for ( InputIterator iter = first_; iter != last_; ++iter )
{
// Unless we reduce the reference count to one, the same image
// structure may occur more than once in the container, causing
// the linked list to fail.
iter->modifyImage();
MagickCore::Image* current = iter->image();
current->previous = previous;
current->next = 0;
current->scene = scene++;
if ( previous != 0)
previous->next = current;
previous = current;
}
return(scene > 0 ? true : false);
}
// Remove links added by linkImages. This should be called after the
// ImageMagick function call has completed to reset the image list
// back to its pristine un-linked state.
template <class InputIterator>
void unlinkImages( InputIterator first_,
InputIterator last_ ) {
for( InputIterator iter = first_; iter != last_; ++iter )
{
MagickCore::Image* image = iter->image();
image->previous = 0;
image->next = 0;
}
}
// Insert images in image list into existing container (appending to container)
// The images should not be deleted since only the image ownership is passed.
// The options are copied into the object.
template <class Container>
void insertImages( Container *sequence_,
MagickCore::Image* images_ ) {
MagickCore::Image *image = images_;
if ( image )
{
do
{
MagickCore::Image* next_image = image->next;
image->next = 0;
if (next_image != 0)
next_image->previous=0;
sequence_->push_back( Magick::Image( image ) );
image=next_image;
} while( image );
return;
}
}
///////////////////////////////////////////////////////////////////
//
// Template definitions for documented API
//
///////////////////////////////////////////////////////////////////
template <class InputIterator>
void animateImages( InputIterator first_,
InputIterator last_ ) {
if (linkImages(first_,last_) == false)
return;
GetPPException;
MagickCore::AnimateImages( first_->imageInfo(), first_->image() );
MagickCore::GetImageException( first_->image(), exceptionInfo );
unlinkImages( first_, last_ );
ThrowPPException(first_->quiet());
}
// Append images from list into single image in either horizontal or
// vertical direction.
template <class InputIterator>
void appendImages( Image *appendedImage_,
InputIterator first_,
InputIterator last_,
bool stack_ = false) {
if (linkImages(first_,last_) == false)
return;
GetPPException;
MagickCore::Image* image = MagickCore::AppendImages( first_->image(),
(MagickBooleanType) stack_,
exceptionInfo );
unlinkImages( first_, last_ );
appendedImage_->replaceImage( image );
ThrowPPException(appendedImage_->quiet());
}
// Adds the names of the artifacts of the image to the container.
template <class Container>
void artifactNames(Container *names_,const Image* image_)
{
char*
name;
names_->clear();
MagickCore::ResetImageArtifactIterator(image_->constImage());
name=MagickCore::GetNextImageArtifact(image_->constImage());
while (name != (char *) NULL)
{
names_->push_back(std::string(name));
name=MagickCore::GetNextImageArtifact(image_->constImage());
}
}
// Adds the names of the attributes of the image to the container.
template <class Container>
void attributeNames(Container *names_,const Image* image_)
{
char*
name;
names_->clear();
MagickCore::ResetImagePropertyIterator(image_->constImage());
name=MagickCore::GetNextImageProperty(image_->constImage());
while (name != (char *) NULL)
{
names_->push_back(std::string(name));
name=MagickCore::GetNextImageProperty(image_->constImage());
}
}
// Average a set of images.
// All the input images must be the same size in pixels.
template <class InputIterator>
void averageImages( Image *averagedImage_,
InputIterator first_,
InputIterator last_ ) {
GetPPException;
linkImages( first_, last_ );
MagickCore::Image* image = MagickCore::EvaluateImages( first_->image(),
MagickCore::MeanEvaluateOperator, exceptionInfo );
unlinkImages( first_, last_ );
averagedImage_->replaceImage( image );
ThrowPPException(averagedImage_->quiet());
}
// Merge a sequence of images.
// This is useful for GIF animation sequences that have page
// offsets and disposal methods. A container to contain
// the updated image sequence is passed via the coalescedImages_
// option.
template <class InputIterator, class Container >
void coalesceImages(Container *coalescedImages_,InputIterator first_,
InputIterator last_)
{
bool
quiet;
MagickCore::Image
*images;
if (linkImages(first_,last_) == false)
return;
GetPPException;
quiet=first_->quiet();
images=MagickCore::CoalesceImages( first_->image(),exceptionInfo);
// Unlink image list
unlinkImages(first_,last_);
// Ensure container is empty
coalescedImages_->clear();
// Move images to container
insertImages(coalescedImages_,images);
// Report any error
ThrowPPException(quiet);
}
// Return format coders matching specified conditions.
//
// The default (if no match terms are supplied) is to return all
// available format coders.
//
// For example, to return all readable formats:
// list<CoderInfo> coderList;
// coderInfoList( &coderList, CoderInfo::TrueMatch, CoderInfo::AnyMatch, CoderInfo::AnyMatch)
//
template <class Container >
void coderInfoList( Container *container_,
CoderInfo::MatchType isReadable_ = CoderInfo::AnyMatch,
CoderInfo::MatchType isWritable_ = CoderInfo::AnyMatch,
CoderInfo::MatchType isMultiFrame_ = CoderInfo::AnyMatch
) {
// Obtain first entry in MagickInfo list
size_t number_formats;
GetPPException;
char **coder_list =
MagickCore::GetMagickList( "*", &number_formats, exceptionInfo );
if( !coder_list )
{
throwException(exceptionInfo);
throwExceptionExplicit(MagickCore::MissingDelegateError,
"Coder array not returned!", 0 );
}
// Clear out container
container_->clear();
for ( ::ssize_t i=0; i < (::ssize_t) number_formats; i++)
{
const MagickCore::MagickInfo *magick_info =
MagickCore::GetMagickInfo( coder_list[i], exceptionInfo );
coder_list[i]=(char *)
MagickCore::RelinquishMagickMemory( coder_list[i] );
// Skip stealth coders
if ( magick_info->stealth )
continue;
try {
CoderInfo coderInfo( magick_info->name );
// Test isReadable_
if ( isReadable_ != CoderInfo::AnyMatch &&
(( coderInfo.isReadable() && isReadable_ != CoderInfo::TrueMatch ) ||
( !coderInfo.isReadable() && isReadable_ != CoderInfo::FalseMatch )) )
continue;
// Test isWritable_
if ( isWritable_ != CoderInfo::AnyMatch &&
(( coderInfo.isWritable() && isWritable_ != CoderInfo::TrueMatch ) ||
( !coderInfo.isWritable() && isWritable_ != CoderInfo::FalseMatch )) )
continue;
// Test isMultiFrame_
if ( isMultiFrame_ != CoderInfo::AnyMatch &&
(( coderInfo.isMultiFrame() && isMultiFrame_ != CoderInfo::TrueMatch ) ||
( !coderInfo.isMultiFrame() && isMultiFrame_ != CoderInfo::FalseMatch )) )
continue;
// Append matches to container
container_->push_back( coderInfo );
}
// Intentionally ignore missing module errors
catch (Magick::ErrorModule&)
{
continue;
}
}
coder_list=(char **) MagickCore::RelinquishMagickMemory( coder_list );
ThrowPPException(false);
}
//
// Fill container with color histogram.
// Entries are of type "std::pair<Color,size_t>". Use the pair
// "first" member to access the Color and the "second" member to access
// the number of times the color occurs in the image.
//
// For example:
//
// Using <map>:
//
// Image image("image.miff");
// map<Color,size_t> histogram;
// colorHistogram( &histogram, image );
// std::map<Color,size_t>::const_iterator p=histogram.begin();
// while (p != histogram.end())
// {
// cout << setw(10) << (int)p->second << ": ("
// << setw(quantum_width) << (int)p->first.redQuantum() << ","
// << setw(quantum_width) << (int)p->first.greenQuantum() << ","
// << setw(quantum_width) << (int)p->first.blueQuantum() << ")"
// << endl;
// p++;
// }
//
// Using <vector>:
//
// Image image("image.miff");
// std::vector<std::pair<Color,size_t> > histogram;
// colorHistogram( &histogram, image );
// std::vector<std::pair<Color,size_t> >::const_iterator p=histogram.begin();
// while (p != histogram.end())
// {
// cout << setw(10) << (int)p->second << ": ("
// << setw(quantum_width) << (int)p->first.redQuantum() << ","
// << setw(quantum_width) << (int)p->first.greenQuantum() << ","
// << setw(quantum_width) << (int)p->first.blueQuantum() << ")"
// << endl;
// p++;
// }
template <class Container >
void colorHistogram( Container *histogram_, const Image image)
{
GetPPException;
// Obtain histogram array
size_t colors;
MagickCore::ColorPacket *histogram_array =
MagickCore::GetImageHistogram( image.constImage(), &colors, exceptionInfo );
ThrowPPException(image.quiet());
// Clear out container
histogram_->clear();
// Transfer histogram array to container
for ( size_t i=0; i < colors; i++)
{
histogram_->insert( histogram_->end(), std::pair<const Color,size_t>
( Color(histogram_array[i].pixel), (size_t) histogram_array[i].count) );
}
// Deallocate histogram array
histogram_array=(MagickCore::ColorPacket *)
MagickCore::RelinquishMagickMemory(histogram_array);
}
// Combines one or more images into a single image. The grayscale value of
// the pixels of each image in the sequence is assigned in order to the
// specified channels of the combined image. The typical ordering would be
// image 1 => Red, 2 => Green, 3 => Blue, etc.
template <class InputIterator >
void combineImages( Image *combinedImage_,
InputIterator first_,
InputIterator last_,
const ChannelType channel_ ) {
if (linkImages(first_,last_) == false)
return;
GetPPException;
MagickCore::Image* image = CombineImages( first_->image(), channel_, exceptionInfo );
unlinkImages( first_, last_ );
combinedImage_->replaceImage( image );
ThrowPPException(combinedImage_->quiet());
}
template <class Container>
void cropToTiles(Container *tiledImages_,const Image image_,
const Geometry &geometry_)
{
GetPPException;
MagickCore::Image* images=CropImageToTiles(image_.constImage(),
static_cast<std::string>(geometry_).c_str(),exceptionInfo);
tiledImages_->clear();
insertImages(tiledImages_,images);
ThrowPPException(image_.quiet());
}
// Break down an image sequence into constituent parts. This is
// useful for creating GIF or MNG animation sequences.
template <class InputIterator, class Container>
void deconstructImages(Container *deconstructedImages_,InputIterator first_,
InputIterator last_)
{
bool
quiet;
MagickCore::Image
*images;
if (linkImages(first_,last_) == false)
return;
GetPPException;
quiet=first_->quiet();
images=DeconstructImages(first_->image(),exceptionInfo);
// Unlink image list
unlinkImages(first_,last_);
// Ensure container is empty
deconstructedImages_->clear();
// Move images to container
insertImages(deconstructedImages_,images);
// Report any error
ThrowPPException(quiet);
}
//
// Display an image sequence
//
template <class InputIterator>
void displayImages( InputIterator first_,
InputIterator last_ ) {
if (linkImages(first_,last_) == false)
return;
GetPPException;
MagickCore::DisplayImages( first_->imageInfo(), first_->image() );
MagickCore::GetImageException( first_->image(), exceptionInfo );
unlinkImages( first_, last_ );
ThrowPPException(first_->quiet());
}
// Applies a value to the image with an arithmetic, relational,
// or logical operator to an image. Use these operations to lighten or darken
// an image, to increase or decrease contrast in an image, or to produce the
// "negative" of an image.
template <class InputIterator >
void evaluateImages( Image *evaluatedImage_,
InputIterator first_,
InputIterator last_,
const MagickEvaluateOperator operator_ ) {
if (linkImages(first_,last_) == false)
return;
GetPPException;
MagickCore::Image* image = EvaluateImages( first_->image(), operator_, exceptionInfo );
unlinkImages( first_, last_ );
evaluatedImage_->replaceImage( image );
ThrowPPException(evaluatedImage_->quiet());
}
// Merge a sequence of image frames which represent image layers.
// This is useful for combining Photoshop layers into a single image.
template <class InputIterator>
void flattenImages( Image *flattenedImage_,
InputIterator first_,
InputIterator last_ ) {
if (linkImages(first_,last_) == false)
return;
GetPPException;
MagickCore::Image* image = MagickCore::MergeImageLayers( first_->image(),
FlattenLayer,exceptionInfo );
unlinkImages( first_, last_ );
flattenedImage_->replaceImage( image );
ThrowPPException(flattenedImage_->quiet());
}
// Implements the discrete Fourier transform (DFT) of the image either as a
// magnitude / phase or real / imaginary image pair.
template <class Container >
void forwardFourierTransformImage( Container *fourierImages_,
const Image &image_ ) {
GetPPException;
// Build image list
MagickCore::Image* images = ForwardFourierTransformImage(
image_.constImage(), MagickTrue, exceptionInfo);
// Ensure container is empty
fourierImages_->clear();
// Move images to container
insertImages( fourierImages_, images );
// Report any error
ThrowPPException(image_.quiet());
}
template <class Container >
void forwardFourierTransformImage( Container *fourierImages_,
const Image &image_, const bool magnitude_ ) {
GetPPException;
// Build image list
MagickCore::Image* images = ForwardFourierTransformImage(
image_.constImage(), magnitude_ == true ? MagickTrue : MagickFalse,
exceptionInfo);
// Ensure container is empty
fourierImages_->clear();
// Move images to container
insertImages( fourierImages_, images );
// Report any error
ThrowPPException(image_.quiet());
}
// Applies a mathematical expression to a sequence of images.
template <class InputIterator>
void fxImages(Image *fxImage_,InputIterator first_,InputIterator last_,
const std::string expression)
{
MagickCore::Image
*image;
if (linkImages(first_,last_) == false)
return;
GetPPException;
image=FxImageChannel(first_->constImage(),DefaultChannels,
expression.c_str(),exceptionInfo);
unlinkImages(first_,last_);
fxImage_->replaceImage(image);
ThrowPPException(fxImage_->quiet());
}
// Replace the colors of a sequence of images with the closest color
// from a reference image.
// Set dither_ to true to enable dithering. Set measureError_ to
// true in order to evaluate quantization error.
template <class InputIterator>
void mapImages( InputIterator first_,
InputIterator last_,
const Image& mapImage_,
bool dither_ = false,
bool measureError_ = false ) {
if (linkImages(first_,last_) == false)
return;
GetPPException;
MagickCore::QuantizeInfo quantizeInfo;
MagickCore::GetQuantizeInfo( &quantizeInfo );
quantizeInfo.dither = dither_ ? MagickCore::MagickTrue : MagickCore::MagickFalse;
MagickCore::RemapImages( &quantizeInfo, first_->image(),
(mapImage_.isValid() ? mapImage_.constImage() : (const MagickCore::Image*) NULL));
MagickCore::GetImageException( first_->image(), exceptionInfo );
if ( exceptionInfo->severity != MagickCore::UndefinedException )
{
unlinkImages( first_, last_ );
throwException(exceptionInfo,mapImage_.quiet());
}
MagickCore::Image* image = first_->image();
while( image )
{
// Calculate quantization error
if ( measureError_ )
{
MagickCore::GetImageQuantizeError( image );
if ( image->exception.severity > MagickCore::UndefinedException )
{
unlinkImages( first_, last_ );
throwException(exceptionInfo,mapImage_.quiet());
}
}
// Udate DirectClass representation of pixels
MagickCore::SyncImage( image );
if ( image->exception.severity > MagickCore::UndefinedException )
{
unlinkImages( first_, last_ );
throwException(exceptionInfo,mapImage_.quiet());
}
// Next image
image=image->next;
}
unlinkImages( first_, last_ );
(void) MagickCore::DestroyExceptionInfo( exceptionInfo );
}
// Composes all the image layers from the current given
// image onward to produce a single image of the merged layers.
template <class InputIterator >
void mergeImageLayers( Image *mergedImage_,
InputIterator first_,
InputIterator last_,
const ImageLayerMethod method_ ) {
if (linkImages(first_,last_) == false)
return;
GetPPException;
MagickCore::Image* image = MergeImageLayers( first_->image(), method_, exceptionInfo );
unlinkImages( first_, last_ );
mergedImage_->replaceImage( image );
ThrowPPException(mergedImage_->quiet());
}
// Create a composite image by combining several separate images.
template <class Container, class InputIterator>
void montageImages(Container *montageImages_,InputIterator first_,
InputIterator last_,const Montage &options_)
{
bool
quiet;
MagickCore::Image
*images;
MagickCore::MontageInfo
*montageInfo;
if (linkImages(first_,last_) == false)
return;
montageInfo=static_cast<MagickCore::MontageInfo*>(
MagickCore::AcquireMagickMemory(sizeof(MagickCore::MontageInfo)));
// Update montage options with those set in montageOpts_
options_.updateMontageInfo(*montageInfo);
// Update options which must transfer to image options
if (options_.label().length() != 0)
first_->label(options_.label());
// Do montage
GetPPException;
quiet=first_->quiet();
images=MagickCore::MontageImages(first_->image(),montageInfo,
exceptionInfo);
// Unlink linked image list
unlinkImages(first_,last_);
// Reset output container to pristine state
montageImages_->clear();
if (images != (MagickCore::Image *) NULL)
insertImages(montageImages_,images);
// Clean up any allocated data in montageInfo
MagickCore::DestroyMontageInfo(montageInfo);
// Report any montage error
ThrowPPException(quiet);
// Apply transparency to montage images
if (montageImages_->size() > 0 && options_.transparentColor().isValid())
for_each(montageImages_->begin(),montageImages_->end(),transparentImage(
options_.transparentColor()));
}
// Morph a set of images
template <class InputIterator,class Container>
void morphImages(Container *morphedImages_,InputIterator first_,
InputIterator last_,size_t frames_)
{
bool
quiet;
MagickCore::Image
*images;
if (linkImages(first_,last_) == false)
return;
GetPPException;
quiet=first_->quiet();
images=MagickCore::MorphImages(first_->image(),frames_,exceptionInfo);
// Unlink image list
unlinkImages(first_,last_);
// Ensure container is empty
morphedImages_->clear();
// Move images to container
insertImages(morphedImages_,images);
// Report any error
ThrowPPException(quiet);
}
// Inlay a number of images to form a single coherent picture.
template <class InputIterator>
void mosaicImages( Image *mosaicImage_,
InputIterator first_,
InputIterator last_ ) {
if (linkImages(first_,last_) == false)
return;
GetPPException;
MagickCore::Image* image = MagickCore::MergeImageLayers( first_->image(),
MosaicLayer,exceptionInfo );
unlinkImages( first_, last_ );
mosaicImage_->replaceImage( image );
ThrowPPException(mosaicImage_->quiet());
}
// Compares each image the GIF disposed forms of the previous image in
// the sequence. From this it attempts to select the smallest cropped
// image to replace each frame, while preserving the results of the
// GIF animation.
template <class InputIterator,class Container>
void optimizeImageLayers(Container *optimizedImages_,InputIterator first_,
InputIterator last_)
{
bool
quiet;
MagickCore::Image
*images;
if (linkImages(first_,last_) == false)
return;
GetPPException;
quiet=first_->quiet();
images=OptimizeImageLayers(first_->image(),exceptionInfo);
unlinkImages(first_,last_);
optimizedImages_->clear();
insertImages(optimizedImages_,images);
ThrowPPException(quiet);
}
// optimizeImagePlusLayers is exactly as optimizeImageLayers, but may
// also add or even remove extra frames in the animation, if it improves
// the total number of pixels in the resulting GIF animation.
template <class InputIterator, class Container >
void optimizePlusImageLayers(Container *optimizedImages_,
InputIterator first_,InputIterator last_)
{
bool
quiet;
MagickCore::Image
*images;
if (linkImages(first_,last_) == false)
return;
GetPPException;
quiet=first_->quiet();
images=OptimizePlusImageLayers(first_->image(),exceptionInfo);
unlinkImages(first_,last_);
optimizedImages_->clear();
insertImages(optimizedImages_,images);
ThrowPPException(quiet);
}
// Compares each image the GIF disposed forms of the previous image in the
// sequence. Any pixel that does not change the displayed result is replaced
// with transparency.
template<class InputIterator>
void optimizeTransparency(InputIterator first_,InputIterator last_)
{
if (linkImages(first_,last_) == false)
return;
GetPPException;
OptimizeImageTransparency(first_->image(),exceptionInfo);
unlinkImages(first_,last_ );
ThrowPPException(first_->quiet());
}
// Adds the names of the profiles from the image to the container.
template <class Container>
void profileNames(Container *names_,const Image* image_)
{
const char
*name;
names_->clear();
MagickCore::ResetImageProfileIterator(image_->constImage());
name=MagickCore::GetNextImageProfile(image_->constImage());
while (name != (const char *) NULL)
{
names_->push_back(std::string(name));
name=MagickCore::GetNextImageProfile(image_->constImage());
}
}
// Quantize colors in images using current quantization settings
// Set measureError_ to true in order to measure quantization error
template <class InputIterator>
void quantizeImages( InputIterator first_,
InputIterator last_,
bool measureError_ = false ) {
if (linkImages(first_,last_) == false)
return;
GetPPException;
MagickCore::QuantizeImages( first_->quantizeInfo(),
first_->image() );
MagickCore::GetImageException( first_->image(), exceptionInfo );
if ( exceptionInfo->severity > MagickCore::UndefinedException )
{
unlinkImages( first_, last_ );
throwException(exceptionInfo,first_->quiet());
}
MagickCore::Image* image = first_->image();
while( image != 0 )
{
// Calculate quantization error
if ( measureError_ )
MagickCore::GetImageQuantizeError( image );
// Update DirectClass representation of pixels
MagickCore::SyncImage( image );
// Next image
image=image->next;
}
unlinkImages( first_, last_ );
(void) MagickCore::DestroyExceptionInfo( exceptionInfo );
}
// Read images into existing container (appending to container)
template<class Container>
void readImages(Container *sequence_,const std::string &imageSpec_,
ReadOptions &options)
{
MagickCore::Image
*images;
MagickCore::ImageInfo
*imageInfo;
imageInfo=options.imageInfo();
imageSpec_.copy(imageInfo->filename,MaxTextExtent-1);
imageInfo->filename[imageSpec_.length()] = 0;
GetPPException;
images=MagickCore::ReadImage(imageInfo,exceptionInfo);
insertImages(sequence_,images);
ThrowPPException(options.quiet());
}
template<class Container>
void readImages(Container *sequence_,const std::string &imageSpec_)
{
ReadOptions options;
readImages(sequence_,imageSpec_,options);
}
template<class Container>
void readImages(Container *sequence_,const Blob &blob_,ReadOptions &options)
{
MagickCore::Image
*images;
GetPPException;
images=MagickCore::BlobToImage(options.imageInfo(),blob_.data(),
blob_.length(),exceptionInfo);
insertImages(sequence_,images);
ThrowPPException(options.quiet());
}
template<class Container>
void readImages(Container *sequence_,const Blob &blob_)
{
ReadOptions options;
readImages(sequence_,blob_,options);
}
// Returns a separate grayscale image for each channel specified.
template <class Container >
void separateImages( Container *separatedImages_,
const Image &image_,
const ChannelType channel_ ) {
GetPPException;
MagickCore::Image* images = MagickCore::SeparateImages( image_.constImage(), channel_, exceptionInfo );
separatedImages_->clear();
insertImages( separatedImages_, images );
ThrowPPException(image_.quiet());
}
// Smush images from list into single image in either horizontal or
// vertical direction.
template<class InputIterator>
void smushImages(Image *smushedImage_,InputIterator first_,
InputIterator last_,const ssize_t offset_,bool stack_=false)
{
MagickCore::Image
*newImage;
if (linkImages(first_,last_) == false)
return;
GetPPException;
newImage=MagickCore::SmushImages(first_->constImage(),
(MagickBooleanType) stack_,offset_,exceptionInfo);
unlinkImages(first_,last_);
smushedImage_->replaceImage(newImage);
ThrowPPException(smushedImage_->quiet());
}
// Write Images
template <class InputIterator>
void writeImages( InputIterator first_,
InputIterator last_,
const std::string &imageSpec_,
bool adjoin_ = true ) {
if (linkImages(first_,last_) == false)
return;
first_->adjoin( adjoin_ );
GetPPException;
::ssize_t errorStat = MagickCore::WriteImages( first_->constImageInfo(),
first_->image(),
imageSpec_.c_str(),
exceptionInfo );
unlinkImages( first_, last_ );
if ( errorStat != false )
{
(void) MagickCore::DestroyExceptionInfo( exceptionInfo );
return;
}
ThrowPPException(first_->quiet());
}
// Write images to BLOB
template <class InputIterator>
void writeImages( InputIterator first_,
InputIterator last_,
Blob *blob_,
bool adjoin_ = true) {
if (linkImages(first_,last_) == false)
return;
first_->adjoin( adjoin_ );
GetPPException;
size_t length = 2048; // Efficient size for small images
void* data = MagickCore::ImagesToBlob( first_->imageInfo(),
first_->image(),
&length,
exceptionInfo);
blob_->updateNoCopy( data, length, Magick::Blob::MallocAllocator );
unlinkImages( first_, last_ );
ThrowPPException(first_->quiet());
}
} // namespace Magick
#endif // Magick_STL_header
Magick++/CoderInfo.h 0000644 00000003202 15051111170 0010073 0 ustar 00 // This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 2001, 2002
// Copyright Dirk Lemstra 2013-2014
//
// CoderInfo Definition
//
// Container for image format support information.
//
#if !defined (Magick_CoderInfo_header)
#define Magick_CoderInfo_header 1
#include "Magick++/Include.h"
#include <string>
namespace Magick
{
class MagickPPExport CoderInfo
{
public:
enum MatchType {
AnyMatch, // match any coder
TrueMatch, // match coder if true
FalseMatch // match coder if false
};
// Default constructor
CoderInfo(void);
// Copy constructor
CoderInfo(const CoderInfo &coder_);
// Construct with coder name
CoderInfo(const std::string &name_);
// Destructor
~CoderInfo(void);
// Assignment operator
CoderInfo& operator=(const CoderInfo &coder_);
// Format description
std::string description(void) const;
// Format supports multiple frames
bool isMultiFrame(void) const;
// Format is readable
bool isReadable(void) const;
// Format is writeable
bool isWritable(void) const;
// Format mime type
std::string mimeType(void) const;
// Format name
std::string name(void) const;
// Unregisters this coder
bool unregister(void) const;
//
// Implemementation methods
//
CoderInfo(const MagickCore::MagickInfo *magickInfo_);
private:
std::string _name;
std::string _description;
std::string _mimeType;
bool _isReadable;
bool _isWritable;
bool _isMultiFrame;
};
} // namespace Magick
#endif // Magick_CoderInfo_header
Magick++/Image.h 0000644 00000201630 15051111170 0007252 0 ustar 00 // This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003
// Copyright Dirk Lemstra 2013-2015
//
// Definition of Image, the representation of a single image in Magick++
//
#if !defined(Magick_Image_header)
#define Magick_Image_header
#include "Magick++/Include.h"
#include <string>
#include <list>
#include "Magick++/Blob.h"
#include "Magick++/ChannelMoments.h"
#include "Magick++/Color.h"
#include "Magick++/Drawable.h"
#include "Magick++/Exception.h"
#include "Magick++/Geometry.h"
#include "Magick++/TypeMetric.h"
namespace Magick
{
// Forward declarations
class Options;
class ImageRef;
extern MagickPPExport const char *borderGeometryDefault;
extern MagickPPExport const char *frameGeometryDefault;
extern MagickPPExport const char *raiseGeometryDefault;
// Compare two Image objects regardless of LHS/RHS
// Image sizes and signatures are used as basis of comparison
MagickPPExport int operator ==
(const Magick::Image &left_,const Magick::Image &right_);
MagickPPExport int operator !=
(const Magick::Image &left_,const Magick::Image &right_);
MagickPPExport int operator >
(const Magick::Image &left_,const Magick::Image &right_);
MagickPPExport int operator <
(const Magick::Image &left_,const Magick::Image &right_);
MagickPPExport int operator >=
(const Magick::Image &left_,const Magick::Image &right_);
MagickPPExport int operator <=
(const Magick::Image &left_,const Magick::Image &right_);
//
// Image is the representation of an image. In reality, it actually
// a handle object which contains a pointer to a shared reference
// object (ImageRef). As such, this object is extremely space efficient.
//
class MagickPPExport Image
{
public:
// Obtain image statistics. Statistics are normalized to the range
// of 0.0 to 1.0 and are output to the specified ImageStatistics
// structure.
typedef struct _ImageChannelStatistics
{
/* Minimum value observed */
double maximum;
/* Maximum value observed */
double minimum;
/* Average (mean) value observed */
double mean;
/* Standard deviation, sqrt(variance) */
double standard_deviation;
/* Variance */
double variance;
/* Kurtosis */
double kurtosis;
/* Skewness */
double skewness;
} ImageChannelStatistics;
typedef struct _ImageStatistics
{
ImageChannelStatistics red;
ImageChannelStatistics green;
ImageChannelStatistics blue;
ImageChannelStatistics opacity;
} ImageStatistics;
// Default constructor
Image(void);
// Construct Image from in-memory BLOB
Image(const Blob &blob_);
// Construct Image of specified size from in-memory BLOB
Image(const Blob &blob_,const Geometry &size_);
// Construct Image of specified size and depth from in-memory BLOB
Image(const Blob &blob_,const Geometry &size_,const size_t depth_);
// Construct Image of specified size, depth, and format from
// in-memory BLOB
Image(const Blob &blob_,const Geometry &size_,const size_t depth_,
const std::string &magick_);
// Construct Image of specified size, and format from in-memory BLOB
Image(const Blob &blob_,const Geometry &size_,const std::string &magick_);
// Construct a blank image canvas of specified size and color
Image(const Geometry &size_,const Color &color_);
// Copy constructor
Image(const Image &image_);
// Copy constructor to copy part of the image
Image(const Image &image_,const Geometry &geometry_);
// Construct an image based on an array of raw pixels, of
// specified type and mapping, in memory
Image(const size_t width_,const size_t height_,const std::string &map_,
const StorageType type_,const void *pixels_);
// Construct from image file or image specification
Image(const std::string &imageSpec_);
// Destructor
virtual ~Image();
// Assignment operator
Image& operator=(const Image &image_);
// Join images into a single multi-image file
void adjoin(const bool flag_);
bool adjoin(void) const;
// Anti-alias Postscript and TrueType fonts (default true)
void antiAlias(const bool flag_);
bool antiAlias(void) const;
// Time in 1/100ths of a second which must expire before
// displaying the next image in an animated sequence.
void animationDelay(const size_t delay_);
size_t animationDelay(void) const;
// Number of iterations to loop an animation (e.g. Netscape loop
// extension) for.
void animationIterations(const size_t iterations_);
size_t animationIterations(void) const;
// Lessen (or intensify) when adding noise to an image.
void attenuate(const double attenuate_);
// Image background color
void backgroundColor(const Color &color_);
Color backgroundColor(void) const;
// Name of texture image to tile onto the image background
void backgroundTexture(const std::string &backgroundTexture_);
std::string backgroundTexture(void) const;
// Base image width (before transformations)
size_t baseColumns(void) const;
// Base image filename (before transformations)
std::string baseFilename(void) const;
// Base image height (before transformations)
size_t baseRows(void) const;
// Use black point compensation.
void blackPointCompensation(const bool flag_);
bool blackPointCompensation(void) const;
// Image border color
void borderColor(const Color &color_);
Color borderColor(void) const;
// Return smallest bounding box enclosing non-border pixels. The
// current fuzz value is used when discriminating between pixels.
// This is the crop bounding box used by crop(Geometry(0,0));
Geometry boundingBox(void) const;
// Text bounding-box base color (default none)
void boxColor(const Color &boxColor_);
Color boxColor(void) const;
// This method is now deprecated. Please use ResourceLimits instead.
static void cacheThreshold(const size_t threshold_);
// Image class (DirectClass or PseudoClass)
// NOTE: setting a DirectClass image to PseudoClass will result in
// the loss of color information if the number of colors in the
// image is greater than the maximum palette size (either 256 or
// 65536 entries depending on the value of MAGICKCORE_QUANTUM_DEPTH when
// ImageMagick was built).
void classType(const ClassType class_);
ClassType classType(void) const;
// Associate a clip mask with the image. The clip mask must be the
// same dimensions as the image. Pass an invalid image to unset an
// existing clip mask.
void clipMask(const Image &clipMask_);
Image clipMask(void) const;
// Colors within this distance are considered equal
void colorFuzz(const double fuzz_);
double colorFuzz(void) const;
// Colormap size (number of colormap entries)
void colorMapSize(const size_t entries_);
size_t colorMapSize(void) const;
// Image Color Space
void colorSpace(const ColorspaceType colorSpace_);
ColorspaceType colorSpace(void) const;
void colorspaceType(const ColorspaceType colorSpace_);
ColorspaceType colorspaceType(void) const;
// Image width
size_t columns(void) const;
// Comment image (add comment string to image)
void comment(const std::string &comment_);
std::string comment(void) const;
// Composition operator to be used when composition is implicitly
// used (such as for image flattening).
void compose(const CompositeOperator compose_);
CompositeOperator compose(void) const;
// Compression type
void compressType(const CompressionType compressType_);
CompressionType compressType(void) const;
// Enable printing of debug messages from ImageMagick
void debug(const bool flag_);
bool debug(void) const;
// Vertical and horizontal resolution in pixels of the image
void density(const Geometry &geomery_);
Geometry density(void) const;
// Image depth (bits allocated to red/green/blue components)
void depth(const size_t depth_);
size_t depth(void) const;
// Tile names from within an image montage
std::string directory(void) const;
// Endianness (little like Intel or big like SPARC) for image
// formats which support endian-specific options.
void endian(const EndianType endian_);
EndianType endian(void) const;
// Exif profile (BLOB)
void exifProfile(const Blob &exifProfile_);
Blob exifProfile(void) const;
// Image file name
void fileName(const std::string &fileName_);
std::string fileName(void) const;
// Number of bytes of the image on disk
off_t fileSize(void) const;
// Color to use when filling drawn objects
void fillColor(const Color &fillColor_);
Color fillColor(void) const;
// Rule to use when filling drawn objects
void fillRule(const FillRule &fillRule_);
FillRule fillRule(void) const;
// Pattern to use while filling drawn objects.
void fillPattern(const Image &fillPattern_);
Image fillPattern(void) const;
// Filter to use when resizing image
void filterType(const FilterTypes filterType_);
FilterTypes filterType(void) const;
// Text rendering font
void font(const std::string &font_);
std::string font(void) const;
// Font family
void fontFamily(const std::string &family_);
std::string fontFamily(void) const;
// Font point size
void fontPointsize(const double pointSize_);
double fontPointsize(void) const;
// Font style
void fontStyle(const StyleType style_);
StyleType fontStyle(void) const;
// Font weight
void fontWeight(const size_t weight_);
size_t fontWeight(void) const;
// Long image format description
std::string format(void) const;
// Formats the specified expression
// More info here: https://imagemagick.org/script/escape.php
std::string formatExpression(const std::string expression);
// Gamma level of the image
double gamma(void) const;
// Preferred size of the image when encoding
Geometry geometry(void) const;
// GIF disposal method
void gifDisposeMethod(const size_t disposeMethod_);
size_t gifDisposeMethod(void) const;
// When comparing images, emphasize pixel differences with this color.
void highlightColor(const Color color_);
// ICC color profile (BLOB)
void iccColorProfile(const Blob &colorProfile_);
Blob iccColorProfile(void) const;
// Type of interlacing to use
void interlaceType(const InterlaceType interlace_);
InterlaceType interlaceType(void) const;
// Pixel color interpolation method to use
void interpolate(const InterpolatePixelMethod interpolate_);
InterpolatePixelMethod interpolate(void) const;
// IPTC profile (BLOB)
void iptcProfile(const Blob &iptcProfile_);
Blob iptcProfile(void) const;
// Returns true if none of the pixels in the image have an alpha value
// other than OpaqueAlpha (QuantumRange).
bool isOpaque(void) const;
// Does object contain valid image?
void isValid(const bool isValid_);
bool isValid(void) const;
// Image label
void label(const std::string &label_);
std::string label(void) const;
// Stroke width for drawing vector objects (default one)
// This method is now deprecated. Please use strokeWidth instead.
void lineWidth(const double lineWidth_);
double lineWidth(void) const;
// When comparing images, de-emphasize pixel differences with this color.
void lowlightColor(const Color color_);
// File type magick identifier (.e.g "GIF")
void magick(const std::string &magick_);
std::string magick(void) const;
// Associate a mask with the image. The mask must be the same dimensions
// as the image. Pass an invalid image to unset an existing clip mask.
void mask(const Image &mask_);
Image mask(void) const;
// Image supports transparency (matte channel)
void matte(const bool matteFlag_);
bool matte(void) const;
// Transparent color
void matteColor(const Color &matteColor_);
Color matteColor(void) const;
// The mean error per pixel computed when an image is color reduced
double meanErrorPerPixel(void) const;
// Image modulus depth (minimum number of bits required to support
// red/green/blue components without loss of accuracy)
void modulusDepth(const size_t modulusDepth_);
size_t modulusDepth(void) const;
// Transform image to black and white
void monochrome(const bool monochromeFlag_);
bool monochrome(void) const;
// Tile size and offset within an image montage
Geometry montageGeometry(void) const;
// The normalized max error per pixel computed when an image is
// color reduced.
double normalizedMaxError(void) const;
// The normalized mean error per pixel computed when an image is
// color reduced.
double normalizedMeanError(void) const;
// Image orientation
void orientation(const OrientationType orientation_);
OrientationType orientation(void) const;
// Preferred size and location of an image canvas.
void page(const Geometry &pageSize_);
Geometry page(void) const;
// Pen color (deprecated, don't use any more)
void penColor(const Color &penColor_);
Color penColor(void) const;
// Pen texture image (deprecated, don't use any more)
void penTexture(const Image &penTexture_);
Image penTexture(void) const;
// JPEG/MIFF/PNG compression level (default 75).
void quality(const size_t quality_);
size_t quality(void) const;
// Maximum number of colors to quantize to
void quantizeColors(const size_t colors_);
size_t quantizeColors(void) const;
// Colorspace to quantize in.
void quantizeColorSpace(const ColorspaceType colorSpace_);
ColorspaceType quantizeColorSpace(void) const;
// Dither image during quantization (default true).
void quantizeDither(const bool ditherFlag_);
bool quantizeDither(void) const;
// Dither method
void quantizeDitherMethod(const DitherMethod ditherMethod_);
DitherMethod quantizeDitherMethod(void) const;
// Quantization tree-depth
void quantizeTreeDepth(const size_t treeDepth_);
size_t quantizeTreeDepth(void) const;
// Suppress all warning messages. Error messages are still reported.
void quiet(const bool quiet_);
bool quiet(void) const;
// The type of rendering intent
void renderingIntent(const RenderingIntent renderingIntent_);
RenderingIntent renderingIntent(void) const;
// Units of image resolution
void resolutionUnits(const ResolutionType resolutionUnits_);
ResolutionType resolutionUnits(void) const;
// The number of pixel rows in the image
size_t rows(void) const;
// Image scene number
void scene(const size_t scene_);
size_t scene(void) const;
// Width and height of a raw image
void size(const Geometry &geometry_);
Geometry size(void) const;
// enabled/disable stroke anti-aliasing
void strokeAntiAlias(const bool flag_);
bool strokeAntiAlias(void) const;
// Color to use when drawing object outlines
void strokeColor(const Color &strokeColor_);
Color strokeColor(void) const;
// Specify the pattern of dashes and gaps used to stroke
// paths. The strokeDashArray represents a zero-terminated array
// of numbers that specify the lengths of alternating dashes and
// gaps in pixels. If an odd number of values is provided, then
// the list of values is repeated to yield an even number of
// values. A typical strokeDashArray_ array might contain the
// members 5 3 2 0, where the zero value indicates the end of the
// pattern array.
void strokeDashArray(const double *strokeDashArray_);
const double *strokeDashArray(void) const;
// While drawing using a dash pattern, specify distance into the
// dash pattern to start the dash (default 0).
void strokeDashOffset(const double strokeDashOffset_);
double strokeDashOffset(void) const;
// Specify the shape to be used at the end of open subpaths when
// they are stroked. Values of LineCap are UndefinedCap, ButtCap,
// RoundCap, and SquareCap.
void strokeLineCap(const LineCap lineCap_);
LineCap strokeLineCap(void) const;
// Specify the shape to be used at the corners of paths (or other
// vector shapes) when they are stroked. Values of LineJoin are
// UndefinedJoin, MiterJoin, RoundJoin, and BevelJoin.
void strokeLineJoin(const LineJoin lineJoin_);
LineJoin strokeLineJoin(void) const;
// Specify miter limit. When two line segments meet at a sharp
// angle and miter joins have been specified for 'lineJoin', it is
// possible for the miter to extend far beyond the thickness of
// the line stroking the path. The miterLimit' imposes a limit on
// the ratio of the miter length to the 'lineWidth'. The default
// value of this parameter is 4.
void strokeMiterLimit(const size_t miterLimit_);
size_t strokeMiterLimit(void) const;
// Pattern image to use while stroking object outlines.
void strokePattern(const Image &strokePattern_);
Image strokePattern(void) const;
// Stroke width for drawing vector objects (default one)
void strokeWidth(const double strokeWidth_);
double strokeWidth(void) const;
// Subimage of an image sequence
void subImage(const size_t subImage_);
size_t subImage(void) const;
// Number of images relative to the base image
void subRange(const size_t subRange_);
size_t subRange(void) const;
// Render text right-to-left or left-to-right.
void textDirection(DirectionType direction_);
DirectionType textDirection() const;
// Annotation text encoding (e.g. "UTF-16")
void textEncoding(const std::string &encoding_);
std::string textEncoding(void) const;
// Text gravity.
void textGravity(GravityType gravity_);
GravityType textGravity() const;
// Text inter-line spacing
void textInterlineSpacing(double spacing_);
double textInterlineSpacing(void) const;
// Text inter-word spacing
void textInterwordSpacing(double spacing_);
double textInterwordSpacing(void) const;
// Text inter-character kerning
void textKerning(double kerning_);
double textKerning(void) const;
// Text undercolor box
void textUnderColor(const Color &underColor_);
Color textUnderColor(void) const;
// Tile name
void tileName(const std::string &tileName_);
std::string tileName(void) const;
// Number of colors in the image
size_t totalColors(void) const;
// Rotation to use when annotating with text or drawing
void transformRotation(const double angle_);
// Skew to use in X axis when annotating with text or drawing
void transformSkewX(const double skewx_);
// Skew to use in Y axis when annotating with text or drawing
void transformSkewY(const double skewy_);
// Image representation type (also see type operation)
// Available types:
// Bilevel Grayscale GrayscaleMatte
// Palette PaletteMatte TrueColor
// TrueColorMatte ColorSeparation ColorSeparationMatte
void type(const ImageType type_);
ImageType type(void) const;
// Print detailed information about the image
void verbose(const bool verboseFlag_);
bool verbose(void) const;
// FlashPix viewing parameters
void view(const std::string &view_);
std::string view(void) const;
// Virtual pixel method
void virtualPixelMethod(const VirtualPixelMethod virtual_pixel_method_);
VirtualPixelMethod virtualPixelMethod(void) const;
// X11 display to display to, obtain fonts from, or to capture
// image from
void x11Display(const std::string &display_);
std::string x11Display(void) const;
// x resolution of the image
double xResolution(void) const;
// y resolution of the image
double yResolution(void) const;
// Adaptive-blur image with specified blur factor
// The radius_ parameter specifies the radius of the Gaussian, in
// pixels, not counting the center pixel. The sigma_ parameter
// specifies the standard deviation of the Laplacian, in pixels.
void adaptiveBlur(const double radius_=0.0,const double sigma_=1.0);
// This is shortcut function for a fast interpolative resize using mesh
// interpolation. It works well for small resizes of less than +/- 50%
// of the original image size. For larger resizing on images a full
// filtered and slower resize function should be used instead.
void adaptiveResize(const Geometry &geometry_);
// Adaptively sharpens the image by sharpening more intensely near image
// edges and less intensely far from edges. We sharpen the image with a
// Gaussian operator of the given radius and standard deviation (sigma).
// For reasonable results, radius should be larger than sigma.
void adaptiveSharpen(const double radius_=0.0,const double sigma_=1.0);
void adaptiveSharpenChannel(const ChannelType channel_,
const double radius_=0.0,const double sigma_=1.0);
// Local adaptive threshold image
// http://www.dai.ed.ac.uk/HIPR2/adpthrsh.htm
// Width x height define the size of the pixel neighborhood
// offset = constant to subtract from pixel neighborhood mean
void adaptiveThreshold(const size_t width,const size_t height,
const ::ssize_t offset=0);
// Add noise to image with specified noise type
void addNoise(const NoiseType noiseType_);
void addNoiseChannel(const ChannelType channel_,
const NoiseType noiseType_);
// Transform image by specified affine (or free transform) matrix.
void affineTransform(const DrawableAffine &affine);
// Activates, deactivates, resets, or sets the alpha channel.
void alphaChannel(AlphaChannelType alphaType_);
//
// Annotate image (draw text on image)
//
// Gravity effects text placement in bounding area according to rules:
// NorthWestGravity text bottom-left corner placed at top-left
// NorthGravity text bottom-center placed at top-center
// NorthEastGravity text bottom-right corner placed at top-right
// WestGravity text left-center placed at left-center
// CenterGravity text center placed at center
// EastGravity text right-center placed at right-center
// SouthWestGravity text top-left placed at bottom-left
// SouthGravity text top-center placed at bottom-center
// SouthEastGravity text top-right placed at bottom-right
// Annotate using specified text, and placement location
void annotate(const std::string &text_,const Geometry &location_);
// Annotate using specified text, bounding area, and placement
// gravity
void annotate(const std::string &text_,const Geometry &boundingArea_,
const GravityType gravity_);
// Annotate with text using specified text, bounding area,
// placement gravity, and rotation.
void annotate(const std::string &text_,const Geometry &boundingArea_,
const GravityType gravity_,const double degrees_);
// Annotate with text (bounding area is entire image) and placement
// gravity.
void annotate(const std::string &text_,const GravityType gravity_);
// Inserts the artifact with the specified name and value into
// the artifact tree of the image.
void artifact(const std::string &name_,const std::string &value_);
// Returns the value of the artifact with the specified name.
std::string artifact(const std::string &name_) const;
// Access/Update a named image attribute
void attribute(const std::string name_,const char *value_);
void attribute(const std::string name_,const std::string value_);
std::string attribute(const std::string name_ ) const;
// Extracts the 'mean' from the image and adjust the image to try
// make set its gamma appropriately.
void autoGamma(void);
void autoGammaChannel(const ChannelType channel_);
// Adjusts the levels of a particular image channel by scaling the
// minimum and maximum values to the full quantum range.
void autoLevel(void);
void autoLevelChannel(const ChannelType channel_);
// Adjusts an image so that its orientation is suitable for viewing.
void autoOrient(void);
// Forces all pixels below the threshold into black while leaving all
// pixels at or above the threshold unchanged.
void blackThreshold(const std::string &threshold_);
void blackThresholdChannel(const ChannelType channel_,
const std::string &threshold_);
// Simulate a scene at nighttime in the moonlight.
void blueShift(const double factor_=1.5);
// Blur image with specified blur factor
// The radius_ parameter specifies the radius of the Gaussian, in
// pixels, not counting the center pixel. The sigma_ parameter
// specifies the standard deviation of the Laplacian, in pixels.
void blur(const double radius_=0.0,const double sigma_=1.0);
void blurChannel(const ChannelType channel_,const double radius_=0.0,
const double sigma_=1.0);
// Border image (add border to image)
void border(const Geometry &geometry_=borderGeometryDefault);
// Changes the brightness and/or contrast of an image. It converts the
// brightness and contrast parameters into slope and intercept and calls
// a polynomial function to apply to the image.
void brightnessContrast(const double brightness_=0.0,
const double contrast_=0.0);
void brightnessContrastChannel(const ChannelType channel_,
const double brightness_=0.0,const double contrast_=0.0);
// Uses a multi-stage algorithm to detect a wide range of edges in images.
void cannyEdge(const double radius_=0.0,const double sigma_=1.0,
const double lowerPercent_=0.1,const double upperPercent_=0.3);
// Accepts a lightweight Color Correction Collection
// (CCC) file which solely contains one or more color corrections and
// applies the correction to the image.
void cdl(const std::string &cdl_);
// Extract channel from image
void channel(const ChannelType channel_);
// Set or obtain modulus channel depth
void channelDepth(const ChannelType channel_,const size_t depth_);
size_t channelDepth(const ChannelType channel_);
// Charcoal effect image (looks like charcoal sketch)
// The radius_ parameter specifies the radius of the Gaussian, in
// pixels, not counting the center pixel. The sigma_ parameter
// specifies the standard deviation of the Laplacian, in pixels.
void charcoal(const double radius_=0.0,const double sigma_=1.0);
// Chop image (remove vertical or horizontal subregion of image)
// FIXME: describe how geometry argument is used to select either
// horizontal or vertical subregion of image.
void chop(const Geometry &geometry_);
// Chromaticity blue primary point (e.g. x=0.15, y=0.06)
void chromaBluePrimary(const double x_,const double y_);
void chromaBluePrimary(double *x_, double *y_) const;
// Chromaticity green primary point (e.g. x=0.3, y=0.6)
void chromaGreenPrimary(const double x_,const double y_);
void chromaGreenPrimary(double *x_,double *y_) const;
// Chromaticity red primary point (e.g. x=0.64, y=0.33)
void chromaRedPrimary(const double x_,const double y_);
void chromaRedPrimary(double *x_,double *y_) const;
// Chromaticity white point (e.g. x=0.3127, y=0.329)
void chromaWhitePoint(const double x_,const double y_);
void chromaWhitePoint(double *x_,double *y_) const;
// Set each pixel whose value is below zero to zero and any the
// pixel whose value is above the quantum range to the quantum range (e.g.
// 65535) otherwise the pixel value remains unchanged.
void clamp(void);
void clampChannel(const ChannelType channel_);
// Sets the image clip mask based on any clipping path information
// if it exists.
void clip(void);
void clipPath(const std::string pathname_,const bool inside_);
// Apply a color lookup table (CLUT) to the image.
void clut(const Image &clutImage_);
void clutChannel(const ChannelType channel_,const Image &clutImage_);
// Colorize image with pen color, using specified percent opacity.
void colorize(const unsigned int opacity_,const Color &penColor_);
// Colorize image with pen color, using specified percent opacity
// for red, green, and blue quantums
void colorize(const unsigned int opacityRed_,
const unsigned int opacityGreen_,const unsigned int opacityBlue_,
const Color &penColor_);
// Color at colormap position index_
void colorMap(const size_t index_,const Color &color_);
Color colorMap(const size_t index_) const;
// Apply a color matrix to the image channels. The user supplied
// matrix may be of order 1 to 5 (1x1 through 5x5).
void colorMatrix(const size_t order_,const double *color_matrix_);
// Compare current image with another image
// Sets meanErrorPerPixel, normalizedMaxError, and normalizedMeanError
// in the current image. True is returned if the images are identical.
bool compare(const Image &reference_);
// Compare current image with another image
// Returns the distortion based on the specified metric.
double compare(const Image &reference_,const MetricType metric_);
double compareChannel(const ChannelType channel_,const Image &reference_,
const MetricType metric_);
// Compare current image with another image
// Sets the distortion and returns the difference image.
Image compare(const Image &reference_,const MetricType metric_,
double *distortion);
Image compareChannel(const ChannelType channel_,const Image &reference_,
const MetricType metric_,double *distortion );
// Compose an image onto another at specified offset and using
// specified algorithm
void composite(const Image &compositeImage_,const Geometry &offset_,
const CompositeOperator compose_=InCompositeOp);
void composite(const Image &compositeImage_,const GravityType gravity_,
const CompositeOperator compose_=InCompositeOp);
void composite(const Image &compositeImage_,const ::ssize_t xOffset_,
const ::ssize_t yOffset_,const CompositeOperator compose_=InCompositeOp);
// Determines the connected-components of the image
void connectedComponents(const size_t connectivity_);
// Contrast image (enhance intensity differences in image)
void contrast(const size_t sharpen_);
// A simple image enhancement technique that attempts to improve the
// contrast in an image by 'stretching' the range of intensity values
// it contains to span a desired range of values. It differs from the
// more sophisticated histogram equalization in that it can only apply a
// linear scaling function to the image pixel values. As a result the
// 'enhancement' is less harsh.
void contrastStretch(const double black_point_,const double white_point_);
void contrastStretchChannel(const ChannelType channel_,
const double black_point_,const double white_point_);
// Convolve image. Applies a user-specified convolution to the image.
// order_ represents the number of columns and rows in the filter kernel.
// kernel_ is an array of doubles representing the convolution kernel.
void convolve(const size_t order_,const double *kernel_);
// Copies pixels from the source image as defined by the geometry the
// destination image at the specified offset.
void copyPixels(const Image &source_,const Geometry &geometry_,
const Offset &offset_);
// Crop image (subregion of original image)
void crop(const Geometry &geometry_);
// Cycle image colormap
void cycleColormap(const ::ssize_t amount_);
// Converts cipher pixels to plain pixels.
void decipher(const std::string &passphrase_);
// Tagged image format define. Similar to the defineValue() method
// except that passing the flag_ value 'true' creates a value-less
// define with that format and key. Passing the flag_ value 'false'
// removes any existing matching definition. The method returns 'true'
// if a matching key exists, and 'false' if no matching key exists.
void defineSet(const std::string &magick_,const std::string &key_,
bool flag_);
bool defineSet(const std::string &magick_,const std::string &key_) const;
// Tagged image format define (set/access coder-specific option) The
// magick_ option specifies the coder the define applies to. The key_
// option provides the key specific to that coder. The value_ option
// provides the value to set (if any). See the defineSet() method if the
// key must be removed entirely.
void defineValue(const std::string &magick_,const std::string &key_,
const std::string &value_);
std::string defineValue(const std::string &magick_,
const std::string &key_) const;
// Removes skew from the image. Skew is an artifact that occurs in scanned
// images because of the camera being misaligned, imperfections in the
// scanning or surface, or simply because the paper was not placed
// completely flat when scanned. The value of threshold_ ranges from 0
// to QuantumRange.
void deskew(const double threshold_);
// Despeckle image (reduce speckle noise)
void despeckle(void);
// Determines the color type of the image. This method can be used to
// automaticly make the type GrayScale.
ImageType determineType(void) const;
// Display image on screen
void display(void);
// Distort image. distorts an image using various distortion methods, by
// mapping color lookups of the source image to a new destination image
// usually of the same size as the source image, unless 'bestfit' is set to
// true.
void distort(const DistortImageMethod method_,
const size_t number_arguments_,const double *arguments_,
const bool bestfit_=false);
// Draw on image using a single drawable
void draw(const Drawable &drawable_);
// Draw on image using a drawable list
void draw(const std::list<Magick::Drawable> &drawable_);
// Edge image (highlight edges in image)
void edge(const double radius_=0.0);
// Emboss image (highlight edges with 3D effect)
// The radius_ parameter specifies the radius of the Gaussian, in
// pixels, not counting the center pixel. The sigma_ parameter
// specifies the standard deviation of the Laplacian, in pixels.
void emboss(const double radius_=0.0,const double sigma_=1.0);
// Converts pixels to cipher-pixels.
void encipher(const std::string &passphrase_);
// Enhance image (minimize noise)
void enhance(void);
// Equalize image (histogram equalization)
void equalize(void);
// Erase image to current "background color"
void erase(void);
// Extend the image as defined by the geometry.
void extent(const Geometry &geometry_);
void extent(const Geometry &geometry_,const Color &backgroundColor);
void extent(const Geometry &geometry_,const Color &backgroundColor,
const GravityType gravity_ );
void extent(const Geometry &geometry_,const GravityType gravity_);
// Flip image (reflect each scanline in the vertical direction)
void flip(void);
// Flood-fill color across pixels that match the color of the
// target pixel and are neighbors of the target pixel.
// Uses current fuzz setting when determining color match.
void floodFillColor(const Geometry &point_,const Color &fillColor_);
void floodFillColor(const Geometry &point_,const Color &fillColor_,
const bool invert_);
void floodFillColor(const ::ssize_t x_,const ::ssize_t y_,
const Color &fillColor_);
void floodFillColor(const ::ssize_t x_,const ::ssize_t y_,
const Color &fillColor_,const bool invert_);
// Flood-fill color across pixels starting at target-pixel and
// stopping at pixels matching specified border color.
// Uses current fuzz setting when determining color match.
void floodFillColor(const Geometry &point_,const Color &fillColor_,
const Color &borderColor_);
void floodFillColor(const Geometry &point_,const Color &fillColor_,
const Color &borderColor_,const bool invert_);
void floodFillColor(const ::ssize_t x_,const ::ssize_t y_,
const Color &fillColor_,const Color &borderColor_);
void floodFillColor(const ::ssize_t x_,const ::ssize_t y_,
const Color &fillColor_,const Color &borderColor_,const bool invert_);
// Floodfill pixels matching color (within fuzz factor) of target
// pixel(x,y) with replacement opacity value using method.
void floodFillOpacity(const ::ssize_t x_,const ::ssize_t y_,
const unsigned int opacity_,const bool invert_=false);
void floodFillOpacity(const ::ssize_t x_,const ::ssize_t y_,
const unsigned int opacity_,const PaintMethod method_);
void floodFillOpacity(const ::ssize_t x_,const ::ssize_t y_,
const unsigned int opacity_,const Color &target_,
const bool invert_=false);
// Flood-fill texture across pixels that match the color of the
// target pixel and are neighbors of the target pixel.
// Uses current fuzz setting when determining color match.
void floodFillTexture(const Geometry &point_,const Image &texture_);
void floodFillTexture(const Geometry &point_,const Image &texture_,
const bool invert_);
void floodFillTexture(const ::ssize_t x_,const ::ssize_t y_,
const Image &texture_);
void floodFillTexture(const ::ssize_t x_,const ::ssize_t y_,
const Image &texture_,const bool invert_);
// Flood-fill texture across pixels starting at target-pixel and
// stopping at pixels matching specified border color.
// Uses current fuzz setting when determining color match.
void floodFillTexture(const Geometry &point_,const Image &texture_,
const Color &borderColor_);
void floodFillTexture(const Geometry &point_,const Image &texture_,
const Color &borderColor_,const bool invert_);
void floodFillTexture(const ::ssize_t x_,const ::ssize_t y_,
const Image &texture_,const Color &borderColor_);
void floodFillTexture(const ::ssize_t x_,const ::ssize_t y_,
const Image &texture_,const Color &borderColor_,const bool invert_);
// Flop image (reflect each scanline in the horizontal direction)
void flop(void);
// Obtain font metrics for text string given current font,
// pointsize, and density settings.
void fontTypeMetrics(const std::string &text_,TypeMetric *metrics);
// Obtain multi line font metrics for text string given current font,
// pointsize, and density settings.
void fontTypeMetricsMultiline(const std::string &text_,
TypeMetric *metrics);
// Frame image
void frame(const Geometry &geometry_=frameGeometryDefault);
void frame(const size_t width_,const size_t height_,
const ::ssize_t innerBevel_=6, const ::ssize_t outerBevel_=6);
// Applies a mathematical expression to the image.
void fx(const std::string expression);
void fx(const std::string expression,const Magick::ChannelType channel);
// Gamma correct image
void gamma(const double gamma_);
void gamma(const double gammaRed_,const double gammaGreen_,
const double gammaBlue_);
// Gaussian blur image
// The number of neighbor pixels to be included in the convolution
// mask is specified by 'width_'. The standard deviation of the
// gaussian bell curve is specified by 'sigma_'.
void gaussianBlur(const double width_,const double sigma_);
void gaussianBlurChannel(const ChannelType channel_,const double width_,
const double sigma_);
// Obtain immutable image pixel indexes (valid for PseudoClass images)
const IndexPacket *getConstIndexes(void) const;
// Transfers read-only pixels from the image to the pixel cache as
// defined by the specified region
const PixelPacket *getConstPixels(const ::ssize_t x_,const ::ssize_t y_,
const size_t columns_,const size_t rows_) const;
// Obtain mutable image pixel indexes (valid for PseudoClass images)
IndexPacket *getIndexes(void);
// Transfers pixels from the image to the pixel cache as defined
// by the specified region. Modified pixels may be subsequently
// transferred back to the image via syncPixels. This method is
// valid for DirectClass images.
PixelPacket *getPixels(const ::ssize_t x_,const ::ssize_t y_,
const size_t columns_,const size_t rows_);
// Converts the colors in the image to gray.
void grayscale(const PixelIntensityMethod method_);
// Apply a color lookup table (Hald CLUT) to the image.
void haldClut(const Image &clutImage_);
// Identifies lines in the image.
void houghLine(const size_t width_,const size_t height_,
const size_t threshold_=40);
// Implode image (special effect)
void implode(const double factor_);
// Implements the inverse discrete Fourier transform (DFT) of the image
// either as a magnitude / phase or real / imaginary image pair.
void inverseFourierTransform(const Image &phase_);
void inverseFourierTransform(const Image &phase_,const bool magnitude_);
// An edge preserving noise reduction filter.
void kuwahara(const double radius_=0.0,const double sigma_=1.0);
void kuwaharaChannel(const ChannelType channel_,const double radius_=0.0,
const double sigma_=1.0);
// Level image. Adjust the levels of the image by scaling the
// colors falling between specified white and black points to the
// full available quantum range. The parameters provided represent
// the black, mid (gamma), and white points. The black point
// specifies the darkest color in the image. Colors darker than
// the black point are set to zero. Mid point (gamma) specifies a
// gamma correction to apply to the image. White point specifies
// the lightest color in the image. Colors brighter than the
// white point are set to the maximum quantum value. The black and
// white point have the valid range 0 to QuantumRange while mid (gamma)
// has a useful range of 0 to ten.
void level(const double black_point,const double white_point,
const double mid_point=1.0);
void levelChannel(const ChannelType channel,const double black_point,
const double white_point,const double mid_point=1.0);
// Maps the given color to "black" and "white" values, linearly spreading
// out the colors, and level values on a channel by channel bases, as
// per level(). The given colors allows you to specify different level
// ranges for each of the color channels separately.
void levelColors(const Color &blackColor_,const Color &whiteColor_,
const bool invert_=true);
void levelColorsChannel(const ChannelType channel_,
const Color &blackColor_,const Color &whiteColor_,
const bool invert_=true);
// Levelize applies the reversed level operation to just the specific
// channels specified.It compresses the full range of color values, so
// that they lie between the given black and white points. Gamma is
// applied before the values are mapped.
void levelize(const double blackPoint_,const double whitePoint_,
const double gamma_=1.0);
void levelizeChannel(const ChannelType channel_,const double blackPoint_,
const double whitePoint_,const double gamma_=1.0);
// Discards any pixels below the black point and above the white point and
// levels the remaining pixels.
void linearStretch(const double blackPoint_,const double whitePoint_);
// Rescales image with seam carving.
void liquidRescale(const Geometry &geometry_);
// Local contrast enhancement
void localContrast(const double radius_,const double strength_);
// Magnify image by integral size
void magnify(void);
// Remap image colors with closest color from reference image
void map(const Image &mapImage_,const bool dither_=false);
// Floodfill designated area with replacement opacity value
void matteFloodfill(const Color &target_,const unsigned int opacity_,
const ::ssize_t x_,const ::ssize_t y_,const PaintMethod method_);
// Filter image by replacing each pixel component with the median
// color in a circular neighborhood
void medianFilter(const double radius_=0.0);
// Merge image layers (deprecated, don't use any more)
void mergeLayers(const ImageLayerMethod layerType_);
// Reduce image by integral size
void minify(void);
// Modulate percent hue, saturation, and brightness of an image
void modulate(const double brightness_,const double saturation_,
const double hue_);
// Returns the normalized moments of one or more image channels.
ImageMoments moments(void) const;
// Applies a kernel to the image according to the given morphology method.
void morphology(const MorphologyMethod method_,const std::string kernel_,
const ssize_t iterations_=1);
void morphology(const MorphologyMethod method_,
const KernelInfoType kernel_,const std::string arguments_,
const ssize_t iterations_=1);
void morphologyChannel(const ChannelType channel_,
const MorphologyMethod method_,const std::string kernel_,
const ssize_t iterations_=1);
void morphologyChannel(const ChannelType channel_,
const MorphologyMethod method_,const KernelInfoType kernel_,
const std::string arguments_,const ssize_t iterations_=1);
// Motion blur image with specified blur factor
// The radius_ parameter specifies the radius of the Gaussian, in
// pixels, not counting the center pixel. The sigma_ parameter
// specifies the standard deviation of the Laplacian, in pixels.
// The angle_ parameter specifies the angle the object appears
// to be coming from (zero degrees is from the right).
void motionBlur(const double radius_,const double sigma_,
const double angle_);
// Negate colors in image. Set grayscale to only negate grayscale
// values in image.
void negate(const bool grayscale_=false);
void negateChannel(const ChannelType channel_,const bool grayscale_=false);
// Normalize image (increase contrast by normalizing the pixel
// values to span the full range of color values)
void normalize(void);
// Oilpaint image (image looks like oil painting)
void oilPaint(const double radius_=3.0);
// Set or attenuate the opacity channel in the image. If the image
// pixels are opaque then they are set to the specified opacity
// value, otherwise they are blended with the supplied opacity
// value. The value of opacity_ ranges from 0 (completely opaque)
// to QuantumRange. The defines OpaqueOpacity and TransparentOpacity are
// available to specify completely opaque or completely
// transparent, respectively.
void opacity(const unsigned int opacity_);
// Change color of opaque pixel to specified pen color.
void opaque(const Color &opaqueColor_,const Color &penColor_,
const bool invert_=MagickFalse);
// Perform a ordered dither based on a number of pre-defined dithering
// threshold maps, but over multiple intensity levels.
void orderedDither(std::string thresholdMap_);
void orderedDitherChannel(const ChannelType channel_,
std::string thresholdMap_);
// Set each pixel whose value is less than epsilon to epsilon or
// -epsilon (whichever is closer) otherwise the pixel value remains
// unchanged.
void perceptible(const double epsilon_);
void perceptibleChannel(const ChannelType channel_,const double epsilon_);
// Ping is similar to read except only enough of the image is read
// to determine the image columns, rows, and filesize. Access the
// columns(), rows(), and fileSize() attributes after invoking
// ping. The image data is not valid after calling ping.
void ping(const Blob &blob_);
// Ping is similar to read except only enough of the image is read
// to determine the image columns, rows, and filesize. Access the
// columns(), rows(), and fileSize() attributes after invoking
// ping. The image data is not valid after calling ping.
void ping(const std::string &imageSpec_);
// Get/set pixel color at location x & y.
void pixelColor(const ::ssize_t x_,const ::ssize_t y_,const Color &color_);
Color pixelColor(const ::ssize_t x_,const ::ssize_t y_ ) const;
// Simulates a Polaroid picture.
void polaroid(const std::string &caption_,const double angle_);
// Reduces the image to a limited number of colors for a "poster" effect.
void posterize(const size_t levels_,const bool dither_=false);
void posterizeChannel(const ChannelType channel_, const size_t levels_,
const bool dither_=false);
// Execute a named process module using an argc/argv syntax similar to
// that accepted by a C 'main' routine. An exception is thrown if the
// requested process module doesn't exist, fails to load, or fails during
// execution.
void process(std::string name_,const ::ssize_t argc_,const char **argv_);
// Add or remove a named profile to/from the image. Remove the
// profile by passing an empty Blob (e.g. Blob()). Valid names are
// "*", "8BIM", "ICM", "IPTC", or a user/format-defined profile name.
void profile(const std::string name_,const Blob &colorProfile_);
// Retrieve a named profile from the image. Valid names are:
// "8BIM", "8BIMTEXT", "APP1", "APP1JPEG", "ICC", "ICM", & "IPTC"
// or an existing user/format-defined profile name.
Blob profile(const std::string name_) const;
// Quantize image (reduce number of colors)
void quantize(const bool measureError_=false);
// Apply a value with an arithmetic, relational, or logical operator.
void quantumOperator(const ChannelType channel_,
const MagickEvaluateOperator operator_,double rvalue_);
// Apply a value with an arithmetic, relational, or logical operator.
void quantumOperator(const ChannelType channel_,
const MagickFunction function_,const size_t number_parameters_,
const double *parameters_);
// Apply a value with an arithmetic, relational, or logical operator.
void 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_);
// Raise image (lighten or darken the edges of an image to give a
// 3-D raised or lowered effect)
void raise(const Geometry &geometry_=raiseGeometryDefault,
const bool raisedFlag_=false);
// Random threshold image.
//
// Changes the value of individual pixels based on the intensity
// of each pixel compared to a random threshold. The result is a
// low-contrast, two color image. The thresholds_ argument is a
// geometry containing LOWxHIGH thresholds. If the string
// contains 2x2, 3x3, or 4x4, then an ordered dither of order 2,
// 3, or 4 will be performed instead. If a channel_ argument is
// specified then only the specified channel is altered. This is
// a very fast alternative to 'quantize' based dithering.
void randomThreshold(const Geometry &thresholds_);
void randomThresholdChannel(const Geometry &thresholds_,
const ChannelType channel_);
// Read single image frame from in-memory BLOB
void read(const Blob &blob_);
// Read single image frame of specified size from in-memory BLOB
void read(const Blob &blob_,const Geometry &size_);
// Read single image frame of specified size and depth from
// in-memory BLOB
void read(const Blob &blob_,const Geometry &size_,const size_t depth_);
// Read single image frame of specified size, depth, and format
// from in-memory BLOB
void read(const Blob &blob_,const Geometry &size_,const size_t depth_,
const std::string &magick_);
// Read single image frame of specified size, and format from
// in-memory BLOB
void read(const Blob &blob_,const Geometry &size_,
const std::string &magick_);
// Read single image frame of specified size into current object
void read(const Geometry &size_,const std::string &imageSpec_);
// Read single image frame from an array of raw pixels, with
// specified storage type (ConstituteImage), e.g.
// image.read( 640, 480, "RGB", 0, pixels );
void read(const size_t width_,const size_t height_,const std::string &map_,
const StorageType type_,const void *pixels_);
// Read single image frame into current object
void read(const std::string &imageSpec_);
// Transfers one or more pixel components from a buffer or file
// into the image pixel cache of an image.
// Used to support image decoders.
void readPixels(const QuantumType quantum_,const unsigned char *source_);
// Reduce noise in image using a noise peak elimination filter
void reduceNoise(void);
void reduceNoise(const double order_);
// Resets the image page canvas and position.
void repage();
// Resize image in terms of its pixel size.
void resample(const Geometry &geometry_);
// Resize image to specified size.
void resize(const Geometry &geometry_);
// Roll image (rolls image vertically and horizontally) by specified
// number of columns and rows)
void roll(const Geometry &roll_);
void roll(const size_t columns_,const size_t rows_);
// Rotate image clockwise by specified number of degrees. Specify a
// negative number for degrees to rotate counter-clockwise.
void rotate(const double degrees_);
// Rotational blur image.
void rotationalBlur(const double angle_);
void rotationalBlurChannel(const ChannelType channel_,
const double angle_);
// Resize image by using pixel sampling algorithm
void sample(const Geometry &geometry_);
// Resize image by using simple ratio algorithm
void scale(const Geometry &geometry_);
// Segment (coalesce similar image components) by analyzing the
// histograms of the color components and identifying units that
// are homogeneous with the fuzzy c-means technique. Also uses
// QuantizeColorSpace and Verbose image attributes
void segment(const double clusterThreshold_=1.0,
const double smoothingThreshold_=1.5);
// Selectively blur pixels within a contrast threshold. It is similar to
// the unsharpen mask that sharpens everything with contrast above a
// certain threshold.
void selectiveBlur(const double radius_,const double sigma_,
const double threshold_);
void selectiveBlurChannel(const ChannelType channel_,const double radius_,
const double sigma_,const double threshold_);
// Separates a channel from the image and returns it as a grayscale image.
Image separate(const ChannelType channel_) const;
// Applies a special effect to the image, similar to the effect achieved in
// a photo darkroom by sepia toning. Threshold ranges from 0 to
// QuantumRange and is a measure of the extent of the sepia toning.
// A threshold of 80% is a good starting point for a reasonable tone.
void sepiaTone(const double threshold_);
// Allocates a pixel cache region to store image pixels as defined
// by the region rectangle. This area is subsequently transferred
// from the pixel cache to the image via syncPixels.
PixelPacket *setPixels(const ::ssize_t x_,const ::ssize_t y_,
const size_t columns_,const size_t rows_);
// Shade image using distant light source
void shade(const double azimuth_=30,const double elevation_=30,
const bool colorShading_=false);
// Simulate an image shadow
void shadow(const double percent_opacity_=80.0,const double sigma_=0.5,
const ssize_t x_=5,const ssize_t y_=5);
// Sharpen pixels in image
// The radius_ parameter specifies the radius of the Gaussian, in
// pixels, not counting the center pixel. The sigma_ parameter
// specifies the standard deviation of the Laplacian, in pixels.
void sharpen(const double radius_=0.0,const double sigma_=1.0);
void sharpenChannel(const ChannelType channel_,const double radius_=0.0,
const double sigma_=1.0);
// Shave pixels from image edges.
void shave(const Geometry &geometry_);
// Shear image (create parallelogram by sliding image by X or Y axis)
void shear(const double xShearAngle_,const double yShearAngle_);
// adjust the image contrast with a non-linear sigmoidal contrast algorithm
void sigmoidalContrast(const size_t sharpen_,const double contrast,
const double midpoint=QuantumRange/2.0);
// Image signature. Set force_ to true in order to re-calculate
// the signature regardless of whether the image data has been
// modified.
std::string signature(const bool force_=false) const;
// Simulates a pencil sketch. We convolve the image with a Gaussian
// operator of the given radius and standard deviation (sigma). For
// reasonable results, radius should be larger than sigma. Use a
// radius of 0 and SketchImage() selects a suitable radius for you.
void sketch(const double radius_=0.0,const double sigma_=1.0,
const double angle_=0.0);
// Solarize image (similar to effect seen when exposing a
// photographic film to light during the development process)
void solarize(const double factor_=50.0);
// Sparse color image, given a set of coordinates, interpolates the colors
// found at those coordinates, across the whole image, using various
// methods.
void sparseColor(const ChannelType channel,const SparseColorMethod method,
const size_t number_arguments,const double *arguments);
// Splice the background color into the image.
void splice(const Geometry &geometry_);
void splice(const Geometry &geometry_,const Color &backgroundColor_);
void splice(const Geometry &geometry_,const Color &backgroundColor_,
const GravityType gravity_);
// Spread pixels randomly within image by specified ammount
void spread(const size_t amount_=3);
void statistics(ImageStatistics *statistics) const;
// Add a digital watermark to the image (based on second image)
void stegano(const Image &watermark_);
// Create an image which appears in stereo when viewed with
// red-blue glasses (Red image on left, blue on right)
void stereo(const Image &rightImage_);
// Strip strips an image of all profiles and comments.
void strip(void);
// Search for the specified image at EVERY possible location in this image.
// This is slow! very very slow.. It returns a similarity image such that
// an exact match location is completely white and if none of the pixels
// match, black, otherwise some gray level in-between.
Image subImageSearch(const Image &reference_,const MetricType metric_,
Geometry *offset_,double *similarityMetric_,
const double similarityThreshold=(-1.0));
// Swirl image (image pixels are rotated by degrees)
void swirl(const double degrees_);
// Transfers the image cache pixels to the image.
void syncPixels(void);
// Channel a texture on image background
void texture(const Image &texture_);
// Threshold image
void threshold(const double threshold_);
// Resize image to thumbnail size
void thumbnail(const Geometry &geometry_);
// Applies a color vector to each pixel in the image. The length of the
// vector is 0 for black and white and at its maximum for the midtones.
// The vector weighting function is f(x)=(1-(4.0*((x-0.5)*(x-0.5))))
void tint(const std::string opacity_);
// Transform image based on image and crop geometries
// Crop geometry is optional
void transform(const Geometry &imageGeometry_);
void transform(const Geometry &imageGeometry_,
const Geometry &cropGeometry_);
// Origin of coordinate system to use when annotating with text or drawing
void transformOrigin(const double x_,const double y_);
// Reset transformation parameters to default
void transformReset(void);
// Scale to use when annotating with text or drawing
void transformScale(const double sx_,const double sy_);
// Add matte image to image, setting pixels matching color to
// transparent
void transparent(const Color &color_);
// Add matte image to image, for all the pixels that lies in between
// the given two color
void transparentChroma(const Color &colorLow_,const Color &colorHigh_);
// Creates a horizontal mirror image by reflecting the pixels around the
// central y-axis while rotating them by 90 degrees.
void transpose(void);
// Creates a vertical mirror image by reflecting the pixels around the
// central x-axis while rotating them by 270 degrees.
void transverse(void);
// Trim edges that are the background color from the image
void trim(void);
// Returns the unique colors of an image.
Image uniqueColors(void) const;
// Replace image with a sharpened version of the original image
// using the unsharp mask algorithm.
// radius_
// the radius of the Gaussian, in pixels, not counting the
// center pixel.
// sigma_
// the standard deviation of the Gaussian, in pixels.
// amount_
// the percentage of the difference between the original and
// the blur image that is added back into the original.
// threshold_
// the threshold in pixels needed to apply the difference amount.
void unsharpmask(const double radius_,const double sigma_,
const double amount_,const double threshold_);
void unsharpmaskChannel(const ChannelType channel_,const double radius_,
const double sigma_,const double amount_,const double threshold_);
// Softens the edges of the image in vignette style.
void vignette(const double radius_=0.0,const double sigma_=1.0,
const ssize_t x_=0,const ssize_t y_=0);
// Map image pixels to a sine wave
void wave(const double amplitude_=25.0,const double wavelength_=150.0);
// Removes noise from the image using a wavelet transform.
void waveletDenoise(const double threshold_,const double softness_);
// Forces all pixels above the threshold into white while leaving all
// pixels at or below the threshold unchanged.
void whiteThreshold(const std::string &threshold_);
void whiteThresholdChannel(const ChannelType channel_,
const std::string &threshold_);
// Write single image frame to in-memory BLOB, with optional
// format and adjoin parameters.
void write(Blob *blob_);
void write(Blob *blob_,const std::string &magick_);
void write(Blob *blob_,const std::string &magick_,const size_t depth_);
// Write single image frame to an array of pixels with storage
// type specified by user (DispatchImage), e.g.
// image.write( 0, 0, 640, 1, "RGB", 0, pixels );
void write(const ::ssize_t x_,const ::ssize_t y_,const size_t columns_,
const size_t rows_,const std::string& map_,const StorageType type_,
void *pixels_);
// Write single image frame to a file
void write(const std::string &imageSpec_);
// Transfers one or more pixel components from the image pixel
// cache to a buffer or file.
// Used to support image encoders.
void writePixels(const QuantumType quantum_,unsigned char *destination_);
// Zoom image to specified size.
void zoom(const Geometry &geometry_);
//////////////////////////////////////////////////////////////////////
//
// No user-serviceable parts beyond this point
//
//////////////////////////////////////////////////////////////////////
// Construct with MagickCore::Image and default options
Image(MagickCore::Image *image_);
// Retrieve Image*
MagickCore::Image *&image(void);
const MagickCore::Image *constImage(void) const;
// Retrieve ImageInfo*
MagickCore::ImageInfo *imageInfo(void);
const MagickCore::ImageInfo *constImageInfo(void) const;
// Retrieve Options*
Options *options(void);
const Options *constOptions(void) const;
// Retrieve QuantizeInfo*
MagickCore::QuantizeInfo *quantizeInfo(void);
const MagickCore::QuantizeInfo *constQuantizeInfo(void) const;
// Prepare to update image (copy if reference > 1)
void modifyImage(void);
// Replace current image (reference counted)
MagickCore::Image *replaceImage(MagickCore::Image *replacement_);
// Test for ImageMagick error and throw exception if error
void throwImageException(void) const;
private:
void read(MagickCore::Image *image,
MagickCore::ExceptionInfo *exceptionInfo);
void floodFill(const ssize_t x_,const ssize_t y_,
const Magick::Image *fillPattern_,const Color &fill_,
const MagickCore::PixelPacket *target,const bool invert_);
ImageRef *_imgRef;
};
} // end of namespace Magick
//
// Inlines
//
inline Magick::ClassType Magick::Image::classType(void) const
{
return static_cast<Magick::ClassType>(constImage()->storage_class);
}
inline size_t Magick::Image::columns(void) const
{
return constImage()->columns;
}
inline void Magick::Image::lineWidth(const double lineWidth_)
{
strokeWidth(lineWidth_);
}
inline double Magick::Image::lineWidth(void) const
{
return strokeWidth();
}
inline void Magick::Image::reduceNoise(void)
{
reduceNoise(3.0);
}
inline size_t Magick::Image::rows(void) const
{
return constImage()->rows;
}
#endif // Magick_Image_header
Magick++/Include.h 0000644 00000153714 15051111170 0007624 0 ustar 00 // This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002
// Copyright Dirk Lemstra 2013-2017
//
// Inclusion of ImageMagick headers (with namespace magic)
#ifndef Magick_Include_header
#define Magick_Include_header
#if !defined(_MAGICK_CONFIG_H)
# define _MAGICK_CONFIG_H
# if !defined(vms) && !defined(macintosh)
# include "magick/magick-config.h"
# else
# include "magick-config.h"
# endif
# undef inline // Remove possible definition from config.h
# undef class
#endif
// Needed for stdio FILE
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <sys/types.h>
#include <errno.h>
#include <stdint.h>
#if defined(__BORLANDC__)
# include <vcl.h> /* Borland C++ Builder 4.0 requirement */
#endif // defined(__BORLANDC__)
//
// Include ImageMagick headers into namespace "MagickCore". If
// MAGICKCORE_IMPLEMENTATION is defined, include ImageMagick development
// headers. This scheme minimizes the possibility of conflict with
// user code.
//
namespace MagickCore
{
#include <magick/MagickCore.h>
#include <wand/MagickWand.h>
#undef inline // Remove possible definition from config.h
#undef class
}
//
// Provide appropriate DLL imports/exports for Visual C++,
// Borland C++Builder and MinGW builds.
//
#if defined(WIN32) && !defined(__CYGWIN__) && !defined(__MINGW32__)
# define MagickCplusPlusDLLSupported
#endif
#if defined(MagickCplusPlusDLLSupported)
# if defined(_MT) && defined(_DLL) && !defined(_LIB) && !defined(STATIC_MAGICK)
//
// In a native Windows build, the following defines are used:
//
// _MT = Multithreaded
// _DLL = Using code is part of a DLL
// _LIB = Using code is being built as a library.
// _MAGICKMOD_ = Build uses loadable modules (Magick++ does not care about this)
//
// In the case where ImageMagick is built as a static library but the
// using code is dynamic, STATIC_MAGICK may be defined in the project to
// override triggering dynamic library behavior.
//
# if defined(_VISUALC_)
# define MagickDLLExplicitTemplate
# pragma warning( disable: 4273 ) /* Disable the stupid dll linkage warnings */
# pragma warning( disable: 4251 )
# endif
# if !defined(MAGICKCORE_IMPLEMENTATION)
# if defined(__GNUC__)
# define MagickPPExport __attribute__ ((dllimport))
# else
# define MagickPPExport __declspec(dllimport)
# endif
# define MagickPPPrivate extern __declspec(dllimport)
# else
# if defined(__BORLANDC__) || defined(__MINGW32__)
# define MagickPPExport __declspec(dllexport)
# define MagickPPPrivate __declspec(dllexport)
# else
# if defined(__GNUC__)
# define MagickPPExport __attribute__ ((dllexport))
# else
# define MagickPPExport __declspec(dllexport)
# endif
# define MagickPPPrivate extern __declspec(dllexport)
# endif
# endif
# else
# define MagickPPExport
# define MagickPPPrivate
# if defined(_MSC_VER) && defined(STATIC_MAGICK) && !defined(NOAUTOLINK_MAGICK)
# if defined(_DEBUG)
# if defined(MAGICKCORE_BZLIB_DELEGATE)
# pragma comment(lib, "CORE_DB_bzlib_.lib")
# endif
# if defined(MAGICKCORE_CAIRO_DELEGATE)
# pragma comment(lib, "CORE_DB_cairo_.lib")
# endif
# if defined(MAGICKCORE_OPENEXR_DELEGATE)
# pragma comment(lib, "CORE_DB_exr_.lib")
# endif
# if defined(MAGICKCORE_FLIF_DELEGATE)
# pragma comment(lib, "CORE_DB_flif_.lib")
# endif
# if defined(MAGICKCORE_JBIG_DELEGATE)
# pragma comment(lib, "CORE_DB_jbig_.lib")
# endif
# if defined(MAGICKCORE_JP2_DELEGATE)
# pragma comment(lib, "CORE_DB_jp2_.lib")
# endif
# if defined(MAGICKCORE_JPEG_DELEGATE)
# pragma comment(lib, "CORE_DB_jpeg-turbo_.lib")
# endif
# if defined(MAGICKCORE_LCMS_DELEGATE)
# pragma comment(lib, "CORE_DB_lcms_.lib")
# endif
# if defined(MAGICKCORE_HEIC_DELEGATE)
# pragma comment(lib, "CORE_DB_de265_.lib")
# pragma comment(lib, "CORE_DB_heif_.lib")
# endif
# if defined(MAGICKCORE_LZMA_DELEGATE)
# pragma comment(lib, "CORE_DB_lzma_.lib")
# endif
# if defined(MAGICKCORE_RAW_R_DELEGATE)
# pragma comment(lib, "CORE_DB_raw_.lib")
# endif
# if defined(MAGICKCORE_RSVG_DELEGATE)
# pragma comment(lib, "CORE_DB_rsvg_.lib")
# endif
# if defined(MAGICKCORE_XML_DELEGATE)
# pragma comment(lib, "CORE_DB_xml_.lib")
# endif
# if defined(MAGICKCORE_LQR_DELEGATE)
# pragma comment(lib, "CORE_DB_ffi_.lib")
# pragma comment(lib, "CORE_DB_glib_.lib")
# pragma comment(lib, "CORE_DB_lqr_.lib")
# pragma comment(lib, "winmm.lib")
# endif
# if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
# pragma comment(lib, "CORE_DB_openjpeg_.lib")
# endif
# if defined(MAGICKCORE_PANGOCAIRO_DELEGATE)
# pragma comment(lib, "CORE_DB_pango_.lib")
# pragma comment(lib, "CORE_DB_pixman_.lib")
# endif
# if defined(MAGICKCORE_PNG_DELEGATE)
# pragma comment(lib, "CORE_DB_png_.lib")
# endif
# if defined(MAGICKCORE_RAQM_DELEGATE)
# pragma comment(lib, "CORE_DB_raqm_.lib")
# endif
# if defined(MAGICKCORE_TIFF_DELEGATE)
# pragma comment(lib, "CORE_DB_tiff_.lib")
# endif
# if defined(MAGICKCORE_FREETYPE_DELEGATE)
# pragma comment(lib, "CORE_DB_ttf_.lib")
# endif
# if defined(MAGICKCORE_WEBP_DELEGATE)
# pragma comment(lib, "CORE_DB_webp_.lib")
# endif
# if defined(MAGICKCORE_ZLIB_DELEGATE)
# pragma comment(lib, "CORE_DB_zlib_.lib")
# endif
# pragma comment(lib, "CORE_DB_coders_.lib")
# pragma comment(lib, "CORE_DB_filters_.lib")
# pragma comment(lib, "CORE_DB_Magick++_.lib")
# pragma comment(lib, "CORE_DB_MagickCore_.lib")
# pragma comment(lib, "CORE_DB_MagickWand_.lib")
# else
# if defined(MAGICKCORE_BZLIB_DELEGATE)
# pragma comment(lib, "CORE_RL_bzlib_.lib")
# endif
# if defined(MAGICKCORE_CAIRO_DELEGATE)
# pragma comment(lib, "CORE_RL_cairo_.lib")
# endif
# if defined(MAGICKCORE_OPENEXR_DELEGATE)
# pragma comment(lib, "CORE_RL_exr_.lib")
# endif
# if defined(MAGICKCORE_FLIF_DELEGATE)
# pragma comment(lib, "CORE_RL_flif_.lib")
# endif
# if defined(MAGICKCORE_JBIG_DELEGATE)
# pragma comment(lib, "CORE_RL_jbig_.lib")
# endif
# if defined(MAGICKCORE_JP2_DELEGATE)
# pragma comment(lib, "CORE_RL_jp2_.lib")
# endif
# if defined(MAGICKCORE_JPEG_DELEGATE)
# pragma comment(lib, "CORE_RL_jpeg-turbo_.lib")
# endif
# if defined(MAGICKCORE_LCMS_DELEGATE)
# pragma comment(lib, "CORE_RL_lcms_.lib")
# endif
# if defined(MAGICKCORE_HEIC_DELEGATE)
# pragma comment(lib, "CORE_RL_de265_.lib")
# pragma comment(lib, "CORE_RL_heif_.lib")
# endif
# if defined(MAGICKCORE_LZMA_DELEGATE)
# pragma comment(lib, "CORE_RL_lzma_.lib")
# endif
# if defined(MAGICKCORE_RAW_R_DELEGATE)
# pragma comment(lib, "CORE_RL_raw_.lib")
# endif
# if defined(MAGICKCORE_RSVG_DELEGATE)
# pragma comment(lib, "CORE_RL_rsvg_.lib")
# endif
# if defined(MAGICKCORE_XML_DELEGATE)
# pragma comment(lib, "CORE_RL_xml_.lib")
# endif
# if defined(MAGICKCORE_LQR_DELEGATE)
# pragma comment(lib, "CORE_RL_ffi_.lib")
# pragma comment(lib, "CORE_RL_glib_.lib")
# pragma comment(lib, "CORE_RL_lqr_.lib")
# pragma comment(lib, "winmm.lib")
# endif
# if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
# pragma comment(lib, "CORE_RL_openjpeg_.lib")
# endif
# if defined(MAGICKCORE_PANGOCAIRO_DELEGATE)
# pragma comment(lib, "CORE_RL_pango_.lib")
# pragma comment(lib, "CORE_RL_pixman_.lib")
# endif
# if defined(MAGICKCORE_PNG_DELEGATE)
# pragma comment(lib, "CORE_RL_png_.lib")
# endif
# if defined(MAGICKCORE_RAQM_DELEGATE)
# pragma comment(lib, "CORE_RL_raqm_.lib")
# endif
# if defined(MAGICKCORE_TIFF_DELEGATE)
# pragma comment(lib, "CORE_RL_tiff_.lib")
# endif
# if defined(MAGICKCORE_FREETYPE_DELEGATE)
# pragma comment(lib, "CORE_RL_ttf_.lib")
# endif
# if defined(MAGICKCORE_WEBP_DELEGATE)
# pragma comment(lib, "CORE_RL_webp_.lib")
# endif
# if defined(MAGICKCORE_ZLIB_DELEGATE)
# pragma comment(lib, "CORE_RL_zlib_.lib")
# endif
# pragma comment(lib, "CORE_RL_coders_.lib")
# pragma comment(lib, "CORE_RL_filters_.lib")
# pragma comment(lib, "CORE_RL_Magick++_.lib")
# pragma comment(lib, "CORE_RL_magick_.lib")
# pragma comment(lib, "CORE_RL_wand_.lib")
# endif
# if defined(_WIN32_WCE)
# pragma comment(lib, "wsock32.lib")
# else
# pragma comment(lib, "ws2_32.lib")
# endif
# pragma comment(lib, "urlmon.lib")
# endif
# endif
#else
# if __GNUC__ >= 4
# define MagickPPExport __attribute__ ((visibility ("default")))
# define MagickPPPrivate __attribute__ ((visibility ("hidden")))
# else
# define MagickPPExport
# define MagickPPPrivate
# endif
#endif
#if (defined(WIN32) || defined(WIN64)) && defined(_VISUALC_)
# pragma warning(disable : 4996) /* function deprecation warnings */
#endif
//
// Import ImageMagick symbols and types which are used as part of the
// Magick++ API definition into namespace "Magick".
//
namespace Magick
{
// The datatype for an RGB component
using MagickCore::Quantum;
using MagickCore::MagickRealType;
using MagickCore::MagickSizeType;
// Boolean types
using MagickCore::MagickBooleanType;
using MagickCore::MagickFalse;
using MagickCore::MagickTrue;
// Alpha channel types
using MagickCore::AlphaChannelType;
using MagickCore::UndefinedAlphaChannel;
using MagickCore::ActivateAlphaChannel;
using MagickCore::BackgroundAlphaChannel;
using MagickCore::CopyAlphaChannel;
using MagickCore::DeactivateAlphaChannel;
using MagickCore::ExtractAlphaChannel;
using MagickCore::OpaqueAlphaChannel;
using MagickCore::SetAlphaChannel;
using MagickCore::ShapeAlphaChannel;
using MagickCore::TransparentAlphaChannel;
using MagickCore::FlattenAlphaChannel;
using MagickCore::RemoveAlphaChannel;
using MagickCore::AssociateAlphaChannel;
using MagickCore::DisassociateAlphaChannel;
// Image class types
using MagickCore::ClassType;
using MagickCore::UndefinedClass;
using MagickCore::DirectClass;
using MagickCore::PseudoClass;
// Channel types
using MagickCore::ChannelType;
using MagickCore::UndefinedChannel;
using MagickCore::RedChannel;
using MagickCore::GrayChannel;
using MagickCore::CyanChannel;
using MagickCore::GreenChannel;
using MagickCore::MagentaChannel;
using MagickCore::BlueChannel;
using MagickCore::YellowChannel;
using MagickCore::AlphaChannel;
using MagickCore::OpacityChannel;
using MagickCore::MatteChannel; /* deprecated */
using MagickCore::BlackChannel;
using MagickCore::IndexChannel;
using MagickCore::CompositeChannels;
using MagickCore::AllChannels;
using MagickCore::TrueAlphaChannel;
using MagickCore::RGBChannels;
using MagickCore::GrayChannels;
using MagickCore::SyncChannels;
using MagickCore::DefaultChannels;
// Color-space types
using MagickCore::ColorspaceType;
using MagickCore::UndefinedColorspace;
using MagickCore::CMYColorspace;
using MagickCore::CMYKColorspace;
using MagickCore::GRAYColorspace;
using MagickCore::HCLColorspace;
using MagickCore::HCLpColorspace;
using MagickCore::HSBColorspace;
using MagickCore::HSIColorspace;
using MagickCore::HSLColorspace;
using MagickCore::HSVColorspace;
using MagickCore::HWBColorspace;
using MagickCore::LabColorspace;
using MagickCore::LCHColorspace;
using MagickCore::LCHabColorspace;
using MagickCore::LCHuvColorspace;
using MagickCore::LogColorspace;
using MagickCore::LMSColorspace;
using MagickCore::LuvColorspace;
using MagickCore::OHTAColorspace;
using MagickCore::Rec601LumaColorspace;
using MagickCore::Rec601YCbCrColorspace;
using MagickCore::Rec709LumaColorspace;
using MagickCore::Rec709YCbCrColorspace;
using MagickCore::RGBColorspace;
using MagickCore::scRGBColorspace;
using MagickCore::sRGBColorspace;
using MagickCore::TransparentColorspace;
using MagickCore::XYZColorspace;
using MagickCore::YCbCrColorspace;
using MagickCore::YCCColorspace;
using MagickCore::YDbDrColorspace;
using MagickCore::YIQColorspace;
using MagickCore::YPbPrColorspace;
using MagickCore::YUVColorspace;
using MagickCore::xyYColorspace;
// Command options
using MagickCore::CommandOption;
using MagickCore::MagickDirectionOptions;
using MagickCore::MagickGravityOptions;
using MagickCore::MagickKernelOptions;
using MagickCore::MagickStyleOptions;
// Composition operations
using MagickCore::CompositeOperator;
using MagickCore::UndefinedCompositeOp;
using MagickCore::NoCompositeOp;
using MagickCore::ModulusAddCompositeOp;
using MagickCore::AtopCompositeOp;
using MagickCore::BlendCompositeOp;
using MagickCore::BumpmapCompositeOp;
using MagickCore::ChangeMaskCompositeOp;
using MagickCore::ClearCompositeOp;
using MagickCore::ColorBurnCompositeOp;
using MagickCore::ColorDodgeCompositeOp;
using MagickCore::ColorizeCompositeOp;
using MagickCore::CopyBlackCompositeOp;
using MagickCore::CopyBlueCompositeOp;
using MagickCore::CopyCompositeOp;
using MagickCore::CopyCyanCompositeOp;
using MagickCore::CopyGreenCompositeOp;
using MagickCore::CopyMagentaCompositeOp;
using MagickCore::CopyOpacityCompositeOp;
using MagickCore::CopyRedCompositeOp;
using MagickCore::CopyYellowCompositeOp;
using MagickCore::DarkenCompositeOp;
using MagickCore::DstAtopCompositeOp;
using MagickCore::DstCompositeOp;
using MagickCore::DstInCompositeOp;
using MagickCore::DstOutCompositeOp;
using MagickCore::DstOverCompositeOp;
using MagickCore::DifferenceCompositeOp;
using MagickCore::DisplaceCompositeOp;
using MagickCore::DissolveCompositeOp;
using MagickCore::ExclusionCompositeOp;
using MagickCore::HardLightCompositeOp;
using MagickCore::HardMixCompositeOp;
using MagickCore::HueCompositeOp;
using MagickCore::InCompositeOp;
using MagickCore::LightenCompositeOp;
using MagickCore::LinearLightCompositeOp;
using MagickCore::LuminizeCompositeOp;
using MagickCore::MinusDstCompositeOp;
using MagickCore::ModulateCompositeOp;
using MagickCore::MultiplyCompositeOp;
using MagickCore::OutCompositeOp;
using MagickCore::OverCompositeOp;
using MagickCore::OverlayCompositeOp;
using MagickCore::PlusCompositeOp;
using MagickCore::ReplaceCompositeOp;
using MagickCore::SaturateCompositeOp;
using MagickCore::ScreenCompositeOp;
using MagickCore::SoftLightCompositeOp;
using MagickCore::SrcAtopCompositeOp;
using MagickCore::SrcCompositeOp;
using MagickCore::SrcInCompositeOp;
using MagickCore::SrcOutCompositeOp;
using MagickCore::SrcOverCompositeOp;
using MagickCore::ModulusSubtractCompositeOp;
using MagickCore::ThresholdCompositeOp;
using MagickCore::XorCompositeOp;
using MagickCore::DivideDstCompositeOp;
using MagickCore::DistortCompositeOp;
using MagickCore::BlurCompositeOp;
using MagickCore::PegtopLightCompositeOp;
using MagickCore::VividLightCompositeOp;
using MagickCore::PinLightCompositeOp;
using MagickCore::LinearDodgeCompositeOp;
using MagickCore::LinearBurnCompositeOp;
using MagickCore::MathematicsCompositeOp;
using MagickCore::DivideSrcCompositeOp;
using MagickCore::MinusSrcCompositeOp;
using MagickCore::DarkenIntensityCompositeOp;
using MagickCore::LightenIntensityCompositeOp;
using MagickCore::AddCompositeOp;
using MagickCore::SubtractCompositeOp;
using MagickCore::MinusCompositeOp;
using MagickCore::DivideCompositeOp;
// Compression algorithms
using MagickCore::CompressionType;
using MagickCore::UndefinedCompression;
using MagickCore::NoCompression;
using MagickCore::B44ACompression;
using MagickCore::B44Compression;
using MagickCore::BZipCompression;
using MagickCore::DXT1Compression;
using MagickCore::DXT3Compression;
using MagickCore::DXT5Compression;
using MagickCore::FaxCompression;
using MagickCore::Group4Compression;
using MagickCore::JBIG1Compression;
using MagickCore::JBIG2Compression;
using MagickCore::JPEG2000Compression;
using MagickCore::JPEGCompression;
using MagickCore::LosslessJPEGCompression;
using MagickCore::LZMACompression;
using MagickCore::LZWCompression;
using MagickCore::PizCompression;
using MagickCore::Pxr24Compression;
using MagickCore::RLECompression;
using MagickCore::WebPCompression;
using MagickCore::ZipCompression;
using MagickCore::ZipSCompression;
using MagickCore::ZstdCompression;
// Decoration types
using MagickCore::DecorationType;
using MagickCore::UndefinedDecoration;
using MagickCore::NoDecoration;
using MagickCore::UnderlineDecoration;
using MagickCore::OverlineDecoration;
using MagickCore::LineThroughDecoration;
// Direction types
using MagickCore::DirectionType;
using MagickCore::UndefinedDirection;
using MagickCore::RightToLeftDirection;
using MagickCore::LeftToRightDirection;
// Dispose methods
using MagickCore::DisposeType;
using MagickCore::UndefinedDispose;
using MagickCore::NoneDispose;
using MagickCore::BackgroundDispose;
using MagickCore::PreviousDispose;
// Distort methods
using MagickCore::DistortImageMethod;
using MagickCore::UndefinedDistortion;
using MagickCore::AffineDistortion;
using MagickCore::AffineProjectionDistortion;
using MagickCore::ScaleRotateTranslateDistortion;
using MagickCore::PerspectiveDistortion;
using MagickCore::PerspectiveProjectionDistortion;
using MagickCore::BilinearForwardDistortion;
using MagickCore::BilinearDistortion;
using MagickCore::BilinearReverseDistortion;
using MagickCore::PolynomialDistortion;
using MagickCore::ArcDistortion;
using MagickCore::PolarDistortion;
using MagickCore::DePolarDistortion;
using MagickCore::Cylinder2PlaneDistortion;
using MagickCore::Plane2CylinderDistortion;
using MagickCore::BarrelDistortion;
using MagickCore::BarrelInverseDistortion;
using MagickCore::ShepardsDistortion;
using MagickCore::ResizeDistortion;
using MagickCore::SentinelDistortion;
// Dither methods
using MagickCore::DitherMethod;
using MagickCore::UndefinedDitherMethod;
using MagickCore::NoDitherMethod;
using MagickCore::RiemersmaDitherMethod;
using MagickCore::FloydSteinbergDitherMethod;
// Endian options
using MagickCore::EndianType;
using MagickCore::UndefinedEndian;
using MagickCore::LSBEndian;
using MagickCore::MSBEndian;
// Evaluate options
using MagickCore::MagickEvaluateOperator;
using MagickCore::UndefinedEvaluateOperator;
using MagickCore::AddEvaluateOperator;
using MagickCore::AndEvaluateOperator;
using MagickCore::DivideEvaluateOperator;
using MagickCore::LeftShiftEvaluateOperator;
using MagickCore::MaxEvaluateOperator;
using MagickCore::MinEvaluateOperator;
using MagickCore::MultiplyEvaluateOperator;
using MagickCore::OrEvaluateOperator;
using MagickCore::RightShiftEvaluateOperator;
using MagickCore::SetEvaluateOperator;
using MagickCore::SubtractEvaluateOperator;
using MagickCore::XorEvaluateOperator;
using MagickCore::PowEvaluateOperator;
using MagickCore::LogEvaluateOperator;
using MagickCore::ThresholdEvaluateOperator;
using MagickCore::ThresholdBlackEvaluateOperator;
using MagickCore::ThresholdWhiteEvaluateOperator;
using MagickCore::GaussianNoiseEvaluateOperator;
using MagickCore::ImpulseNoiseEvaluateOperator;
using MagickCore::LaplacianNoiseEvaluateOperator;
using MagickCore::MultiplicativeNoiseEvaluateOperator;
using MagickCore::PoissonNoiseEvaluateOperator;
using MagickCore::UniformNoiseEvaluateOperator;
using MagickCore::CosineEvaluateOperator;
using MagickCore::SineEvaluateOperator;
using MagickCore::AddModulusEvaluateOperator;
using MagickCore::MeanEvaluateOperator;
using MagickCore::AbsEvaluateOperator;
using MagickCore::ExponentialEvaluateOperator;
using MagickCore::MedianEvaluateOperator;
using MagickCore::SumEvaluateOperator;
using MagickCore::RootMeanSquareEvaluateOperator;
// Fill rules
using MagickCore::FillRule;
using MagickCore::UndefinedRule;
using MagickCore::EvenOddRule;
using MagickCore::NonZeroRule;
// Filter types
using MagickCore::FilterTypes;
using MagickCore::UndefinedFilter;
using MagickCore::PointFilter;
using MagickCore::BoxFilter;
using MagickCore::TriangleFilter;
using MagickCore::HermiteFilter;
using MagickCore::HanningFilter;
using MagickCore::HammingFilter;
using MagickCore::BlackmanFilter;
using MagickCore::GaussianFilter;
using MagickCore::QuadraticFilter;
using MagickCore::CubicFilter;
using MagickCore::CatromFilter;
using MagickCore::MitchellFilter;
using MagickCore::JincFilter;
using MagickCore::SincFilter;
using MagickCore::SincFastFilter;
using MagickCore::KaiserFilter;
using MagickCore::WelshFilter;
using MagickCore::ParzenFilter;
using MagickCore::BohmanFilter;
using MagickCore::BartlettFilter;
using MagickCore::LagrangeFilter;
using MagickCore::LanczosFilter;
using MagickCore::LanczosSharpFilter;
using MagickCore::Lanczos2Filter;
using MagickCore::Lanczos2SharpFilter;
using MagickCore::RobidouxFilter;
using MagickCore::RobidouxSharpFilter;
using MagickCore::CosineFilter;
using MagickCore::SplineFilter;
using MagickCore::LanczosRadiusFilter;
using MagickCore::SentinelFilter;
// Bit gravity
using MagickCore::GravityType;
using MagickCore::UndefinedGravity;
using MagickCore::ForgetGravity;
using MagickCore::NorthWestGravity;
using MagickCore::NorthGravity;
using MagickCore::NorthEastGravity;
using MagickCore::WestGravity;
using MagickCore::CenterGravity;
using MagickCore::EastGravity;
using MagickCore::SouthWestGravity;
using MagickCore::SouthGravity;
using MagickCore::SouthEastGravity;
using MagickCore::StaticGravity;
// Image types
using MagickCore::ImageType;
using MagickCore::UndefinedType;
using MagickCore::BilevelType;
using MagickCore::GrayscaleType;
using MagickCore::GrayscaleMatteType;
using MagickCore::PaletteType;
using MagickCore::PaletteMatteType;
using MagickCore::TrueColorType;
using MagickCore::TrueColorMatteType;
using MagickCore::ColorSeparationType;
using MagickCore::ColorSeparationMatteType;
using MagickCore::OptimizeType;
using MagickCore::PaletteBilevelMatteType;
// Interlace types
using MagickCore::InterlaceType;
using MagickCore::UndefinedInterlace;
using MagickCore::NoInterlace;
using MagickCore::LineInterlace;
using MagickCore::PlaneInterlace;
using MagickCore::PartitionInterlace;
using MagickCore::GIFInterlace;
using MagickCore::JPEGInterlace;
using MagickCore::PNGInterlace;
// Pixel interpolation methods
using MagickCore::InterpolatePixelMethod;
using MagickCore::UndefinedInterpolatePixel;
using MagickCore::AverageInterpolatePixel;
using MagickCore::BicubicInterpolatePixel;
using MagickCore::BilinearInterpolatePixel;
using MagickCore::FilterInterpolatePixel;
using MagickCore::IntegerInterpolatePixel;
using MagickCore::MeshInterpolatePixel;
using MagickCore::NearestNeighborInterpolatePixel;
using MagickCore::SplineInterpolatePixel;
using MagickCore::Average9InterpolatePixel;
using MagickCore::Average16InterpolatePixel;
using MagickCore::BlendInterpolatePixel;
using MagickCore::BackgroundInterpolatePixel;
using MagickCore::CatromInterpolatePixel;
// Layer method
using MagickCore::ImageLayerMethod;
using MagickCore::UndefinedLayer;
using MagickCore::CoalesceLayer;
using MagickCore::CompareAnyLayer;
using MagickCore::CompareClearLayer;
using MagickCore::CompareOverlayLayer;
using MagickCore::DisposeLayer;
using MagickCore::OptimizeLayer;
using MagickCore::OptimizeImageLayer;
using MagickCore::OptimizePlusLayer;
using MagickCore::OptimizeTransLayer;
using MagickCore::RemoveDupsLayer;
using MagickCore::RemoveZeroLayer;
using MagickCore::CompositeLayer;
using MagickCore::MergeLayer;
using MagickCore::FlattenLayer;
using MagickCore::MosaicLayer;
using MagickCore::TrimBoundsLayer;
// Built-in kernels
using MagickCore::KernelInfoType;
using MagickCore::UndefinedKernel;
using MagickCore::UnityKernel;
using MagickCore::GaussianKernel;
using MagickCore::DoGKernel;
using MagickCore::LoGKernel;
using MagickCore::BlurKernel;
using MagickCore::CometKernel;
using MagickCore::LaplacianKernel;
using MagickCore::SobelKernel;
using MagickCore::FreiChenKernel;
using MagickCore::RobertsKernel;
using MagickCore::PrewittKernel;
using MagickCore::CompassKernel;
using MagickCore::KirschKernel;
using MagickCore::DiamondKernel;
using MagickCore::SquareKernel;
using MagickCore::RectangleKernel;
using MagickCore::OctagonKernel;
using MagickCore::DiskKernel;
using MagickCore::PlusKernel;
using MagickCore::CrossKernel;
using MagickCore::RingKernel;
using MagickCore::PeaksKernel;
using MagickCore::EdgesKernel;
using MagickCore::CornersKernel;
using MagickCore::DiagonalsKernel;
using MagickCore::LineEndsKernel;
using MagickCore::LineJunctionsKernel;
using MagickCore::RidgesKernel;
using MagickCore::ConvexHullKernel;
using MagickCore::ThinSEKernel;
using MagickCore::SkeletonKernel;
using MagickCore::ChebyshevKernel;
using MagickCore::ManhattanKernel;
using MagickCore::OctagonalKernel;
using MagickCore::EuclideanKernel;
using MagickCore::UserDefinedKernel;
using MagickCore::BinomialKernel;
// Line cap types
using MagickCore::LineCap;
using MagickCore::UndefinedCap;
using MagickCore::ButtCap;
using MagickCore::RoundCap;
using MagickCore::SquareCap;
// Line join types
using MagickCore::LineJoin;
using MagickCore::UndefinedJoin;
using MagickCore::MiterJoin;
using MagickCore::RoundJoin;
using MagickCore::BevelJoin;
// Log event types
using MagickCore::LogEventType;
using MagickCore::UndefinedEvents;
using MagickCore::NoEvents;
using MagickCore::TraceEvent;
using MagickCore::AnnotateEvent;
using MagickCore::BlobEvent;
using MagickCore::CacheEvent;
using MagickCore::CoderEvent;
using MagickCore::ConfigureEvent;
using MagickCore::DeprecateEvent;
using MagickCore::DrawEvent;
using MagickCore::ExceptionEvent;
using MagickCore::ImageEvent;
using MagickCore::LocaleEvent;
using MagickCore::ModuleEvent;
using MagickCore::PolicyEvent;
using MagickCore::ResourceEvent;
using MagickCore::TransformEvent;
using MagickCore::UserEvent;
using MagickCore::WandEvent;
using MagickCore::X11Event;
using MagickCore::AccelerateEvent;
using MagickCore::AllEvents;
// Magick functions
using MagickCore::MagickFunction;
using MagickCore::UndefinedFunction;
using MagickCore::ArcsinFunction;
using MagickCore::ArctanFunction;
using MagickCore::PolynomialFunction;
using MagickCore::SinusoidFunction;
// Metric types
using MagickCore::MetricType;
using MagickCore::UndefinedMetric;
using MagickCore::AbsoluteErrorMetric;
using MagickCore::MeanAbsoluteErrorMetric;
using MagickCore::MeanErrorPerPixelMetric;
using MagickCore::MeanSquaredErrorMetric;
using MagickCore::PeakAbsoluteErrorMetric;
using MagickCore::PeakSignalToNoiseRatioMetric;
using MagickCore::RootMeanSquaredErrorMetric;
using MagickCore::NormalizedCrossCorrelationErrorMetric;
using MagickCore::FuzzErrorMetric;
using MagickCore::UndefinedErrorMetric;
using MagickCore::PerceptualHashErrorMetric;
// Morphology methods
using MagickCore::MorphologyMethod;
using MagickCore::UndefinedMorphology;
using MagickCore::ConvolveMorphology;
using MagickCore::CorrelateMorphology;
using MagickCore::ErodeMorphology;
using MagickCore::DilateMorphology;
using MagickCore::ErodeIntensityMorphology;
using MagickCore::DilateIntensityMorphology;
using MagickCore::DistanceMorphology;
using MagickCore::OpenMorphology;
using MagickCore::CloseMorphology;
using MagickCore::OpenIntensityMorphology;
using MagickCore::CloseIntensityMorphology;
using MagickCore::SmoothMorphology;
using MagickCore::EdgeInMorphology;
using MagickCore::EdgeOutMorphology;
using MagickCore::EdgeMorphology;
using MagickCore::TopHatMorphology;
using MagickCore::BottomHatMorphology;
using MagickCore::HitAndMissMorphology;
using MagickCore::ThinningMorphology;
using MagickCore::ThickenMorphology;
using MagickCore::VoronoiMorphology;
using MagickCore::IterativeDistanceMorphology;
// Noise types
using MagickCore::NoiseType;
using MagickCore::UndefinedNoise;
using MagickCore::UniformNoise;
using MagickCore::GaussianNoise;
using MagickCore::MultiplicativeGaussianNoise;
using MagickCore::ImpulseNoise;
using MagickCore::LaplacianNoise;
using MagickCore::PoissonNoise;
// Orientation types
using MagickCore::OrientationType;
using MagickCore::UndefinedOrientation;
using MagickCore::TopLeftOrientation;
using MagickCore::TopRightOrientation;
using MagickCore::BottomRightOrientation;
using MagickCore::BottomLeftOrientation;
using MagickCore::LeftTopOrientation;
using MagickCore::RightTopOrientation;
using MagickCore::RightBottomOrientation;
using MagickCore::LeftBottomOrientation;
// Paint methods
using MagickCore::PaintMethod;
using MagickCore::UndefinedMethod;
using MagickCore::PointMethod;
using MagickCore::ReplaceMethod;
using MagickCore::FloodfillMethod;
using MagickCore::FillToBorderMethod;
using MagickCore::ResetMethod;
// Pixel intensity method
using MagickCore::PixelIntensityMethod;
using MagickCore::UndefinedPixelIntensityMethod;
using MagickCore::AveragePixelIntensityMethod;
using MagickCore::BrightnessPixelIntensityMethod;
using MagickCore::LightnessPixelIntensityMethod;
using MagickCore::Rec601LumaPixelIntensityMethod;
using MagickCore::Rec601LuminancePixelIntensityMethod;
using MagickCore::Rec709LumaPixelIntensityMethod;
using MagickCore::Rec709LuminancePixelIntensityMethod;
using MagickCore::RMSPixelIntensityMethod;
using MagickCore::MSPixelIntensityMethod;
// PixelPacket structure
using MagickCore::PixelPacket;
// Preview types. Not currently used by Magick++
using MagickCore::PreviewType;
using MagickCore::UndefinedPreview;
using MagickCore::RotatePreview;
using MagickCore::ShearPreview;
using MagickCore::RollPreview;
using MagickCore::HuePreview;
using MagickCore::SaturationPreview;
using MagickCore::BrightnessPreview;
using MagickCore::GammaPreview;
using MagickCore::SpiffPreview;
using MagickCore::DullPreview;
using MagickCore::GrayscalePreview;
using MagickCore::QuantizePreview;
using MagickCore::DespecklePreview;
using MagickCore::ReduceNoisePreview;
using MagickCore::AddNoisePreview;
using MagickCore::SharpenPreview;
using MagickCore::BlurPreview;
using MagickCore::ThresholdPreview;
using MagickCore::EdgeDetectPreview;
using MagickCore::SpreadPreview;
using MagickCore::SolarizePreview;
using MagickCore::ShadePreview;
using MagickCore::RaisePreview;
using MagickCore::SegmentPreview;
using MagickCore::SwirlPreview;
using MagickCore::ImplodePreview;
using MagickCore::WavePreview;
using MagickCore::OilPaintPreview;
using MagickCore::CharcoalDrawingPreview;
using MagickCore::JPEGPreview;
// Quantum types
using MagickCore::QuantumType;
using MagickCore::IndexQuantum;
using MagickCore::GrayQuantum;
using MagickCore::IndexAlphaQuantum;
using MagickCore::GrayAlphaQuantum;
using MagickCore::RedQuantum;
using MagickCore::CyanQuantum;
using MagickCore::GreenQuantum;
using MagickCore::YellowQuantum;
using MagickCore::BlueQuantum;
using MagickCore::MagentaQuantum;
using MagickCore::AlphaQuantum;
using MagickCore::BlackQuantum;
using MagickCore::RGBQuantum;
using MagickCore::RGBAQuantum;
using MagickCore::CMYKQuantum;
// Rendering intents
using MagickCore::RenderingIntent;
using MagickCore::UndefinedIntent;
using MagickCore::SaturationIntent;
using MagickCore::PerceptualIntent;
using MagickCore::AbsoluteIntent;
using MagickCore::RelativeIntent;
// Resource types
using MagickCore::ResourceType;
using MagickCore::AreaResource;
using MagickCore::DiskResource;
using MagickCore::FileResource;
using MagickCore::MapResource;
using MagickCore::MemoryResource;
using MagickCore::ThreadResource;
using MagickCore::TimeResource;
using MagickCore::ThrottleResource;
using MagickCore::WidthResource;
using MagickCore::HeightResource;
using MagickCore::ListLengthResource;
// Resolution units
using MagickCore::ResolutionType;
using MagickCore::UndefinedResolution;
using MagickCore::PixelsPerInchResolution;
using MagickCore::PixelsPerCentimeterResolution;
// IndexPacket type
using MagickCore::IndexPacket;
// Sparse Color methods
using MagickCore::SparseColorMethod;
using MagickCore::UndefinedColorInterpolate;
using MagickCore::BarycentricColorInterpolate;
using MagickCore::BilinearColorInterpolate;
using MagickCore::PolynomialColorInterpolate;
using MagickCore::ShepardsColorInterpolate;
using MagickCore::VoronoiColorInterpolate;
using MagickCore::InverseColorInterpolate;
using MagickCore::ManhattanColorInterpolate;
// Statistic type
using MagickCore::MedianStatistic;
using MagickCore::NonpeakStatistic;
// StorageType type
using MagickCore::StorageType;
using MagickCore::UndefinedPixel;
using MagickCore::CharPixel;
using MagickCore::DoublePixel;
using MagickCore::FloatPixel;
using MagickCore::IntegerPixel;
using MagickCore::LongPixel;
using MagickCore::QuantumPixel;
using MagickCore::ShortPixel;
// StretchType type
using MagickCore::StretchType;
using MagickCore::UndefinedStretch;
using MagickCore::NormalStretch;
using MagickCore::UltraCondensedStretch;
using MagickCore::ExtraCondensedStretch;
using MagickCore::CondensedStretch;
using MagickCore::SemiCondensedStretch;
using MagickCore::SemiExpandedStretch;
using MagickCore::ExpandedStretch;
using MagickCore::ExtraExpandedStretch;
using MagickCore::UltraExpandedStretch;
using MagickCore::AnyStretch;
// StyleType type
using MagickCore::StyleType;
using MagickCore::UndefinedStyle;
using MagickCore::NormalStyle;
using MagickCore::ItalicStyle;
using MagickCore::ObliqueStyle;
using MagickCore::AnyStyle;
// Virtual pixel methods
using MagickCore::VirtualPixelMethod;
using MagickCore::UndefinedVirtualPixelMethod;
using MagickCore::BackgroundVirtualPixelMethod;
using MagickCore::DitherVirtualPixelMethod;
using MagickCore::EdgeVirtualPixelMethod;
using MagickCore::MirrorVirtualPixelMethod;
using MagickCore::RandomVirtualPixelMethod;
using MagickCore::TileVirtualPixelMethod;
using MagickCore::TransparentVirtualPixelMethod;
using MagickCore::MaskVirtualPixelMethod;
using MagickCore::BlackVirtualPixelMethod;
using MagickCore::GrayVirtualPixelMethod;
using MagickCore::WhiteVirtualPixelMethod;
using MagickCore::HorizontalTileVirtualPixelMethod;
using MagickCore::VerticalTileVirtualPixelMethod;
using MagickCore::HorizontalTileEdgeVirtualPixelMethod;
using MagickCore::VerticalTileEdgeVirtualPixelMethod;
using MagickCore::CheckerTileVirtualPixelMethod;
#if defined(MAGICKCORE_IMPLEMENTATION)
//
// ImageMagick symbols used in implementation code
//
using MagickCore::AcquireExceptionInfo;
using MagickCore::AcquireCacheView;
using MagickCore::AcquireDrawingWand;
using MagickCore::AcquireImage;
using MagickCore::AcquireKernelInfo;
using MagickCore::AcquireMagickMemory;
using MagickCore::AcquireQuantumInfo;
using MagickCore::AcquireString;
using MagickCore::AcquireStringInfo;
using MagickCore::AcquireVirtualCacheView;
using MagickCore::AdaptiveBlurImage;
using MagickCore::AdaptiveResizeImage;
using MagickCore::AdaptiveSharpenImage;
using MagickCore::AdaptiveSharpenImageChannel;
using MagickCore::AdaptiveThresholdImage;
using MagickCore::AddNoiseImage;
using MagickCore::AddNoiseImageChannel;
using MagickCore::AffineMatrix;
using MagickCore::AffineTransformImage;
using MagickCore::AnnotateImage;
using MagickCore::AreaValue;
using MagickCore::AspectValue;
using MagickCore::AutoGammaImage;
using MagickCore::AutoGammaImageChannel;
using MagickCore::AutoLevelImage;
using MagickCore::AutoLevelImageChannel;
using MagickCore::AutoOrientImage;
using MagickCore::Base64Decode;
using MagickCore::Base64Encode;
using MagickCore::BilevelImage;
using MagickCore::BlackThresholdImage;
using MagickCore::BlackThresholdImageChannel;
using MagickCore::BlobError;
using MagickCore::BlobFatalError;
using MagickCore::BlobToImage;
using MagickCore::BlobWarning;
using MagickCore::BlueShiftImage;
using MagickCore::BlurImage;
using MagickCore::BlurImageChannel;
using MagickCore::BorderImage;
using MagickCore::BrightnessContrastImage;
using MagickCore::BrightnessContrastImageChannel;
using MagickCore::CacheError;
using MagickCore::CacheFatalError;
using MagickCore::CacheWarning;
using MagickCore::CannyEdgeImage;
using MagickCore::CharcoalImage;
using MagickCore::ChopImage;
using MagickCore::ClampImage;
using MagickCore::ClampImageChannel;
using MagickCore::ClearMagickException;
using MagickCore::CloneDrawInfo;
using MagickCore::CloneImage;
using MagickCore::CloneImageInfo;
using MagickCore::CloneQuantizeInfo;
using MagickCore::ClutImage;
using MagickCore::ClutImageChannel;
using MagickCore::CoderError;
using MagickCore::CoderFatalError;
using MagickCore::CoderWarning;
using MagickCore::CopyImagePixels;
using MagickCore::ColorDecisionListImage;
using MagickCore::ColorizeImage;
using MagickCore::ColorMatrixImage;
using MagickCore::ColorPacket;
using MagickCore::CommandOptionToMnemonic;
using MagickCore::CompareImageChannels;
using MagickCore::CompareImages;
using MagickCore::CompositeImage;
using MagickCore::ConfigureError;
using MagickCore::ConfigureFatalError;
using MagickCore::ConfigureWarning;
using MagickCore::ConnectedComponentsImage;
using MagickCore::ConstituteImage;
using MagickCore::ContrastImage;
using MagickCore::ContrastStretchImageChannel;
using MagickCore::ConvertHSLToRGB;
using MagickCore::ConvertRGBToHSL;
using MagickCore::ConvolveImage;
using MagickCore::CopyMagickString;
using MagickCore::CorruptImageError;
using MagickCore::CorruptImageFatalError;
using MagickCore::CorruptImageWarning;
using MagickCore::CropImage;
using MagickCore::CropImageToTiles;
using MagickCore::CycleColormapImage;
using MagickCore::DeconstructImages;
using MagickCore::DecipherImage;
using MagickCore::DelegateError;
using MagickCore::DelegateFatalError;
using MagickCore::DelegateWarning;
using MagickCore::DeleteImageOption;
using MagickCore::DeleteImageRegistry;
using MagickCore::DeskewImage;
using MagickCore::DespeckleImage;
using MagickCore::DestroyCacheView;
using MagickCore::DestroyDrawInfo;
using MagickCore::DestroyDrawingWand;
using MagickCore::DestroyExceptionInfo;
using MagickCore::DestroyImageInfo;
using MagickCore::DestroyImageList;
using MagickCore::DestroyKernelInfo;
using MagickCore::DestroyMagickWand;
using MagickCore::DestroyPixelWand;
using MagickCore::DestroyQuantizeInfo;
using MagickCore::DestroyQuantumInfo;
using MagickCore::DestroyString;
using MagickCore::DestroyStringInfo;
using MagickCore::DisplayImages;
using MagickCore::DistortImage;
using MagickCore::DrawAffine;
using MagickCore::DrawAnnotation;
using MagickCore::DrawArc;
using MagickCore::DrawBezier;
using MagickCore::DrawCircle;
using MagickCore::DrawColor;
using MagickCore::DrawComment;
using MagickCore::DrawComposite;
using MagickCore::DrawEllipse;
using MagickCore::DrawError;
using MagickCore::DrawFatalError;
using MagickCore::DrawImage;
using MagickCore::DrawInfo;
using MagickCore::DrawingWand;
using MagickCore::DrawLine;
using MagickCore::DrawMatte;
using MagickCore::DrawPathClose;
using MagickCore::DrawPathCurveToAbsolute;
using MagickCore::DrawPathCurveToQuadraticBezierAbsolute;
using MagickCore::DrawPathCurveToQuadraticBezierRelative;
using MagickCore::DrawPathCurveToQuadraticBezierSmoothAbsolute;
using MagickCore::DrawPathCurveToQuadraticBezierSmoothRelative;
using MagickCore::DrawPathCurveToRelative;
using MagickCore::DrawPathCurveToSmoothAbsolute;
using MagickCore::DrawPathCurveToSmoothRelative;
using MagickCore::DrawPathEllipticArcAbsolute;
using MagickCore::DrawPathEllipticArcRelative;
using MagickCore::DrawPathFinish;
using MagickCore::DrawPathLineToAbsolute;
using MagickCore::DrawPathLineToHorizontalAbsolute;
using MagickCore::DrawPathLineToHorizontalRelative;
using MagickCore::DrawPathLineToRelative;
using MagickCore::DrawPathLineToVerticalAbsolute;
using MagickCore::DrawPathLineToVerticalRelative;
using MagickCore::DrawPathMoveToAbsolute;
using MagickCore::DrawPathMoveToRelative;
using MagickCore::DrawPathStart;
using MagickCore::DrawPoint;
using MagickCore::DrawPolygon;
using MagickCore::DrawPolyline;
using MagickCore::DrawPopClipPath;
using MagickCore::DrawPopDefs;
using MagickCore::DrawPopPattern;
using MagickCore::DrawPushClipPath;
using MagickCore::DrawPushDefs;
using MagickCore::DrawPushPattern;
using MagickCore::DrawRectangle;
using MagickCore::DrawRender;
using MagickCore::DrawRotate;
using MagickCore::DrawRoundRectangle;
using MagickCore::DrawScale;
using MagickCore::DrawSetClipPath;
using MagickCore::DrawSetClipRule;
using MagickCore::DrawSetClipUnits;
using MagickCore::DrawSetFillColor;
using MagickCore::DrawSetFillOpacity;
using MagickCore::DrawSetFillPatternURL;
using MagickCore::DrawSetFillRule;
using MagickCore::DrawSetFont;
using MagickCore::DrawSetFontFamily;
using MagickCore::DrawSetFontSize;
using MagickCore::DrawSetFontStretch;
using MagickCore::DrawSetFontStyle;
using MagickCore::DrawSetFontWeight;
using MagickCore::DrawSetGravity;
using MagickCore::DrawSetStrokeAntialias;
using MagickCore::DrawSetStrokeColor;
using MagickCore::DrawSetStrokeDashArray;
using MagickCore::DrawSetStrokeDashOffset;
using MagickCore::DrawSetStrokeLineCap;
using MagickCore::DrawSetStrokeLineJoin;
using MagickCore::DrawSetStrokeMiterLimit;
using MagickCore::DrawSetStrokeOpacity;
using MagickCore::DrawSetStrokePatternURL;
using MagickCore::DrawSetStrokeWidth;
using MagickCore::DrawSetTextAntialias;
using MagickCore::DrawSetTextDecoration;
using MagickCore::DrawSetTextEncoding;
using MagickCore::DrawSetTextInterlineSpacing;
using MagickCore::DrawSetTextInterwordSpacing;
using MagickCore::DrawSetTextKerning;
using MagickCore::DrawSetTextUnderColor;
using MagickCore::DrawSetViewbox;
using MagickCore::DrawSkewX;
using MagickCore::DrawSkewY;
using MagickCore::DrawTranslate;
using MagickCore::DrawWarning;
using MagickCore::EdgeImage;
using MagickCore::EmbossImage;
using MagickCore::EncipherImage;
using MagickCore::EnhanceImage;
using MagickCore::EqualizeImage;
using MagickCore::EvaluateImage;
using MagickCore::EvaluateImageChannel;
using MagickCore::ExceptionInfo;
using MagickCore::ExceptionType;
using MagickCore::ExportImagePixels;
using MagickCore::ExportQuantumPixels;
using MagickCore::ExtentImage;
using MagickCore::FileOpenError;
using MagickCore::FileOpenFatalError;
using MagickCore::FileOpenWarning;
using MagickCore::FlipImage;
using MagickCore::FloodfillPaintImage;
using MagickCore::FlopImage;
using MagickCore::FormatLocaleString;
using MagickCore::ForwardFourierTransformImage;
using MagickCore::FrameImage;
using MagickCore::FrameInfo;
using MagickCore::FxImageChannel;
using MagickCore::GammaImage;
using MagickCore::GammaImage;
using MagickCore::GaussianBlurImage;
using MagickCore::GaussianBlurImageChannel;
using MagickCore::GetAffineMatrix;
using MagickCore::GetAuthenticIndexQueue;
using MagickCore::GetBlobSize;
using MagickCore::GetCacheViewException;
using MagickCore::GetCacheViewAuthenticIndexQueue;
using MagickCore::GetCacheViewAuthenticPixels;
using MagickCore::GetCacheViewVirtualPixels;
using MagickCore::GetClientName;
using MagickCore::GetColorTuple;
using MagickCore::GetDrawInfo;
using MagickCore::GetGeometry;
using MagickCore::GetImageArtifact;
using MagickCore::GetImageBoundingBox;
using MagickCore::GetImageChannelDistortion;
using MagickCore::GetImageChannelDepth;
using MagickCore::GetImageChannelMean;
using MagickCore::GetImageChannelKurtosis;
using MagickCore::GetImageChannelMoments;
using MagickCore::GetImageChannelRange;
using MagickCore::GetImageClipMask;
using MagickCore::GetImageDepth;
using MagickCore::GetImageDistortion;
using MagickCore::GetImageInfo;
using MagickCore::GetImageInfoFile;
using MagickCore::GetImageMask;
using MagickCore::GetImageOption;
using MagickCore::GetAuthenticPixels;
using MagickCore::GetImageProfile;
using MagickCore::GetImageProperty;
using MagickCore::GetImageQuantizeError;
using MagickCore::GetImageType;
using MagickCore::GetMagickInfo;
using MagickCore::GetMagickPixelPacket;
using MagickCore::GetMultilineTypeMetrics;
using MagickCore::GetNextValueInLinkedList;
using MagickCore::GetNumberColors;
using MagickCore::GetNumberOfElementsInLinkedList;
using MagickCore::GetPageGeometry;
using MagickCore::GetQuantizeInfo;
using MagickCore::GetStringInfoDatum;
using MagickCore::GetStringInfoLength;
using MagickCore::GetTypeMetrics;
using MagickCore::GetValueFromLinkedList;
using MagickCore::GetVirtualIndexQueue;
using MagickCore::GetVirtualPixels;
using MagickCore::GetImageVirtualPixelMethod;
using MagickCore::GlobExpression;
using MagickCore::GravityAdjustGeometry;
using MagickCore::GrayscaleImage;
using MagickCore::GreaterValue;
using MagickCore::HaldClutImage;
using MagickCore::HeightValue;
using MagickCore::HoughLineImage;
using MagickCore::ImageError;
using MagickCore::ImageFatalError;
using MagickCore::ImageInfo;
using MagickCore::ImageRegistryType;
using MagickCore::ImageToBlob;
using MagickCore::ImagesToBlob;
using MagickCore::ImageWarning;
using MagickCore::ImplodeImage;
using MagickCore::ImportQuantumPixels;
using MagickCore::InterpretImageProperties;
using MagickCore::InverseFourierTransformImage;
using MagickCore::InvokeDynamicImageFilter;
using MagickCore::IsEventLogging;
using MagickCore::IsGeometry;
using MagickCore::IsImagesEqual;
using MagickCore::IsOpaqueImage;
using MagickCore::KernelInfo;
using MagickCore::KuwaharaImage;
using MagickCore::LessValue;
using MagickCore::LevelImage;
using MagickCore::LevelImageChannel;
using MagickCore::LevelColorsImageChannel;
using MagickCore::LevelizeImage;
using MagickCore::LevelizeImageChannel;
using MagickCore::LinearStretchImage;
using MagickCore::LinkedListInfo;
using MagickCore::LiquidRescaleImage;
using MagickCore::LocaleCompare;
using MagickCore::LocalContrastImage;
using MagickCore::LockSemaphoreInfo;
using MagickCore::LogMagickEvent;
using MagickCore::MagickCoreTerminus;
using MagickCore::MagickInfo;
using MagickCore::MagickPixelPacket;
using MagickCore::MagickToMime;
using MagickCore::MagickWand;
using MagickCore::MagnifyImage;
using MagickCore::MergeImageLayers;
using MagickCore::MinifyImage;
using MagickCore::MinimumValue;
using MagickCore::MissingDelegateError;
using MagickCore::MissingDelegateFatalError;
using MagickCore::MissingDelegateWarning;
using MagickCore::ModulateImage;
using MagickCore::ModuleError;
using MagickCore::ModuleFatalError;
using MagickCore::ModuleWarning;
using MagickCore::MonitorError;
using MagickCore::MonitorFatalError;
using MagickCore::MonitorWarning;
using MagickCore::MontageInfo;
using MagickCore::MorphologyImage;
using MagickCore::MorphologyImageChannel;
using MagickCore::MotionBlurImage;
using MagickCore::NegateImage;
using MagickCore::NegateImageChannel;
using MagickCore::NewMagickWandFromImage;
using MagickCore::NewPixelWand;
using MagickCore::NoiseType;
using MagickCore::NormalizeImage;
using MagickCore::NoValue;
using MagickCore::OffsetInfo;
using MagickCore::OilPaintImage;
using MagickCore::OpaquePaintImage;
using MagickCore::OrderedPosterizeImage;
using MagickCore::OptionError;
using MagickCore::OptionFatalError;
using MagickCore::OptionWarning;
using MagickCore::OptimizeImageLayers;
using MagickCore::OptimizeImageTransparency;
using MagickCore::OptimizePlusImageLayers;
using MagickCore::ParseMetaGeometry;
using MagickCore::PercentValue;
using MagickCore::PerceptibleImage;
using MagickCore::PerceptibleImageChannel;
using MagickCore::PingBlob;
using MagickCore::PingImage;
using MagickCore::PixelSetQuantumColor;
using MagickCore::PixelWand;
using MagickCore::PointInfo;
using MagickCore::PopDrawingWand;
using MagickCore::PolaroidImage;
using MagickCore::PolicyWarning;
using MagickCore::PolicyError;
using MagickCore::PolicyFatalError;
using MagickCore::PosterizeImage;
using MagickCore::PosterizeImageChannel;
using MagickCore::ProfileImage;
using MagickCore::ProfileInfo;
using MagickCore::PushDrawingWand;
using MagickCore::QuantizeImage;
using MagickCore::QuantizeInfo;
using MagickCore::QuantumInfo;
using MagickCore::QueryColorDatabase;
using MagickCore::QueryMagickColor;
using MagickCore::QueueAuthenticPixels;
using MagickCore::QueueCacheViewAuthenticPixels;
using MagickCore::RaiseImage;
using MagickCore::RandomThresholdImageChannel;
using MagickCore::ReadImage;
using MagickCore::RectangleInfo;
using MagickCore::RegisterMagickInfo;
using MagickCore::RegistryError;
using MagickCore::RegistryFatalError;
using MagickCore::RegistryType;
using MagickCore::RegistryWarning;
using MagickCore::RelinquishMagickMemory;
using MagickCore::RemapImage;
using MagickCore::ResampleImage;
using MagickCore::ResetLinkedListIterator;
using MagickCore::ResizeImage;
using MagickCore::ResizeMagickMemory;
using MagickCore::ResourceLimitError;
using MagickCore::ResourceLimitFatalError;
using MagickCore::ResourceLimitWarning;
using MagickCore::RollImage;
using MagickCore::RotateImage;
using MagickCore::RotationalBlurImage;
using MagickCore::RotationalBlurImageChannel;
using MagickCore::SampleImage;
using MagickCore::ScaleImage;
using MagickCore::SegmentImage;
using MagickCore::SelectiveBlurImage;
using MagickCore::SelectiveBlurImageChannel;
using MagickCore::SeparateImageChannel;
using MagickCore::SepiaToneImage;
using MagickCore::SetGeometry;
using MagickCore::SetImageAlphaChannel;
using MagickCore::SetImageArtifact;
using MagickCore::SetImageBackgroundColor;
using MagickCore::SetImageChannelDepth;
using MagickCore::SetImageClipMask;
using MagickCore::SetImageColorspace;
using MagickCore::SetImageDepth;
using MagickCore::SetImageExtent;
using MagickCore::SetImageInfo;
using MagickCore::SetImageInfoFile;
using MagickCore::SetImageMask;
using MagickCore::SetImageOpacity;
using MagickCore::SetImageOption;
using MagickCore::SetImageProfile;
using MagickCore::SetImageProperty;
using MagickCore::SetImageRegistry;
using MagickCore::SetImageType;
using MagickCore::SetLogEventMask;
using MagickCore::SetMagickInfo;
using MagickCore::SetMagickResourceLimit;
using MagickCore::SetStringInfoDatum;
using MagickCore::SetImageVirtualPixelMethod;
using MagickCore::ShadeImage;
using MagickCore::ShadowImage;
using MagickCore::SharpenImage;
using MagickCore::SharpenImageChannel;
using MagickCore::ShaveImage;
using MagickCore::ShearImage;
using MagickCore::SimilarityMetricImage;
using MagickCore::SigmoidalContrastImageChannel;
using MagickCore::SignatureImage;
using MagickCore::SketchImage;
using MagickCore::SmushImages;
using MagickCore::SolarizeImage;
using MagickCore::SparseColorImage;
using MagickCore::SpliceImage;
using MagickCore::SpreadImage;
using MagickCore::StatisticImage;
using MagickCore::SteganoImage;
using MagickCore::StereoImage;
using MagickCore::StreamError;
using MagickCore::StreamFatalError;
using MagickCore::StreamWarning;
using MagickCore::StringInfo;
using MagickCore::StripImage;
using MagickCore::SwirlImage;
using MagickCore::SyncCacheViewAuthenticPixels;
using MagickCore::SyncImage;
using MagickCore::SyncAuthenticPixels;
using MagickCore::TextureImage;
using MagickCore::ThrowException;
using MagickCore::TintImage;
using MagickCore::TransformImage;
using MagickCore::TransformImageColorspace;
using MagickCore::TransparentPaintImage;
using MagickCore::TransparentPaintImageChroma;
using MagickCore::TransposeImage;
using MagickCore::TransverseImage;
using MagickCore::TrimImage;
using MagickCore::TypeError;
using MagickCore::TypeFatalError;
using MagickCore::TypeWarning;
using MagickCore::UndefinedException;
using MagickCore::UndefinedRegistryType;
using MagickCore::UniqueImageColors;
using MagickCore::UnlockSemaphoreInfo;
using MagickCore::UnregisterMagickInfo;
using MagickCore::UnsharpMaskImage;
using MagickCore::UnsharpMaskImageChannel;
using MagickCore::VignetteImage;
using MagickCore::CacheView;
using MagickCore::WaveImage;
using MagickCore::WaveletDenoiseImage;
using MagickCore::WhiteThresholdImage;
using MagickCore::WhiteThresholdImageChannel;
using MagickCore::WidthValue;
using MagickCore::WriteImage;
using MagickCore::XNegative;
using MagickCore::XServerError;
using MagickCore::XServerFatalError;
using MagickCore::XServerWarning;
using MagickCore::XValue;
using MagickCore::YNegative;
using MagickCore::YValue;
#endif // MAGICKCORE_IMPLEMENTATION
}
//////////////////////////////////////////////////////////////////////
//
// No user-serviceable parts beyond this point
//
//////////////////////////////////////////////////////////////////////
#define GetPPException \
MagickCore::ExceptionInfo \
*exceptionInfo; \
exceptionInfo=MagickCore::AcquireExceptionInfo()
#define ThrowPPException(quiet) \
throwException(exceptionInfo,quiet); \
(void) MagickCore::DestroyExceptionInfo(exceptionInfo)
#endif // Magick_Include_header
Magick++/Drawable.h 0000644 00000202616 15051111170 0007756 0 ustar 00 // This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002
// Copyright Dirk Lemstra 2014-2017
//
// Definition of Drawable (Graphic objects)
//
// The technique used for instantiating classes which derive from STL
// templates is described in Microsoft MSDN Article ID: Q168958
// "HOWTO: Exporting STL Components Inside & Outside of a Class".
// "http://support.microsoft.com/kb/168958"
//
// Note that version 3.0 of this article says that only STL
// container template which supports DLL export is <vector> and we are
// not using <vector> as part of the Drawable implementation.
//
#if !defined(Magick_Drawable_header)
#define Magick_Drawable_header
#include "Magick++/Include.h"
#include <functional>
#include <string>
#include <list>
#include <utility>
#include "Magick++/Color.h"
#include "Magick++/Geometry.h"
#if defined(MagickDLLExplicitTemplate)
# if defined(MAGICK_PLUSPLUS_IMPLEMENTATION)
# define MagickDrawableExtern
# else
# pragma warning( disable: 4231 ) // Disable warning regarding using extern
# define MagickDrawableExtern extern
# endif // MAGICK_PLUSPLUS_IMPLEMENTATION
#else
# define MagickDrawableExtern
#endif // MagickDLLExplicitTemplate
namespace Magick
{
//
// Representation of an x,y coordinate
//
class MagickPPExport Coordinate
{
public:
Coordinate ( void )
: _x(0),
_y(0)
{ }
Coordinate ( double x_, double y_ )
: _x(x_),
_y(y_)
{ }
virtual ~Coordinate ()
{ }
void x ( double x_ )
{
_x = x_;
}
double x ( void ) const
{
return _x;
}
void y ( double y_ )
{
_y = y_;
}
double y ( void ) const
{
return _y;
}
private:
double _x;
double _y;
};
typedef std::list<Magick::Coordinate> CoordinateList;
#if defined(MagickDLLExplicitTemplate)
MagickDrawableExtern template class MagickPPExport
std::allocator<Magick::Coordinate>;
#endif // MagickDLLExplicitTemplate
// Compare two Coordinate objects regardless of LHS/RHS
MagickPPExport int operator == ( const Coordinate& left_,
const Coordinate& right_ );
MagickPPExport int operator != ( const Coordinate& left_,
const Coordinate& right_ );
MagickPPExport int operator > ( const Coordinate& left_,
const Coordinate& right_ );
MagickPPExport int operator < ( const Coordinate& left_,
const Coordinate& right_ );
MagickPPExport int operator >= ( const Coordinate& left_,
const Coordinate& right_ );
MagickPPExport int operator <= ( const Coordinate& left_,
const Coordinate& right_ );
//
// Base class for all drawable objects
//
class MagickPPExport DrawableBase
{
public:
// Constructor
DrawableBase ( void )
{ }
// Destructor
virtual ~DrawableBase ( void );
// Operator to invoke equivalent draw API call
virtual void operator()( MagickCore::DrawingWand *) const = 0;
// Return polymorphic copy of object
virtual DrawableBase* copy() const = 0;
private:
};
//
// Representation of a drawable surrogate object to manage drawable objects
//
#undef Drawable // Conflict with <X11/Xproto.h>
class MagickPPExport Drawable
{
public:
// Constructor
Drawable ( void );
// Construct from DrawableBase
Drawable ( const DrawableBase& original_ );
// Destructor
~Drawable ( void );
// Copy constructor
Drawable ( const Drawable& original_ );
// Assignment operator
Drawable& operator= (const Drawable& original_ );
// Operator to invoke contained object
void operator()( MagickCore::DrawingWand *context_ ) const;
private:
DrawableBase* dp;
};
// Compare two Drawable objects regardless of LHS/RHS
MagickPPExport int operator == ( const Drawable& left_,
const Drawable& right_ );
MagickPPExport int operator != ( const Drawable& left_,
const Drawable& right_ );
MagickPPExport int operator > ( const Drawable& left_,
const Drawable& right_ );
MagickPPExport int operator < ( const Drawable& left_,
const Drawable& right_ );
MagickPPExport int operator >= ( const Drawable& left_,
const Drawable& right_ );
MagickPPExport int operator <= ( const Drawable& left_,
const Drawable& right_ );
typedef std::list<Magick::Drawable> DrawableList;
#if defined(MagickDLLExplicitTemplate)
MagickDrawableExtern template class MagickPPExport
std::allocator<Magick::Drawable>;
// MagickDrawableExtern template class MagickPPExport
// std::list<Magick::Drawable, std::allocator<Magick::Drawable> >;
#endif // MagickDLLExplicitTemplate
//
// Base class for all drawable path elements for use with
// DrawablePath
//
class MagickPPExport VPathBase
{
public:
// Constructor
VPathBase ( void )
{ }
// Destructor
virtual ~VPathBase ( void );
// Assignment operator
// const VPathBase& operator= (const VPathBase& original_ );
// Operator to invoke equivalent draw API call
virtual void operator()( MagickCore::DrawingWand *context_ ) const = 0;
// Return polymorphic copy of object
virtual VPathBase* copy() const = 0;
};
//
// Representation of a drawable path element surrogate object to
// manage drawable path elements so they may be passed as a list to
// DrawablePath.
//
class MagickPPExport VPath
{
public:
// Constructor
VPath ( void );
// Construct from VPathBase
VPath ( const VPathBase& original_ );
// Destructor
virtual ~VPath ( void );
// Copy constructor
VPath ( const VPath& original_ );
// Assignment operator
VPath& operator= (const VPath& original_ );
// Operator to invoke contained object
void operator()( MagickCore::DrawingWand *context_ ) const;
private:
VPathBase* dp;
};
// Compare two VPath objects regardless of LHS/RHS
MagickPPExport int operator == ( const VPath& left_,
const VPath& right_ );
MagickPPExport int operator != ( const VPath& left_,
const VPath& right_ );
MagickPPExport int operator > ( const VPath& left_,
const VPath& right_ );
MagickPPExport int operator < ( const VPath& left_,
const VPath& right_ );
MagickPPExport int operator >= ( const VPath& left_,
const VPath& right_ );
MagickPPExport int operator <= ( const VPath& left_,
const VPath& right_ );
typedef std::list<Magick::VPath> VPathList;
#if defined(MagickDLLExplicitTemplate)
MagickDrawableExtern template class MagickPPExport
std::allocator<Magick::VPath>;
// MagickDrawableExtern template class MagickPPExport
// std::list<Magick::VPath, std::allocator<Magick::VPath> >;
#endif // MagickDLLExplicitTemplate
//
// Drawable Objects
//
// Affine (scaling, rotation, and translation)
class MagickPPExport DrawableAffine : public DrawableBase
{
public:
DrawableAffine ( double sx_, double sy_,
double rx_, double ry_,
double tx_, double ty_ );
DrawableAffine ( void );
/*virtual*/ ~DrawableAffine( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/
DrawableBase* copy() const;
void sx( const double sx_ )
{
_affine.sx = sx_;
}
double sx( void ) const
{
return _affine.sx;
}
void sy( const double sy_ )
{
_affine.sy = sy_;
}
double sy( void ) const
{
return _affine.sy;
}
void rx( const double rx_ )
{
_affine.rx = rx_;
}
double rx( void ) const
{
return _affine.rx;
}
void ry( const double ry_ )
{
_affine.ry = ry_;
}
double ry( void ) const
{
return _affine.ry;
}
void tx( const double tx_ )
{
_affine.tx = tx_;
}
double tx( void ) const
{
return _affine.tx;
}
void ty( const double ty_ )
{
_affine.ty = ty_;
}
double ty( void ) const
{
return _affine.ty;
}
private:
MagickCore::AffineMatrix _affine;
};
// Arc
class MagickPPExport DrawableArc : public DrawableBase
{
public:
DrawableArc ( double startX_, double startY_,
double endX_, double endY_,
double startDegrees_, double endDegrees_ )
: _startX(startX_),
_startY(startY_),
_endX(endX_),
_endY(endY_),
_startDegrees(startDegrees_),
_endDegrees(endDegrees_)
{ }
/*virtual*/ ~DrawableArc( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void startX( double startX_ )
{
_startX = startX_;
}
double startX( void ) const
{
return _startX;
}
void startY( double startY_ )
{
_startY = startY_;
}
double startY( void ) const
{
return _startY;
}
void endX( double endX_ )
{
_endX = endX_;
}
double endX( void ) const
{
return _endX;
}
void endY( double endY_ )
{
_endY = endY_;
}
double endY( void ) const
{
return _endY;
}
void startDegrees( double startDegrees_ )
{
_startDegrees = startDegrees_;
}
double startDegrees( void ) const
{
return _startDegrees;
}
void endDegrees( double endDegrees_ )
{
_endDegrees = endDegrees_;
}
double endDegrees( void ) const
{
return _endDegrees;
}
private:
double _startX;
double _startY;
double _endX;
double _endY;
double _startDegrees;
double _endDegrees;
};
// Bezier curve (Coordinate list must contain at least three members)
class MagickPPExport DrawableBezier : public DrawableBase
{
public:
// Construct from coordinates
DrawableBezier ( const CoordinateList &coordinates_ );
// Copy constructor
DrawableBezier ( const DrawableBezier& original_ );
// Destructor
/*virtual*/ ~DrawableBezier ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
CoordinateList _coordinates;
};
// Pop (terminate) clip path definition
class MagickPPExport DrawablePopClipPath : public DrawableBase
{
public:
DrawablePopClipPath ( void )
: _dummy(0)
{
}
/*virtual*/ ~DrawablePopClipPath ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
::ssize_t _dummy;
};
// Push (create) Clip path definition
class MagickPPExport DrawablePushClipPath : public DrawableBase
{
public:
DrawablePushClipPath ( const std::string &id_);
DrawablePushClipPath ( const DrawablePushClipPath& original_ );
/*virtual*/ ~DrawablePushClipPath ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
std::string _id;
};
// Named Clip Path
class MagickPPExport DrawableClipPath : public DrawableBase
{
public:
DrawableClipPath ( const std::string &id_ );
DrawableClipPath ( const DrawableClipPath& original_ );
/*virtual*/ ~DrawableClipPath ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void clip_path( const std::string &id_ )
{
_id = id_.c_str(); //multithread safe
}
std::string clip_path( void ) const
{
return _id;
}
private:
std::string _id;
};
// Circle
class MagickPPExport DrawableCircle : public DrawableBase
{
public:
DrawableCircle ( double originX_, double originY_,
double perimX_, double perimY_ )
: _originX(originX_),
_originY(originY_),
_perimX(perimX_),
_perimY(perimY_)
{
}
/*virtual*/ ~DrawableCircle ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void originX( double originX_ )
{
_originX = originX_;
}
double originX( void ) const
{
return _originX;
}
void originY( double originY_ )
{
_originY = originY_;
}
double originY( void ) const
{
return _originY;
}
void perimX( double perimX_ )
{
_perimX = perimX_;
}
double perimX( void ) const
{
return _perimX;
}
void perimY( double perimY_ )
{
_perimY = perimY_;
}
double perimY( void ) const
{
return _perimY;
}
private:
double _originX;
double _originY;
double _perimX;
double _perimY;
};
// Colorize at point using PaintMethod
class MagickPPExport DrawableColor : public DrawableBase
{
public:
DrawableColor ( double x_, double y_,
PaintMethod paintMethod_ )
: _x(x_),
_y(y_),
_paintMethod(paintMethod_)
{ }
/*virtual*/ ~DrawableColor ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
void paintMethod( PaintMethod paintMethod_ )
{
_paintMethod = paintMethod_;
}
PaintMethod paintMethod( void ) const
{
return _paintMethod;
}
private:
double _x;
double _y;
PaintMethod _paintMethod;
};
// Draw image at point, scaled to size specified by width and height
class MagickPPExport Image;
class MagickPPExport DrawableCompositeImage : public DrawableBase
{
public:
DrawableCompositeImage ( double x_, double y_,
const std::string &filename_ );
DrawableCompositeImage ( double x_, double y_,
const Image &image_ );
DrawableCompositeImage ( double x_, double y_,
double width_, double height_,
const std::string &filename_ );
DrawableCompositeImage ( double x_, double y_,
double width_, double height_,
const Image &image_ );
DrawableCompositeImage ( double x_, double y_,
double width_, double height_,
const std::string &filename_,
CompositeOperator composition_ );
DrawableCompositeImage ( double x_, double y_,
double width_, double height_,
const Image &image_,
CompositeOperator composition_ );
// Copy constructor
DrawableCompositeImage ( const DrawableCompositeImage& original_ );
// Destructor
/*virtual*/ ~DrawableCompositeImage( void );
// Assignment operator
DrawableCompositeImage& operator=
(const DrawableCompositeImage& original_ );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void composition( CompositeOperator composition_ )
{
_composition = composition_;
}
CompositeOperator composition( void ) const
{
return _composition;
}
void filename( const std::string &image_ );
std::string filename( void ) const;
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
void width( double width_ )
{
_width = width_;
}
double width( void ) const
{
return _width;
}
void height( double height_ )
{
_height = height_;
}
double height( void ) const
{
return _height;
}
void image( const Image &image_ );
Magick::Image image( void ) const;
// Specify image format used to output Base64 inlined image data.
void magick( std::string magick_ );
std::string magick( void );
private:
CompositeOperator _composition;
double _x;
double _y;
double _width;
double _height;
Image* _image;
};
// Density
class MagickPPExport DrawableDensity : public DrawableBase
{
public:
DrawableDensity(const std::string &density_);
~DrawableDensity(void);
void operator()(MagickCore::DrawingWand *context_) const;
DrawableBase* copy() const;
private:
std::string _density;
};
// Ellipse
class MagickPPExport DrawableEllipse : public DrawableBase
{
public:
DrawableEllipse ( double originX_, double originY_,
double radiusX_, double radiusY_,
double arcStart_, double arcEnd_ )
: _originX(originX_),
_originY(originY_),
_radiusX(radiusX_),
_radiusY(radiusY_),
_arcStart(arcStart_),
_arcEnd(arcEnd_)
{ }
/*virtual*/ ~DrawableEllipse( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void originX( double originX_ )
{
_originX = originX_;
}
double originX( void ) const
{
return _originX;
}
void originY( double originY_ )
{
_originY = originY_;
}
double originY( void ) const
{
return _originY;
}
void radiusX( double radiusX_ )
{
_radiusX = radiusX_;
}
double radiusX( void ) const
{
return _radiusX;
}
void radiusY( double radiusY_ )
{
_radiusY = radiusY_;
}
double radiusY( void ) const
{
return _radiusY;
}
void arcStart( double arcStart_ )
{
_arcStart = arcStart_;
}
double arcStart( void ) const
{
return _arcStart;
}
void arcEnd( double arcEnd_ )
{
_arcEnd = arcEnd_;
}
double arcEnd( void ) const
{
return _arcEnd;
}
private:
double _originX;
double _originY;
double _radiusX;
double _radiusY;
double _arcStart;
double _arcEnd;
};
// Specify drawing fill color
class MagickPPExport DrawableFillColor : public DrawableBase
{
public:
DrawableFillColor ( const Color &color_ );
DrawableFillColor ( const DrawableFillColor& original_ );
/*virtual*/ ~DrawableFillColor( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void color( const Color &color_ )
{
_color = color_;
}
Color color( void ) const
{
return _color;
}
private:
Color _color;
};
// Specify fill rule (fill-rule)
class MagickPPExport DrawableFillRule : public DrawableBase
{
public:
DrawableFillRule ( const FillRule fillRule_ )
: _fillRule(fillRule_)
{
}
/*virtual*/ ~DrawableFillRule ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void fillRule( const FillRule fillRule_ )
{
_fillRule = fillRule_;
}
FillRule fillRule( void ) const
{
return _fillRule;
}
private:
FillRule _fillRule;
};
// Specify drawing fill opacity
class MagickPPExport DrawableFillOpacity : public DrawableBase
{
public:
DrawableFillOpacity ( double opacity_ )
: _opacity(opacity_)
{
}
/*virtual*/ ~DrawableFillOpacity ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void opacity( double opacity_ )
{
_opacity = opacity_;
}
double opacity( void ) const
{
return _opacity;
}
private:
double _opacity;
};
// Specify text font
class MagickPPExport DrawableFont : public DrawableBase
{
public:
DrawableFont ( const std::string &font_ );
DrawableFont ( const std::string &family_,
StyleType style_,
const unsigned int weight_,
StretchType stretch_ );
DrawableFont ( const DrawableFont& original_ );
/*virtual*/ ~DrawableFont ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void font( const std::string &font_ )
{
_font = font_;
}
std::string font( void ) const
{
return _font;
}
private:
std::string _font;
std::string _family;
StyleType _style;
unsigned int _weight;
StretchType _stretch;
};
// Specify text positioning gravity
class MagickPPExport DrawableGravity : public DrawableBase
{
public:
DrawableGravity ( GravityType gravity_ )
: _gravity(gravity_)
{
}
/*virtual*/ ~DrawableGravity ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void gravity( GravityType gravity_ )
{
_gravity = gravity_;
}
GravityType gravity( void ) const
{
return _gravity;
}
private:
GravityType _gravity;
};
// Line
class MagickPPExport DrawableLine : public DrawableBase
{
public:
DrawableLine ( double startX_, double startY_,
double endX_, double endY_ )
: _startX(startX_),
_startY(startY_),
_endX(endX_),
_endY(endY_)
{ }
/*virtual*/ ~DrawableLine ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void startX( double startX_ )
{
_startX = startX_;
}
double startX( void ) const
{
return _startX;
}
void startY( double startY_ )
{
_startY = startY_;
}
double startY( void ) const
{
return _startY;
}
void endX( double endX_ )
{
_endX = endX_;
}
double endX( void ) const
{
return _endX;
}
void endY( double endY_ )
{
_endY = endY_;
}
double endY( void ) const
{
return _endY;
}
private:
double _startX;
double _startY;
double _endX;
double _endY;
};
// Change pixel matte value to transparent using PaintMethod
class MagickPPExport DrawableMatte : public DrawableBase
{
public:
DrawableMatte ( double x_, double y_,
PaintMethod paintMethod_ )
: _x(x_),
_y(y_),
_paintMethod(paintMethod_)
{ }
/*virtual*/ ~DrawableMatte ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
void paintMethod( PaintMethod paintMethod_ )
{
_paintMethod = paintMethod_;
}
PaintMethod paintMethod( void ) const
{
return _paintMethod;
}
private:
double _x;
double _y;
PaintMethod _paintMethod;
};
// Drawable Path
class MagickPPExport DrawablePath : public DrawableBase
{
public:
DrawablePath ( const VPathList &path_ );
DrawablePath ( const DrawablePath& original_ );
/*virtual*/ ~DrawablePath ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
VPathList _path;
};
// Point
class MagickPPExport DrawablePoint : public DrawableBase
{
public:
DrawablePoint ( double x_, double y_ )
: _x(x_),
_y(y_)
{ }
/*virtual*/ ~DrawablePoint ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
private:
double _x;
double _y;
};
// Text pointsize
class MagickPPExport DrawablePointSize : public DrawableBase
{
public:
DrawablePointSize ( double pointSize_ )
: _pointSize(pointSize_)
{ }
/*virtual*/ ~DrawablePointSize ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void pointSize( double pointSize_ )
{
_pointSize = pointSize_;
}
double pointSize( void ) const
{
return _pointSize;
}
private:
double _pointSize;
};
// Polygon (Coordinate list must contain at least three members)
class MagickPPExport DrawablePolygon : public DrawableBase
{
public:
DrawablePolygon ( const CoordinateList &coordinates_ );
DrawablePolygon ( const DrawablePolygon& original_ );
/*virtual*/ ~DrawablePolygon ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
CoordinateList _coordinates;
};
// Polyline (Coordinate list must contain at least three members)
class MagickPPExport DrawablePolyline : public DrawableBase
{
public:
DrawablePolyline ( const CoordinateList &coordinates_ );
DrawablePolyline ( const DrawablePolyline& original_ );
/*virtual*/ ~DrawablePolyline ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
CoordinateList _coordinates;
};
// Pop Graphic Context
class MagickPPExport DrawablePopGraphicContext : public DrawableBase
{
public:
DrawablePopGraphicContext ( void )
: _dummy(0)
{
}
/*virtual*/ ~DrawablePopGraphicContext ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
::ssize_t _dummy;
};
// Push Graphic Context
class MagickPPExport DrawablePushGraphicContext : public DrawableBase
{
public:
DrawablePushGraphicContext ( void )
: _dummy(0)
{
}
/*virtual*/ ~DrawablePushGraphicContext ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
::ssize_t _dummy;
};
// Pop (terminate) Pattern definition
class MagickPPExport DrawablePopPattern : public DrawableBase
{
public:
DrawablePopPattern ( void )
: _dummy(0)
{
}
/*virtual*/ ~DrawablePopPattern ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
::ssize_t _dummy;
};
// Push (create) Pattern definition
class MagickPPExport DrawablePushPattern : public DrawableBase
{
public:
DrawablePushPattern ( const std::string &id_, ::ssize_t x_, ::ssize_t y_,
size_t width_, size_t height_ );
DrawablePushPattern ( const DrawablePushPattern& original_ );
/*virtual*/ ~DrawablePushPattern ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
std::string _id;
::ssize_t _x;
::ssize_t _y;
size_t _width;
size_t _height;
};
// Rectangle
class MagickPPExport DrawableRectangle : public DrawableBase
{
public:
DrawableRectangle ( double upperLeftX_, double upperLeftY_,
double lowerRightX_, double lowerRightY_ )
: _upperLeftX(upperLeftX_),
_upperLeftY(upperLeftY_),
_lowerRightX(lowerRightX_),
_lowerRightY(lowerRightY_)
{ }
/*virtual*/ ~DrawableRectangle ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void upperLeftX( double upperLeftX_ )
{
_upperLeftX = upperLeftX_;
}
double upperLeftX( void ) const
{
return _upperLeftX;
}
void upperLeftY( double upperLeftY_ )
{
_upperLeftY = upperLeftY_;
}
double upperLeftY( void ) const
{
return _upperLeftY;
}
void lowerRightX( double lowerRightX_ )
{
_lowerRightX = lowerRightX_;
}
double lowerRightX( void ) const
{
return _lowerRightX;
}
void lowerRightY( double lowerRightY_ )
{
_lowerRightY = lowerRightY_;
}
double lowerRightY( void ) const
{
return _lowerRightY;
}
private:
double _upperLeftX;
double _upperLeftY;
double _lowerRightX;
double _lowerRightY;
};
// Apply Rotation
class MagickPPExport DrawableRotation : public DrawableBase
{
public:
DrawableRotation ( double angle_ )
: _angle( angle_ )
{ }
/*virtual*/ ~DrawableRotation ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void angle( double angle_ )
{
_angle = angle_;
}
double angle( void ) const
{
return _angle;
}
private:
double _angle;
};
// Round Rectangle
class MagickPPExport DrawableRoundRectangle : public DrawableBase
{
public:
DrawableRoundRectangle ( double upperLeftX_, double upperLeftY_,
double lowerRightX_, double lowerRightY_,
double cornerWidth_, double cornerHeight_ )
: _upperLeftX(upperLeftX_),
_upperLeftY(upperLeftY_),
_lowerRightX(lowerRightX_),
_lowerRightY(lowerRightY_),
_cornerWidth(cornerWidth_),
_cornerHeight(cornerHeight_)
{ }
/*virtual*/ ~DrawableRoundRectangle ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
#if !defined(MAGICKCORE_EXCLUDE_DEPRECATED)
void centerX( double centerX_ )
{
_upperLeftX = centerX_;
}
double centerX( void ) const
{
return _upperLeftX;
}
void centerY( double centerY_ )
{
_upperLeftY = centerY_;
}
double centerY( void ) const
{
return _upperLeftY;
}
void width( double width_ )
{
_lowerRightX = width_;
}
double width( void ) const
{
return _lowerRightX;
}
void hight( double hight_ )
{
_lowerRightY = hight_;
}
double hight( void ) const
{
return _lowerRightY;
}
#endif
void upperLeftX( double upperLeftX_ )
{
_upperLeftX = upperLeftX_;
}
double upperLeftX( void ) const
{
return _upperLeftX;
}
void upperLeftY( double upperLeftY_ )
{
_upperLeftY = upperLeftY_;
}
double upperLeftY( void ) const
{
return _upperLeftY;
}
void lowerRightX( double lowerRightX_ )
{
_lowerRightX = lowerRightX_;
}
double lowerRightX( void ) const
{
return _lowerRightX;
}
void lowerRightY( double lowerRightY_ )
{
_lowerRightY = lowerRightY_;
}
double lowerRightY( void ) const
{
return _lowerRightY;
}
void cornerWidth( double cornerWidth_ )
{
_cornerWidth = cornerWidth_;
}
double cornerWidth( void ) const
{
return _cornerWidth;
}
void cornerHeight( double cornerHeight_ )
{
_cornerHeight = cornerHeight_;
}
double cornerHeight( void ) const
{
return _cornerHeight;
}
private:
double _upperLeftX;
double _upperLeftY;
double _lowerRightX;
double _lowerRightY;
double _cornerWidth;
double _cornerHeight;
};
// Apply Scaling
class MagickPPExport DrawableScaling : public DrawableBase
{
public:
DrawableScaling ( double x_, double y_ )
: _x(x_),
_y(y_)
{ }
/*virtual*/ ~DrawableScaling ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
private:
double _x;
double _y;
};
// Apply Skew in X direction
class MagickPPExport DrawableSkewX : public DrawableBase
{
public:
DrawableSkewX ( double angle_ )
: _angle(angle_)
{ }
/*virtual*/ ~DrawableSkewX ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void angle( double angle_ )
{
_angle = angle_;
}
double angle( void ) const
{
return _angle;
}
private:
double _angle;
};
// Apply Skew in Y direction
class MagickPPExport DrawableSkewY : public DrawableBase
{
public:
DrawableSkewY ( double angle_ )
: _angle(angle_)
{ }
/*virtual*/ ~DrawableSkewY ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void angle( double angle_ )
{
_angle = angle_;
}
double angle( void ) const
{
return _angle;
}
private:
double _angle;
};
// Stroke dasharray
//
// dasharray_ is an allocated array terminated by value 0.0 or 0.
// The array is copied so the original does not need to be preserved.
// Pass a null pointer to clear an existing dash array setting.
class MagickPPExport DrawableDashArray : public DrawableBase
{
public:
DrawableDashArray( const double* dasharray_ );
DrawableDashArray( const size_t* dasharray_ ); // Deprecated
DrawableDashArray( const Magick::DrawableDashArray &original_ );
/*virtual*/ ~DrawableDashArray( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void dasharray( const double* dasharray_ );
void dasharray( const size_t* dasharray_ ); // Deprecated
const double* dasharray( void ) const
{
return _dasharray;
}
DrawableDashArray& operator=(const Magick::DrawableDashArray &original_);
private:
size_t _size;
double *_dasharray;
};
// Stroke dashoffset
class MagickPPExport DrawableDashOffset : public DrawableBase
{
public:
DrawableDashOffset ( const double offset_ )
: _offset(offset_)
{ }
/*virtual*/ ~DrawableDashOffset ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void offset( const double offset_ )
{
_offset = offset_;
}
double offset( void ) const
{
return _offset;
}
private:
double _offset;
};
// Stroke linecap
class MagickPPExport DrawableStrokeLineCap : public DrawableBase
{
public:
DrawableStrokeLineCap ( LineCap linecap_ )
: _linecap(linecap_)
{ }
/*virtual*/ ~DrawableStrokeLineCap ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void linecap( LineCap linecap_ )
{
_linecap = linecap_;
}
LineCap linecap( void ) const
{
return _linecap;
}
private:
LineCap _linecap;
};
// Stroke linejoin
class MagickPPExport DrawableStrokeLineJoin : public DrawableBase
{
public:
DrawableStrokeLineJoin ( LineJoin linejoin_ )
: _linejoin(linejoin_)
{ }
/*virtual*/ ~DrawableStrokeLineJoin ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void linejoin( LineJoin linejoin_ )
{
_linejoin = linejoin_;
}
LineJoin linejoin( void ) const
{
return _linejoin;
}
private:
LineJoin _linejoin;
};
// Stroke miterlimit
class MagickPPExport DrawableMiterLimit : public DrawableBase
{
public:
DrawableMiterLimit ( size_t miterlimit_ )
: _miterlimit(miterlimit_)
{ }
/*virtual*/ ~DrawableMiterLimit ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void miterlimit( size_t miterlimit_ )
{
_miterlimit = miterlimit_;
}
size_t miterlimit( void ) const
{
return _miterlimit;
}
private:
size_t _miterlimit;
};
// Stroke antialias
class MagickPPExport DrawableStrokeAntialias : public DrawableBase
{
public:
DrawableStrokeAntialias ( bool flag_ )
: _flag(flag_)
{ }
/*virtual*/ ~DrawableStrokeAntialias ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void flag( bool flag_ )
{
_flag = flag_;
}
bool flag( void ) const
{
return _flag;
}
private:
bool _flag;
};
// Stroke color
class MagickPPExport DrawableStrokeColor : public DrawableBase
{
public:
DrawableStrokeColor ( const Color &color_ );
DrawableStrokeColor ( const DrawableStrokeColor& original_ );
/*virtual*/ ~DrawableStrokeColor ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void color( const Color& color_ )
{
_color = color_;
}
Color color( void ) const
{
return _color;
}
private:
Color _color;
};
// Stroke opacity
class MagickPPExport DrawableStrokeOpacity : public DrawableBase
{
public:
DrawableStrokeOpacity ( double opacity_ )
: _opacity(opacity_)
{
}
/*virtual*/ ~DrawableStrokeOpacity ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void opacity( double opacity_ )
{
_opacity = opacity_;
}
double opacity( void ) const
{
return _opacity;
}
private:
double _opacity;
};
// Stroke width
class MagickPPExport DrawableStrokeWidth : public DrawableBase
{
public:
DrawableStrokeWidth ( double width_ )
: _width(width_)
{ }
/*virtual*/ ~DrawableStrokeWidth ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void width( double width_ )
{
_width = width_;
}
double width( void ) const
{
return _width;
}
private:
double _width;
};
// Draw text at point
class MagickPPExport DrawableText : public DrawableBase
{
public:
DrawableText ( const double x_, const double y_,
const std::string &text_ );
DrawableText ( const double x_, const double y_,
const std::string &text_, const std::string &encoding_);
DrawableText ( const DrawableText& original_ );
/*virtual*/ ~DrawableText ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void encoding(const std::string &encoding_)
{
_encoding = encoding_;
}
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
void text( const std::string &text_ )
{
_text = text_;
}
std::string text( void ) const
{
return _text;
}
private:
double _x;
double _y;
std::string _text;
std::string _encoding;
};
// Text antialias
class MagickPPExport DrawableTextAntialias : public DrawableBase
{
public:
DrawableTextAntialias ( bool flag_ );
DrawableTextAntialias( const DrawableTextAntialias &original_ );
/*virtual*/ ~DrawableTextAntialias ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void flag( bool flag_ )
{
_flag = flag_;
}
bool flag( void ) const
{
return _flag;
}
private:
bool _flag;
};
// Decoration (text decoration)
class MagickPPExport DrawableTextDecoration : public DrawableBase
{
public:
DrawableTextDecoration ( DecorationType decoration_ );
DrawableTextDecoration ( const DrawableTextDecoration& original_ );
/*virtual*/ ~DrawableTextDecoration( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void decoration( DecorationType decoration_ )
{
_decoration = decoration_;
}
DecorationType decoration( void ) const
{
return _decoration;
}
private:
DecorationType _decoration;
};
// Render text right-to-left or left-to-right.
class MagickPPExport DrawableTextDirection : public DrawableBase
{
public:
DrawableTextDirection(DirectionType direction_);
~DrawableTextDirection(void);
void operator()(MagickCore::DrawingWand *context_) const;
void direction(DirectionType direction_);
DirectionType direction(void) const;
DrawableBase* copy() const;
private:
DirectionType _direction;
};
// Specify text inter-line spacing
class MagickPPExport DrawableTextInterlineSpacing : public DrawableBase
{
public:
DrawableTextInterlineSpacing(double spacing_);
~DrawableTextInterlineSpacing(void);
void operator()(MagickCore::DrawingWand *context_) const;
void spacing(double spacing_);
double spacing(void) const;
DrawableBase* copy() const;
private:
double _spacing;
};
// Specify text inter-word spacing
class MagickPPExport DrawableTextInterwordSpacing : public DrawableBase
{
public:
DrawableTextInterwordSpacing(double spacing_);
~DrawableTextInterwordSpacing(void);
void operator()(MagickCore::DrawingWand *context_) const;
void spacing(double spacing_);
double spacing(void) const;
DrawableBase *copy() const;
private:
double _spacing;
};
// Specify text kerning
class MagickPPExport DrawableTextKerning : public DrawableBase
{
public:
DrawableTextKerning(double kerning_);
~DrawableTextKerning(void);
void operator()(MagickCore::DrawingWand *context_) const;
void kerning(double kerning_);
double kerning(void) const;
DrawableBase *copy() const;
private:
double _kerning;
};
// Text undercolor box
class MagickPPExport DrawableTextUnderColor : public DrawableBase
{
public:
DrawableTextUnderColor ( const Color &color_ );
DrawableTextUnderColor ( const DrawableTextUnderColor& original_ );
/*virtual*/ ~DrawableTextUnderColor ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void color( const Color& color_ )
{
_color = color_;
}
Color color( void ) const
{
return _color;
}
private:
Color _color;
};
// Apply Translation
class MagickPPExport DrawableTranslation : public DrawableBase
{
public:
DrawableTranslation ( double x_, double y_ )
: _x(x_),
_y(y_)
{ }
/*virtual*/ ~DrawableTranslation ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
private:
double _x;
double _y;
};
// Set the size of the viewbox
class MagickPPExport DrawableViewbox : public DrawableBase
{
public:
DrawableViewbox(::ssize_t x1_, ::ssize_t y1_,
::ssize_t x2_, ::ssize_t y2_)
: _x1(x1_),
_y1(y1_),
_x2(x2_),
_y2(y2_) { }
/*virtual*/ ~DrawableViewbox ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/
DrawableBase* copy() const;
void x1( ::ssize_t x1_ )
{
_x1 = x1_;
}
::ssize_t x1( void ) const
{
return _x1;
}
void y1( ::ssize_t y1_ )
{
_y1 = y1_;
}
::ssize_t y1( void ) const
{
return _y1;
}
void x2( ::ssize_t x2_ )
{
_x2 = x2_;
}
::ssize_t x2( void ) const
{
return _x2;
}
void y2( ::ssize_t y2_ )
{
_y2 = y2_;
}
::ssize_t y2( void ) const
{
return _y2;
}
private:
::ssize_t _x1;
::ssize_t _y1;
::ssize_t _x2;
::ssize_t _y2;
};
//
// Path Element Classes To Support DrawablePath
//
class MagickPPExport PathArcArgs
{
public:
PathArcArgs( void );
PathArcArgs( double radiusX_, double radiusY_,
double xAxisRotation_, bool largeArcFlag_,
bool sweepFlag_, double x_, double y_ );
PathArcArgs( const PathArcArgs &original_ );
~PathArcArgs ( void );
void radiusX( double radiusX_ )
{
_radiusX = radiusX_;
}
double radiusX( void ) const
{
return _radiusX;
}
void radiusY( double radiusY_ )
{
_radiusY = radiusY_;
}
double radiusY( void ) const
{
return _radiusY;
}
void xAxisRotation( double xAxisRotation_ )
{
_xAxisRotation = xAxisRotation_;
}
double xAxisRotation( void ) const
{
return _xAxisRotation;
}
void largeArcFlag( bool largeArcFlag_ )
{
_largeArcFlag = largeArcFlag_;
}
bool largeArcFlag( void ) const
{
return _largeArcFlag;
}
void sweepFlag( bool sweepFlag_ )
{
_sweepFlag = sweepFlag_;
}
bool sweepFlag( void ) const
{
return _sweepFlag;
}
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
private:
double _radiusX; // X radius
double _radiusY; // Y radius
double _xAxisRotation; // Rotation relative to X axis
bool _largeArcFlag; // Draw longer of the two matching arcs
bool _sweepFlag; // Draw arc matching clock-wise rotation
double _x; // End-point X
double _y; // End-point Y
};
// Compare two PathArcArgs objects regardless of LHS/RHS
MagickPPExport int operator == ( const PathArcArgs& left_,
const PathArcArgs& right_ );
MagickPPExport int operator != ( const PathArcArgs& left_,
const PathArcArgs& right_ );
MagickPPExport int operator > ( const PathArcArgs& left_,
const PathArcArgs& right_ );
MagickPPExport int operator < ( const PathArcArgs& left_,
const PathArcArgs& right_ );
MagickPPExport int operator >= ( const PathArcArgs& left_,
const PathArcArgs& right_ );
MagickPPExport int operator <= ( const PathArcArgs& left_,
const PathArcArgs& right_ );
typedef std::list<Magick::PathArcArgs> PathArcArgsList;
#if defined(MagickDLLExplicitTemplate)
MagickDrawableExtern template class MagickPPExport
std::allocator<Magick::PathArcArgs>;
// MagickDrawableExtern template class MagickPPExport
// std::list<Magick::PathArcArgs, std::allocator<Magick::PathArcArgs> >;
#endif // MagickDLLExplicitTemplate
// Path Arc (Elliptical Arc)
class MagickPPExport PathArcAbs : public VPathBase
{
public:
// Draw a single arc segment
PathArcAbs ( const PathArcArgs &coordinates_ );
// Draw multiple arc segments
PathArcAbs ( const PathArcArgsList &coordinates_ );
// Copy constructor
PathArcAbs ( const PathArcAbs& original_ );
// Destructor
/*virtual*/ ~PathArcAbs ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
PathArcArgsList _coordinates;
};
class MagickPPExport PathArcRel : public VPathBase
{
public:
// Draw a single arc segment
PathArcRel ( const PathArcArgs &coordinates_ );
// Draw multiple arc segments
PathArcRel ( const PathArcArgsList &coordinates_ );
PathArcRel ( const PathArcRel& original_ );
/*virtual*/ ~PathArcRel ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
PathArcArgsList _coordinates;
};
// Path Closepath
class MagickPPExport PathClosePath : public VPathBase
{
public:
PathClosePath ( void )
: _dummy(0)
{
}
/*virtual*/ ~PathClosePath ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
::ssize_t _dummy;
};
//
// Curveto (Cubic Bezier)
//
class MagickPPExport PathCurvetoArgs
{
public:
PathCurvetoArgs( void );
PathCurvetoArgs( double x1_, double y1_,
double x2_, double y2_,
double x_, double y_ );
PathCurvetoArgs( const PathCurvetoArgs &original_ );
~PathCurvetoArgs ( void );
void x1( double x1_ )
{
_x1 = x1_;
}
double x1( void ) const
{
return _x1;
}
void y1( double y1_ )
{
_y1 = y1_;
}
double y1( void ) const
{
return _y1;
}
void x2( double x2_ )
{
_x2 = x2_;
}
double x2( void ) const
{
return _x2;
}
void y2( double y2_ )
{
_y2 = y2_;
}
double y2( void ) const
{
return _y2;
}
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
private:
double _x1;
double _y1;
double _x2;
double _y2;
double _x;
double _y;
};
// Compare two PathCurvetoArgs objects regardless of LHS/RHS
MagickPPExport int operator == ( const PathCurvetoArgs& left_,
const PathCurvetoArgs& right_ );
MagickPPExport int operator != ( const PathCurvetoArgs& left_,
const PathCurvetoArgs& right_ );
MagickPPExport int operator > ( const PathCurvetoArgs& left_,
const PathCurvetoArgs& right_ );
MagickPPExport int operator < ( const PathCurvetoArgs& left_,
const PathCurvetoArgs& right_ );
MagickPPExport int operator >= ( const PathCurvetoArgs& left_,
const PathCurvetoArgs& right_ );
MagickPPExport int operator <= ( const PathCurvetoArgs& left_,
const PathCurvetoArgs& right_ );
typedef std::list<Magick::PathCurvetoArgs> PathCurveToArgsList;
#if defined(MagickDLLExplicitTemplate)
MagickDrawableExtern template class MagickPPExport
std::allocator<Magick::PathCurvetoArgs>;
// MagickDrawableExtern template class MagickPPExport
// std::list<Magick::PathCurvetoArgs, std::allocator<Magick::PathCurvetoArgs> >;
#endif // MagickDLLExplicitTemplate
class MagickPPExport PathCurvetoAbs : public VPathBase
{
public:
// Draw a single curve
PathCurvetoAbs ( const PathCurvetoArgs &args_ );
// Draw multiple curves
PathCurvetoAbs ( const PathCurveToArgsList &args_ );
// Copy constructor
PathCurvetoAbs ( const PathCurvetoAbs& original_ );
// Destructor
/*virtual*/ ~PathCurvetoAbs ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
PathCurveToArgsList _args;
};
class MagickPPExport PathCurvetoRel : public VPathBase
{
public:
// Draw a single curve
PathCurvetoRel ( const PathCurvetoArgs &args_ );
// Draw multiple curves
PathCurvetoRel ( const PathCurveToArgsList &args_ );
// Copy constructor
PathCurvetoRel ( const PathCurvetoRel& original_ );
/*virtual*/ ~PathCurvetoRel ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
PathCurveToArgsList _args;
};
class MagickPPExport PathSmoothCurvetoAbs : public VPathBase
{
public:
// Draw a single curve
PathSmoothCurvetoAbs ( const Magick::Coordinate &coordinates_ );
// Draw multiple curves
PathSmoothCurvetoAbs ( const CoordinateList &coordinates_ );
// Copy constructor
PathSmoothCurvetoAbs ( const PathSmoothCurvetoAbs& original_ );
/*virtual*/ ~PathSmoothCurvetoAbs ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/
VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
class MagickPPExport PathSmoothCurvetoRel : public VPathBase
{
public:
// Draw a single curve
PathSmoothCurvetoRel ( const Coordinate &coordinates_ );
// Draw multiple curves
PathSmoothCurvetoRel ( const CoordinateList &coordinates_ );
// Copy constructor
PathSmoothCurvetoRel ( const PathSmoothCurvetoRel& original_ );
// Destructor
/*virtual*/ ~PathSmoothCurvetoRel ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/
VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
//
// Quadratic Curveto (Quadratic Bezier)
//
class MagickPPExport PathQuadraticCurvetoArgs
{
public:
PathQuadraticCurvetoArgs( void );
PathQuadraticCurvetoArgs( double x1_, double y1_,
double x_, double y_ );
PathQuadraticCurvetoArgs( const PathQuadraticCurvetoArgs &original_ );
~PathQuadraticCurvetoArgs ( void );
void x1( double x1_ )
{
_x1 = x1_;
}
double x1( void ) const
{
return _x1;
}
void y1( double y1_ )
{
_y1 = y1_;
}
double y1( void ) const
{
return _y1;
}
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
private:
double _x1;
double _y1;
double _x;
double _y;
};
// Compare two PathQuadraticCurvetoArgs objects regardless of LHS/RHS
MagickPPExport int operator == ( const PathQuadraticCurvetoArgs& left_,
const PathQuadraticCurvetoArgs& right_ );
MagickPPExport int operator != ( const PathQuadraticCurvetoArgs& left_,
const PathQuadraticCurvetoArgs& right_);
MagickPPExport int operator > ( const PathQuadraticCurvetoArgs& left_,
const PathQuadraticCurvetoArgs& right_);
MagickPPExport int operator < ( const PathQuadraticCurvetoArgs& left_,
const PathQuadraticCurvetoArgs& right_);
MagickPPExport int operator >= ( const PathQuadraticCurvetoArgs& left_,
const PathQuadraticCurvetoArgs& right_ );
MagickPPExport int operator <= ( const PathQuadraticCurvetoArgs& left_,
const PathQuadraticCurvetoArgs& right_ );
typedef std::list<Magick::PathQuadraticCurvetoArgs> PathQuadraticCurvetoArgsList;
#if defined(MagickDLLExplicitTemplate)
MagickDrawableExtern template class MagickPPExport
std::allocator<Magick::PathQuadraticCurvetoArgs>;
// MagickDrawableExtern template class MagickPPExport
// std::list<Magick::PathQuadraticCurvetoArgs, std::allocator<Magick::PathQuadraticCurvetoArgs> >;
#endif // MagickDLLExplicitTemplate
class MagickPPExport PathQuadraticCurvetoAbs : public VPathBase
{
public:
// Draw a single curve
PathQuadraticCurvetoAbs ( const Magick::PathQuadraticCurvetoArgs &args_ );
// Draw multiple curves
PathQuadraticCurvetoAbs ( const PathQuadraticCurvetoArgsList &args_ );
// Copy constructor
PathQuadraticCurvetoAbs ( const PathQuadraticCurvetoAbs& original_ );
// Destructor
/*virtual*/ ~PathQuadraticCurvetoAbs ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
PathQuadraticCurvetoArgsList _args;
};
class MagickPPExport PathQuadraticCurvetoRel : public VPathBase
{
public:
// Draw a single curve
PathQuadraticCurvetoRel ( const Magick::PathQuadraticCurvetoArgs &args_ );
// Draw multiple curves
PathQuadraticCurvetoRel ( const PathQuadraticCurvetoArgsList &args_ );
// Copy constructor
PathQuadraticCurvetoRel ( const PathQuadraticCurvetoRel& original_ );
// Destructor
/*virtual*/ ~PathQuadraticCurvetoRel ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
PathQuadraticCurvetoArgsList _args;
};
class MagickPPExport PathSmoothQuadraticCurvetoAbs : public VPathBase
{
public:
// Draw a single curve
PathSmoothQuadraticCurvetoAbs ( const Magick::Coordinate &coordinate_ );
// Draw multiple curves
PathSmoothQuadraticCurvetoAbs ( const CoordinateList &coordinates_ );
// Copy constructor
PathSmoothQuadraticCurvetoAbs ( const PathSmoothQuadraticCurvetoAbs& original_ );
// Destructor
/*virtual*/ ~PathSmoothQuadraticCurvetoAbs ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
class MagickPPExport PathSmoothQuadraticCurvetoRel : public VPathBase
{
public:
// Draw a single curve
PathSmoothQuadraticCurvetoRel ( const Magick::Coordinate &coordinate_ );
// Draw multiple curves
PathSmoothQuadraticCurvetoRel ( const CoordinateList &coordinates_ );
// Copy constructor
PathSmoothQuadraticCurvetoRel ( const PathSmoothQuadraticCurvetoRel& original_ );
// Destructor
/*virtual*/ ~PathSmoothQuadraticCurvetoRel ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
//
// Path Lineto
//
class MagickPPExport PathLinetoAbs : public VPathBase
{
public:
// Draw to a single point
PathLinetoAbs ( const Magick::Coordinate& coordinate_ );
// Draw to multiple points
PathLinetoAbs ( const CoordinateList &coordinates_ );
// Copy constructor
PathLinetoAbs ( const PathLinetoAbs& original_ );
// Destructor
/*virtual*/ ~PathLinetoAbs ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
class MagickPPExport PathLinetoRel : public VPathBase
{
public:
// Draw to a single point
PathLinetoRel ( const Magick::Coordinate& coordinate_ );
// Draw to multiple points
PathLinetoRel ( const CoordinateList &coordinates_ );
// Copy constructor
PathLinetoRel ( const PathLinetoRel& original_ );
// Destructor
/*virtual*/ ~PathLinetoRel ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
// Path Horizontal Lineto
class MagickPPExport PathLinetoHorizontalAbs : public VPathBase
{
public:
PathLinetoHorizontalAbs ( double x_ )
: _x(x_)
{
}
/*virtual*/ ~PathLinetoHorizontalAbs ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
private:
double _x;
};
class MagickPPExport PathLinetoHorizontalRel : public VPathBase
{
public:
PathLinetoHorizontalRel ( double x_ )
: _x(x_)
{
}
/*virtual*/ ~PathLinetoHorizontalRel ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
private:
double _x;
};
// Path Vertical Lineto
class MagickPPExport PathLinetoVerticalAbs : public VPathBase
{
public:
PathLinetoVerticalAbs ( double y_ )
: _y(y_)
{
}
/*virtual*/ ~PathLinetoVerticalAbs ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
private:
double _y;
};
class MagickPPExport PathLinetoVerticalRel : public VPathBase
{
public:
PathLinetoVerticalRel ( double y_ )
: _y(y_)
{
}
/*virtual*/ ~PathLinetoVerticalRel ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
private:
double _y;
};
// Path Moveto
class MagickPPExport PathMovetoAbs : public VPathBase
{
public:
// Simple moveto
PathMovetoAbs ( const Magick::Coordinate &coordinate_ );
// Moveto followed by implicit linetos
PathMovetoAbs ( const CoordinateList &coordinates_ );
// Copy constructor
PathMovetoAbs ( const PathMovetoAbs& original_ );
// Destructor
/*virtual*/ ~PathMovetoAbs ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
class MagickPPExport PathMovetoRel : public VPathBase
{
public:
// Simple moveto
PathMovetoRel ( const Magick::Coordinate &coordinate_ );
// Moveto followed by implicit linetos
PathMovetoRel ( const CoordinateList &coordinates_ );
// Copy constructor
PathMovetoRel ( const PathMovetoRel& original_ );
// Destructor
/*virtual*/ ~PathMovetoRel ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
} // namespace Magick
#endif // Magick_Drawable_header
Magick++.h 0000644 00000001311 15051111170 0006222 0 ustar 00 // This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999, 2000
// Copyright Dirk Lemstra 2014
//
// Simplified includes for Magick++.
// Inclusion of this header is sufficient to use all Magick++ APIs.
//
#ifndef MagickPlusPlus_Header
#include <Magick++/Include.h>
#include <Magick++/Functions.h>
#include <Magick++/Image.h>
#include <Magick++/Pixels.h>
#include <Magick++/ResourceLimits.h>
#include <Magick++/STL.h>
// Don't leak our definition of the 'restrict' keyword. 'restrict' is a valid
// identifier in C++, and leaking it could cause extraneous build failures.
#ifdef restrict
#undef restrict
#endif
#define MagickPlusPlus_Header
#endif // MagickPlusPlus_Header
magick/visual-effects.h 0000644 00000005437 15051111170 0011071 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image visual effects methods.
*/
#ifndef MAGICKCORE_VISUAL_EFFECTS_H
#define MAGICKCORE_VISUAL_EFFECTS_H
#include "magick/draw.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedNoise,
UniformNoise,
GaussianNoise,
MultiplicativeGaussianNoise,
ImpulseNoise,
LaplacianNoise,
PoissonNoise,
RandomNoise
} NoiseType;
extern MagickExport Image
*AddNoiseImage(const Image *,const NoiseType,ExceptionInfo *),
*AddNoiseImageChannel(const Image *,const ChannelType,const NoiseType,
ExceptionInfo *),
*BlueShiftImage(const Image *,const double,ExceptionInfo *),
*CharcoalImage(const Image *,const double,const double,ExceptionInfo *),
*ColorizeImage(const Image *,const char *,const PixelPacket,ExceptionInfo *),
*ColorMatrixImage(const Image *,const KernelInfo *kernel,ExceptionInfo *),
*ImplodeImage(const Image *,const double,ExceptionInfo *),
*MorphImages(const Image *,const size_t,ExceptionInfo *),
*PolaroidImage(const Image *,const DrawInfo *,const double,ExceptionInfo *),
*SepiaToneImage(const Image *,const double,ExceptionInfo *),
*ShadowImage(const Image *,const double,const double,const ssize_t,
const ssize_t,ExceptionInfo *),
*SketchImage(const Image *,const double,const double,const double,
ExceptionInfo *),
*SteganoImage(const Image *,const Image *,ExceptionInfo *),
*StereoImage(const Image *,const Image *,ExceptionInfo *),
*StereoAnaglyphImage(const Image *,const Image *,const ssize_t,const ssize_t,
ExceptionInfo *),
*SwirlImage(const Image *,double,ExceptionInfo *),
*TintImage(const Image *,const char *,const PixelPacket,ExceptionInfo *),
*VignetteImage(const Image *,const double,const double,const ssize_t,
const ssize_t,ExceptionInfo *),
*WaveImage(const Image *,const double,const double,ExceptionInfo *),
*WaveletDenoiseImage(const Image *,const double,const double,ExceptionInfo *);
extern MagickExport MagickBooleanType
PlasmaImage(Image *,const SegmentInfo *,size_t,size_t),
SolarizeImage(Image *,const double),
SolarizeImageChannel(Image *,const ChannelType,const double,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/string_.h 0000644 00000007205 15051111170 0007611 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore string methods.
*/
#ifndef MAGICKCORE_STRING_H_
#define MAGICKCORE_STRING_H_
#include <stdarg.h>
#include <time.h>
#include "magick/exception.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _StringInfo
{
char
path[MaxTextExtent];
unsigned char
*datum;
size_t
length,
signature;
char
*name;
} StringInfo;
extern MagickExport char
*AcquireString(const char *),
*CloneString(char **,const char *),
*ConstantString(const char *),
*DestroyString(char *),
**DestroyStringList(char **),
*EscapeString(const char *,const char),
*FileToString(const char *,const size_t,ExceptionInfo *),
*GetEnvironmentValue(const char *),
*SanitizeString(const char *),
*StringInfoToHexString(const StringInfo *),
*StringInfoToString(const StringInfo *),
**StringToArgv(const char *,int *),
*StringToken(const char *,char **),
**StringToList(const char *),
**StringToStrings(const char *,size_t *);
extern MagickExport const char
*GetStringInfoName(const StringInfo *),
*GetStringInfoPath(const StringInfo *);
extern MagickExport double
InterpretSiPrefixValue(const char *magick_restrict,char **magick_restrict),
*StringToArrayOfDoubles(const char *,ssize_t *, ExceptionInfo *);
extern MagickExport int
CompareStringInfo(const StringInfo *,const StringInfo *);
extern MagickExport MagickBooleanType
ConcatenateString(char **magick_restrict,const char *magick_restrict),
IsStringTrue(const char *) magick_attribute((__pure__)),
IsStringNotFalse(const char *) magick_attribute((__pure__)),
SubstituteString(char **,const char *,const char *);
extern MagickExport size_t
ConcatenateMagickString(char *magick_restrict,const char *magick_restrict,
const size_t) magick_attribute((__nonnull__)),
CopyMagickString(char *magick_restrict,const char *magick_restrict,
const size_t) magick_attribute((__nonnull__)),
GetStringInfoLength(const StringInfo *);
extern MagickExport ssize_t
FormatMagickSize(const MagickSizeType,const MagickBooleanType,char *);
extern MagickExport StringInfo
*AcquireStringInfo(const size_t),
*BlobToStringInfo(const void *,const size_t),
*CloneStringInfo(const StringInfo *),
*ConfigureFileToStringInfo(const char *),
*DestroyStringInfo(StringInfo *),
*FileToStringInfo(const char *,const size_t,ExceptionInfo *),
*SplitStringInfo(StringInfo *,const size_t),
*StringToStringInfo(const char *);
extern MagickExport unsigned char
*GetStringInfoDatum(const StringInfo *);
extern MagickExport void
ConcatenateStringInfo(StringInfo *,const StringInfo *)
magick_attribute((__nonnull__)),
PrintStringInfo(FILE *file,const char *,const StringInfo *),
ResetStringInfo(StringInfo *),
SetStringInfo(StringInfo *,const StringInfo *),
SetStringInfoDatum(StringInfo *,const unsigned char *),
SetStringInfoLength(StringInfo *,const size_t),
SetStringInfoName(StringInfo *,const char *),
SetStringInfoPath(StringInfo *,const char *),
StripString(char *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/module.h 0000644 00000004350 15051111170 0007427 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore module methods.
*/
#ifndef MAGICKCORE_MODULE_H
#define MAGICKCORE_MODULE_H
#include <time.h>
#include "magick/version.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#define MagickImageCoderSignature ((size_t) \
(((MagickLibInterface) << 8) | MAGICKCORE_QUANTUM_DEPTH))
#define MagickImageFilterSignature ((size_t) \
(((MagickLibInterface) << 8) | MAGICKCORE_QUANTUM_DEPTH))
typedef enum
{
MagickImageCoderModule,
MagickImageFilterModule
} MagickModuleType;
typedef struct _ModuleInfo
{
char
*path,
*tag;
void
*handle,
(*unregister_module)(void);
size_t
(*register_module)(void);
time_t
timestamp;
MagickBooleanType
stealth;
struct _ModuleInfo
*previous,
*next; /* deprecated, use GetModuleInfoList() */
size_t
signature;
} ModuleInfo;
typedef size_t
ImageFilterHandler(Image **,const int,const char **,ExceptionInfo *);
extern MagickExport char
**GetModuleList(const char *,const MagickModuleType,size_t *,ExceptionInfo *);
extern MagickExport const ModuleInfo
**GetModuleInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport MagickBooleanType
InvokeDynamicImageFilter(const char *,Image **,const int,const char **,
ExceptionInfo *),
ListModuleInfo(FILE *,ExceptionInfo *),
ModuleComponentGenesis(void),
OpenModule(const char *,ExceptionInfo *),
OpenModules(ExceptionInfo *);
extern MagickExport ModuleInfo
*GetModuleInfo(const char *,ExceptionInfo *);
extern MagickExport void
DestroyModuleList(void),
ModuleComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/static.h 0000644 00000024014 15051111170 0007430 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore static coder registration methods.
*/
#ifndef MAGICKCORE_STATIC_H
#define MAGICKCORE_STATIC_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
InvokeStaticImageFilter(const char *,Image **,const int,const char **,
ExceptionInfo *),
RegisterStaticModule(const char *,ExceptionInfo *exception),
UnregisterStaticModule(const char *);
extern ModuleExport size_t
RegisterAAIImage(void),
RegisterARTImage(void),
RegisterAVIImage(void),
RegisterAVSImage(void),
RegisterBIEImage(void),
RegisterBGRImage(void),
RegisterBMPImage(void),
RegisterBRAILLEImage(void),
RegisterCALSImage(void),
RegisterCAPTIONImage(void),
RegisterCINImage(void),
RegisterCIPImage(void),
RegisterCLIPImage(void),
RegisterCLIPBOARDImage(void),
RegisterCMYKImage(void),
RegisterCUTImage(void),
RegisterDCMImage(void),
RegisterDCXImage(void),
RegisterDDSImage(void),
RegisterDEBUGImage(void),
RegisterDIBImage(void),
RegisterDJVUImage(void),
RegisterDNGImage(void),
RegisterDOTImage(void),
RegisterDPSImage(void),
RegisterDPXImage(void),
RegisterEMFImage(void),
RegisterEPDFImage(void),
RegisterEPIImage(void),
RegisterEPSImage(void),
RegisterEPS2Image(void),
RegisterEPSFImage(void),
RegisterEPSIImage(void),
RegisterEPTImage(void),
RegisterEXRImage(void),
RegisterFAXImage(void),
RegisterFITSImage(void),
RegisterFLIFImage(void),
RegisterFPXImage(void),
RegisterG3Image(void),
RegisterGIFImage(void),
RegisterGIF87Image(void),
RegisterGRADIENTImage(void),
RegisterGRANITEImage(void),
RegisterGRAYImage(void),
RegisterHALDImage(void),
RegisterHDRImage(void),
RegisterHEICImage(void),
RegisterHImage(void),
RegisterHISTOGRAMImage(void),
RegisterHRZImage(void),
RegisterHTMLImage(void),
RegisterICBImage(void),
RegisterICONImage(void),
RegisterINFOImage(void),
RegisterINLINEImage(void),
RegisterIPLImage(void),
RegisterJBGImage(void),
RegisterJBIGImage(void),
RegisterJNXImage(void),
RegisterJPEGImage(void),
RegisterJP2Image(void),
RegisterJSONImage(void),
RegisterLABELImage(void),
RegisterMACImage(void),
RegisterMAGICKImage(void),
RegisterMAPImage(void),
RegisterMASKImage(void),
RegisterMATImage(void),
RegisterMATTEImage(void),
RegisterMETAImage(void),
RegisterMIFFImage(void),
RegisterMNGImage(void),
RegisterMONOImage(void),
RegisterMPCImage(void),
RegisterMPRImage(void),
RegisterMSLImage(void),
RegisterMTVImage(void),
RegisterMVGImage(void),
RegisterNETSCAPEImage(void),
RegisterNULLImage(void),
RegisterP7Image(void),
RegisterPBMImage(void),
RegisterOTBImage(void),
RegisterPALMImage(void),
RegisterPANGOImage(void),
RegisterPATTERNImage(void),
RegisterPCDImage(void),
RegisterPCDSImage(void),
RegisterPCLImage(void),
RegisterPCTImage(void),
RegisterPCXImage(void),
RegisterPDBImage(void),
RegisterPDFImage(void),
RegisterPESImage(void),
RegisterPGXImage(void),
RegisterPICImage(void),
RegisterPICTImage(void),
RegisterPIXImage(void),
RegisterPGMImage(void),
RegisterPLASMAImage(void),
RegisterPMImage(void),
RegisterPNGImage(void),
RegisterPNMImage(void),
RegisterPPMImage(void),
RegisterPREVIEWImage(void),
RegisterPSImage(void),
RegisterPS2Image(void),
RegisterPS3Image(void),
RegisterPSDImage(void),
RegisterPTIFImage(void),
RegisterPWPImage(void),
RegisterRASImage(void),
RegisterRAWImage(void),
RegisterRGBImage(void),
RegisterRGBAImage(void),
RegisterRGFImage(void),
RegisterRLAImage(void),
RegisterRLEImage(void),
RegisterSCRImage(void),
RegisterSCREENSHOTImage(void),
RegisterSCTImage(void),
RegisterSFWImage(void),
RegisterSGIImage(void),
RegisterSHTMLImage(void),
RegisterSIXELImage(void),
RegisterSTEGANOImage(void),
RegisterSUNImage(void),
RegisterSVGImage(void),
RegisterTEXTImage(void),
RegisterTGAImage(void),
RegisterTHUMBNAILImage(void),
RegisterTIFImage(void),
RegisterTIFFImage(void),
RegisterTILEImage(void),
RegisterTIMImage(void),
RegisterTTFImage(void),
RegisterTXTImage(void),
RegisterUILImage(void),
RegisterURLImage(void),
RegisterUYVYImage(void),
RegisterVDAImage(void),
RegisterVICARImage(void),
RegisterVIDImage(void),
RegisterVIDEOImage(void),
RegisterVIFFImage(void),
RegisterVIPSImage(void),
RegisterVSTImage(void),
RegisterWBMPImage(void),
RegisterWEBPImage(void),
RegisterWMFImage(void),
RegisterWPGImage(void),
RegisterXImage(void),
RegisterXBMImage(void),
RegisterXCImage(void),
RegisterXCFImage(void),
RegisterXPMImage(void),
RegisterXPSImage(void),
RegisterXVImage(void),
RegisterXWDImage(void),
RegisterYCBCRImage(void),
RegisterYUVImage(void);
extern ModuleExport void
UnregisterAAIImage(void),
UnregisterARTImage(void),
UnregisterAVIImage(void),
UnregisterAVSImage(void),
UnregisterBIEImage(void),
UnregisterBGRImage(void),
UnregisterBMPImage(void),
UnregisterBRAILLEImage(void),
UnregisterCALSImage(void),
UnregisterCAPTIONImage(void),
UnregisterCINImage(void),
UnregisterCIPImage(void),
UnregisterCLIPImage(void),
UnregisterCLIPBOARDImage(void),
UnregisterCMYKImage(void),
UnregisterCUTImage(void),
UnregisterDCMImage(void),
UnregisterDCXImage(void),
UnregisterDDSImage(void),
UnregisterDEBUGImage(void),
UnregisterDIBImage(void),
UnregisterDJVUImage(void),
UnregisterDNGImage(void),
UnregisterDOTImage(void),
UnregisterDPSImage(void),
UnregisterDPXImage(void),
UnregisterEMFImage(void),
UnregisterEPDFImage(void),
UnregisterEPIImage(void),
UnregisterEPSImage(void),
UnregisterEPS2Image(void),
UnregisterEPSFImage(void),
UnregisterEPSIImage(void),
UnregisterEPTImage(void),
UnregisterEXRImage(void),
UnregisterFAXImage(void),
UnregisterFITSImage(void),
UnregisterFLIFImage(void),
UnregisterFPXImage(void),
UnregisterG3Image(void),
UnregisterGIFImage(void),
UnregisterGIF87Image(void),
UnregisterGRADIENTImage(void),
UnregisterGRANITEImage(void),
UnregisterGRAYImage(void),
UnregisterHALDImage(void),
UnregisterHDRImage(void),
UnregisterHEICImage(void),
UnregisterHImage(void),
UnregisterHISTOGRAMImage(void),
UnregisterHRZImage(void),
UnregisterHTMLImage(void),
UnregisterICBImage(void),
UnregisterICONImage(void),
UnregisterINFOImage(void),
UnregisterINLINEImage(void),
UnregisterIPLImage(void),
UnregisterJBGImage(void),
UnregisterJBIGImage(void),
UnregisterJNXImage(void),
UnregisterJPEGImage(void),
UnregisterJP2Image(void),
UnregisterJSONImage(void),
UnregisterLABELImage(void),
UnregisterLOCALEImage(void),
UnregisterMACImage(void),
UnregisterMAGICKImage(void),
UnregisterMAPImage(void),
UnregisterMASKImage(void),
UnregisterMATImage(void),
UnregisterMATTEImage(void),
UnregisterMETAImage(void),
UnregisterMIFFImage(void),
UnregisterMNGImage(void),
UnregisterMONOImage(void),
UnregisterMPCImage(void),
UnregisterMPRImage(void),
UnregisterMSLImage(void),
UnregisterMTVImage(void),
UnregisterMVGImage(void),
UnregisterNETSCAPEImage(void),
UnregisterNULLImage(void),
UnregisterP7Image(void),
UnregisterPBMImage(void),
UnregisterOTBImage(void),
UnregisterPALMImage(void),
UnregisterPANGOImage(void),
UnregisterPATTERNImage(void),
UnregisterPCDImage(void),
UnregisterPCDSImage(void),
UnregisterPCLImage(void),
UnregisterPCTImage(void),
UnregisterPCXImage(void),
UnregisterPDBImage(void),
UnregisterPDFImage(void),
UnregisterPESImage(void),
UnregisterPGXImage(void),
UnregisterPICImage(void),
UnregisterPICTImage(void),
UnregisterPIXImage(void),
UnregisterPLASMAImage(void),
UnregisterPGMImage(void),
UnregisterPMImage(void),
UnregisterPNGImage(void),
UnregisterPNMImage(void),
UnregisterPPMImage(void),
UnregisterPREVIEWImage(void),
UnregisterPSImage(void),
UnregisterPS2Image(void),
UnregisterPS3Image(void),
UnregisterPSDImage(void),
UnregisterPTIFImage(void),
UnregisterPWPImage(void),
UnregisterRASImage(void),
UnregisterRAWImage(void),
UnregisterRGBImage(void),
UnregisterRGBAImage(void),
UnregisterRGFImage(void),
UnregisterRLAImage(void),
UnregisterRLEImage(void),
UnregisterSCRImage(void),
UnregisterSCREENSHOTImage(void),
UnregisterSCTImage(void),
UnregisterSFWImage(void),
UnregisterSGIImage(void),
UnregisterSHTMLImage(void),
UnregisterSIXELImage(void),
UnregisterSTEGANOImage(void),
UnregisterSUNImage(void),
UnregisterSVGImage(void),
UnregisterTEXTImage(void),
UnregisterTGAImage(void),
UnregisterTHUMBNAILImage(void),
UnregisterTIFImage(void),
UnregisterTIFFImage(void),
UnregisterTILEImage(void),
UnregisterTIMImage(void),
UnregisterTTFImage(void),
UnregisterTXTImage(void),
UnregisterUILImage(void),
UnregisterURLImage(void),
UnregisterUYVYImage(void),
UnregisterVDAImage(void),
UnregisterVICARImage(void),
UnregisterVIDImage(void),
UnregisterVIDEOImage(void),
UnregisterVIFFImage(void),
UnregisterVIPSImage(void),
UnregisterVSTImage(void),
UnregisterWBMPImage(void),
UnregisterWEBPImage(void),
UnregisterWMFImage(void),
UnregisterWPGImage(void),
UnregisterXImage(void),
UnregisterXBMImage(void),
UnregisterXCImage(void),
UnregisterXCFImage(void),
UnregisterXPMImage(void),
UnregisterXPSImage(void),
UnregisterXVImage(void),
UnregisterXWDImage(void),
UnregisterYCBCRImage(void),
UnregisterYUVImage(void);
extern MagickExport void
RegisterStaticModules(void),
UnregisterStaticModules(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/hashmap.h 0000644 00000005534 15051111170 0007570 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore hash methods.
*/
#ifndef MAGICKCORE_HASHMAP_H
#define MAGICKCORE_HASHMAP_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#define SmallHashmapSize 17
#define MediumHashmapSize 509
#define LargeHashmapSize 8191
#define HugeHashmapSize 131071
typedef struct _HashmapInfo
HashmapInfo;
typedef struct _LinkedListInfo
LinkedListInfo;
extern MagickExport HashmapInfo
*DestroyHashmap(HashmapInfo *),
*NewHashmap(const size_t,size_t (*)(const void *),MagickBooleanType (*)
(const void *,const void *),void *(*)(void *),void *(*)(void *));
extern MagickExport LinkedListInfo
*DestroyLinkedList(LinkedListInfo *,void *(*)(void *)),
*NewLinkedList(const size_t);
extern MagickExport MagickBooleanType
AppendValueToLinkedList(LinkedListInfo *,const void *),
CompareHashmapString(const void *,const void *),
CompareHashmapStringInfo(const void *,const void *),
InsertValueInLinkedList(LinkedListInfo *,const size_t,const void *),
InsertValueInSortedLinkedList(LinkedListInfo *,
int (*)(const void *,const void *),void **,const void *),
IsHashmapEmpty(const HashmapInfo *),
IsLinkedListEmpty(const LinkedListInfo *),
LinkedListToArray(LinkedListInfo *,void **),
PutEntryInHashmap(HashmapInfo *,const void *,const void *);
extern MagickExport size_t
GetNumberOfElementsInLinkedList(const LinkedListInfo *),
GetNumberOfEntriesInHashmap(const HashmapInfo *),
HashPointerType(const void *),
HashStringType(const void *),
HashStringInfoType(const void *);
extern MagickExport void
ClearLinkedList(LinkedListInfo *,void *(*)(void *)),
*GetLastValueInLinkedList(LinkedListInfo *),
*GetNextKeyInHashmap(HashmapInfo *),
*GetNextValueInHashmap(HashmapInfo *),
*GetNextValueInLinkedList(LinkedListInfo *),
*GetValueFromHashmap(HashmapInfo *,const void *),
*GetValueFromLinkedList(LinkedListInfo *,const size_t),
*RemoveElementByValueFromLinkedList(LinkedListInfo *,const void *),
*RemoveElementFromLinkedList(LinkedListInfo *,const size_t),
*RemoveEntryFromHashmap(HashmapInfo *,const void *),
*RemoveLastElementFromLinkedList(LinkedListInfo *),
ResetHashmapIterator(HashmapInfo *),
ResetLinkedListIterator(LinkedListInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/timer.h 0000644 00000003101 15051111170 0007253 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore timer methods.
*/
#ifndef MAGICKCORE_TIMER_H
#define MAGICKCORE_TIMER_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedTimerState,
StoppedTimerState,
RunningTimerState
} TimerState;
typedef struct _Timer
{
double
start,
stop,
total;
} Timer;
typedef struct _TimerInfo
{
Timer
user,
elapsed;
TimerState
state;
size_t
signature;
} TimerInfo;
extern MagickExport double
GetElapsedTime(TimerInfo *),
GetUserTime(TimerInfo *);
extern MagickExport MagickBooleanType
ContinueTimer(TimerInfo *);
extern MagickExport ssize_t
FormatMagickTime(const time_t,const size_t,char *);
extern MagickExport TimerInfo
*AcquireTimerInfo(void),
*DestroyTimerInfo(TimerInfo *);
extern MagickExport void
GetTimerInfo(TimerInfo *),
ResetTimer(TimerInfo *),
StartTimer(TimerInfo *,const MagickBooleanType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/transform.h 0000644 00000003634 15051111170 0010161 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image transform methods.
*/
#ifndef MAGICKCORE_TRANSFORM_H
#define MAGICKCORE_TRANSFORM_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport Image
*AutoOrientImage(const Image *,const OrientationType,ExceptionInfo *),
*ChopImage(const Image *,const RectangleInfo *,ExceptionInfo *),
*ConsolidateCMYKImages(const Image *,ExceptionInfo *),
*CropImage(const Image *,const RectangleInfo *,ExceptionInfo *),
*CropImageToTiles(const Image *,const char *, ExceptionInfo *),
*ExcerptImage(const Image *,const RectangleInfo *,ExceptionInfo *),
*ExtentImage(const Image *,const RectangleInfo *,ExceptionInfo *),
*FlipImage(const Image *,ExceptionInfo *),
*FlopImage(const Image *,ExceptionInfo *),
*RollImage(const Image *,const ssize_t,const ssize_t,ExceptionInfo *),
*ShaveImage(const Image *,const RectangleInfo *,ExceptionInfo *),
*SpliceImage(const Image *,const RectangleInfo *,ExceptionInfo *),
*TransposeImage(const Image *,ExceptionInfo *),
*TransverseImage(const Image *,ExceptionInfo *),
*TrimImage(const Image *,ExceptionInfo *);
extern MagickExport MagickBooleanType
TransformImage(Image **,const char *,const char *),
TransformImages(Image **,const char *,const char *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/identify.h 0000644 00000001666 15051111170 0007764 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image identify method.
*/
#ifndef MAGICKCORE_IDENTIFY_H
#define MAGICKCORE_IDENTIFY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
IdentifyImage(Image *,FILE *,const MagickBooleanType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/decorate.h 0000644 00000002350 15051111170 0007726 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image decorate methods.
*/
#ifndef MAGICKCORE_DECORATE_H
#define MAGICKCORE_DECORATE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _FrameInfo
{
size_t
width,
height;
ssize_t
x,
y,
inner_bevel,
outer_bevel;
} FrameInfo;
extern MagickExport Image
*BorderImage(const Image *,const RectangleInfo *,ExceptionInfo *),
*FrameImage(const Image *,const FrameInfo *,ExceptionInfo *);
extern MagickExport MagickBooleanType
RaiseImage(Image *,const RectangleInfo *,const MagickBooleanType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/morphology.h 0000644 00000011072 15051111170 0010340 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore morphology methods.
*/
#ifndef MAGICKCORE_MORPHOLOGY_H
#define MAGICKCORE_MORPHOLOGY_H
#include "magick/geometry.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedKernel, /* equivalent to UnityKernel */
UnityKernel, /* The no-op or 'original image' kernel */
GaussianKernel, /* Convolution Kernels, Gaussian Based */
DoGKernel,
LoGKernel,
BlurKernel,
CometKernel,
LaplacianKernel, /* Convolution Kernels, by Name */
SobelKernel,
FreiChenKernel,
RobertsKernel,
PrewittKernel,
CompassKernel,
KirschKernel,
DiamondKernel, /* Shape Kernels */
SquareKernel,
RectangleKernel,
OctagonKernel,
DiskKernel,
PlusKernel,
CrossKernel,
RingKernel,
PeaksKernel, /* Hit And Miss Kernels */
EdgesKernel,
CornersKernel,
DiagonalsKernel,
LineEndsKernel,
LineJunctionsKernel,
RidgesKernel,
ConvexHullKernel,
ThinSEKernel,
SkeletonKernel,
ChebyshevKernel, /* Distance Measuring Kernels */
ManhattanKernel,
OctagonalKernel,
EuclideanKernel,
UserDefinedKernel, /* User Specified Kernel Array */
BinomialKernel
} KernelInfoType;
typedef enum
{
UndefinedMorphology,
/* Convolve / Correlate weighted sums */
ConvolveMorphology, /* Weighted Sum with reflected kernel */
CorrelateMorphology, /* Weighted Sum using a sliding window */
/* Low-level Morphology methods */
ErodeMorphology, /* Minimum Value in Neighbourhood */
DilateMorphology, /* Maximum Value in Neighbourhood */
ErodeIntensityMorphology, /* Pixel Pick using GreyScale Erode */
DilateIntensityMorphology, /* Pixel Pick using GreyScale Dialate */
DistanceMorphology, /* Add Kernel Value, take Minimum */
/* Second-level Morphology methods */
OpenMorphology, /* Dilate then Erode */
CloseMorphology, /* Erode then Dilate */
OpenIntensityMorphology, /* Pixel Pick using GreyScale Open */
CloseIntensityMorphology, /* Pixel Pick using GreyScale Close */
SmoothMorphology, /* Open then Close */
/* Difference Morphology methods */
EdgeInMorphology, /* Dilate difference from Original */
EdgeOutMorphology, /* Erode difference from Original */
EdgeMorphology, /* Dilate difference with Erode */
TopHatMorphology, /* Close difference from Original */
BottomHatMorphology, /* Open difference from Original */
/* Recursive Morphology methods */
HitAndMissMorphology, /* Foreground/Background pattern matching */
ThinningMorphology, /* Remove matching pixels from image */
ThickenMorphology, /* Add matching pixels from image */
/* Experimental Morphology methods */
VoronoiMorphology, /* distance matte channel copy nearest color */
IterativeDistanceMorphology /* Add Kernel Value, take Minimum */
} MorphologyMethod;
typedef struct KernelInfo
{
KernelInfoType
type;
size_t
width,
height;
ssize_t
x,
y;
double
*values,
minimum,
maximum,
negative_range,
positive_range,
angle;
struct KernelInfo
*next;
size_t
signature;
} KernelInfo;
extern MagickExport KernelInfo
*AcquireKernelInfo(const char *),
*AcquireKernelBuiltIn(const KernelInfoType,const GeometryInfo *),
*CloneKernelInfo(const KernelInfo *),
*DestroyKernelInfo(KernelInfo *);
extern MagickExport Image
*MorphologyImage(const Image *,const MorphologyMethod,const ssize_t,
const KernelInfo *,ExceptionInfo *),
*MorphologyImageChannel(const Image *,const ChannelType,
const MorphologyMethod,const ssize_t,const KernelInfo *,ExceptionInfo *);
extern MagickExport void
ScaleGeometryKernelInfo(KernelInfo *,const char *),
ScaleKernelInfo(KernelInfo *,const double,const GeometryFlags),
ShowKernelInfo(const KernelInfo *),
UnityAddKernelInfo(KernelInfo *,const double);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/pixel-accessor.h 0000644 00000020632 15051111170 0011064 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore pixel accessor methods.
*/
#ifndef MAGICKCORE_PIXEL_ACCESSOR_H
#define MAGICKCORE_PIXEL_ACCESSOR_H
#include <math.h>
#include "magick/gem.h"
#include "magick/pixel.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#define ClampPixelRed(pixel) ClampToQuantum((pixel)->red)
#define ClampPixelGreen(pixel) ClampToQuantum((pixel)->green)
#define ClampPixelBlue(pixel) ClampToQuantum((pixel)->blue)
#define ClampPixelIndex(indexes) ClampToQuantum(*(indexes))
#define ClampPixelOpacity(pixel) ClampToQuantum((pixel)->opacity)
#define GetPixela(pixel) ((pixel)->green)
#define GetPixelb(pixel) ((pixel)->blue)
#define GetPixelAlpha(pixel) ((double) QuantumRange-(double) (pixel)->opacity)
#define GetPixelBlack(indexes) (*(indexes))
#define GetPixelBlue(pixel) ((pixel)->blue)
#define GetPixelCb(pixel) ((pixel)->green)
#define GetPixelCr(pixel) ((pixel)->blue)
#define GetPixelCyan(pixel) ((pixel)->red)
#define GetPixelGray(pixel) ((pixel)->red)
#define GetPixelGreen(pixel) ((pixel)->green)
#define GetPixelIndex(indexes) (*(indexes))
#define GetPixelL(pixel) ((pixel)->red)
#define GetPixelLabel(pixel) ((ssize_t) (pixel)->red)
#define GetPixelMagenta(pixel) ((pixel)->green)
#define GetPixelNext(pixel) ((pixel)+1)
#define GetPixelOpacity(pixel) ((pixel)->opacity)
#define GetPixelRed(pixel) ((pixel)->red)
#define GetPixelRGB(pixel,packet) \
{ \
(packet)->red=GetPixelRed((pixel)); \
(packet)->green=GetPixelGreen((pixel)); \
(packet)->blue=GetPixelBlue((pixel)); \
}
#define GetPixelRGBO(pixel,packet) \
{ \
(packet)->red=GetPixelRed((pixel)); \
(packet)->green=GetPixelGreen((pixel)); \
(packet)->blue=GetPixelBlue((pixel)); \
(packet)->opacity=GetPixelOpacity((pixel)); \
}
#define GetPixelY(pixel) ((pixel)->red)
#define GetPixelYellow(pixel) ((pixel)->blue)
#define SetPixela(pixel,value) ((pixel)->green=(Quantum) (value))
#define SetPixelAlpha(pixel,value) \
((pixel)->opacity=(Quantum) ((double) QuantumRange-(double) (value)))
#define SetPixelb(pixel,value) ((pixel)->blue=(Quantum) (value))
#define SetPixelBlack(indexes,value) (*(indexes)=(Quantum) (value))
#define SetPixelBlue(pixel,value) ((pixel)->blue=(Quantum) (value))
#define SetPixelCb(pixel,value) ((pixel)->green=(Quantum) (value))
#define SetPixelCr(pixel,value) ((pixel)->blue=(Quantum) (value))
#define SetPixelCyan(pixel,value) ((pixel)->red=(Quantum) (value))
#define SetPixelGray(pixel,value) \
((pixel)->red=(pixel)->green=(pixel)->blue=(Quantum) (value))
#define SetPixelGreen(pixel,value) ((pixel)->green=(Quantum) (value))
#define SetPixelIndex(indexes,value) (*(indexes)=(IndexPacket) (value))
#define SetPixelL(pixel,value) ((pixel)->red=(Quantum) (value))
#define SetPixelMagenta(pixel,value) ((pixel)->green=(Quantum) (value))
#define SetPixelOpacity(pixel,value) ((pixel)->opacity=(Quantum) (value))
#define SetPixelRed(pixel,value) ((pixel)->red=(Quantum) (value))
#define SetPixelRgb(pixel,packet) \
{ \
SetPixelRed(pixel,(packet)->red); \
SetPixelGreen(pixel,(packet)->green); \
SetPixelBlue(pixel,(packet)->blue); \
}
#define SetPixelRGBA(pixel,packet) \
{ \
SetPixelRed(pixel,(packet)->red); \
SetPixelGreen(pixel,(packet)->green); \
SetPixelBlue(pixel,(packet)->blue); \
SetPixelAlpha(pixel,(QuantumRange-(packet)->opacity)); \
}
#define SetPixelRGBO(pixel,packet) \
{ \
SetPixelRed(pixel,(packet)->red); \
SetPixelGreen(pixel,(packet)->green); \
SetPixelBlue(pixel,(packet)->blue); \
SetPixelOpacity(pixel,(packet)->opacity); \
}
#define SetPixelYellow(pixel,value) ((pixel)->blue=(Quantum) (value))
#define SetPixelY(pixel,value) ((pixel)->red=(Quantum) (value))
static inline MagickRealType AbsolutePixelValue(const MagickRealType x)
{
return(x < 0.0 ? -x : x);
}
static inline Quantum ClampPixel(const MagickRealType value)
{
if (value < 0.0)
return((Quantum) 0);
if (value >= (MagickRealType) QuantumRange)
return((Quantum) QuantumRange);
#if !defined(MAGICKCORE_HDRI_SUPPORT)
return((Quantum) (value+0.5));
#else
return((Quantum) value);
#endif
}
static inline double PerceptibleReciprocal(const double x)
{
double
sign;
/*
Return 1/x where x is perceptible (not unlimited or infinitesimal).
*/
sign=x < 0.0 ? -1.0 : 1.0;
if ((sign*x) >= MagickEpsilon)
return(1.0/x);
return(sign/MagickEpsilon);
}
static inline MagickRealType GetPixelLuma(
const Image *magick_restrict image,const PixelPacket *magick_restrict pixel)
{
MagickRealType
intensity;
(void) image;
intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
0.072186f*pixel->blue);
return(intensity);
}
static inline MagickRealType GetPixelLuminance(
const Image *magick_restrict image,const PixelPacket *magick_restrict pixel)
{
MagickRealType
intensity;
if (image->colorspace != sRGBColorspace)
{
intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
0.072186f*pixel->blue);
return(intensity);
}
intensity=(MagickRealType) (0.212656*DecodePixelGamma((MagickRealType)
pixel->red)+0.715158*DecodePixelGamma((MagickRealType) pixel->green)+
0.072186*DecodePixelGamma((MagickRealType) pixel->blue));
return(intensity);
}
static inline void GetPixelPacketRGBA(const Quantum red,const Quantum green,
const Quantum blue,const Quantum opacity,PixelPacket *magick_restrict pixel)
{
pixel->red=red;
pixel->green=green;
pixel->blue=blue;
pixel->opacity=opacity;
}
static inline MagickBooleanType IsPixelAtDepth(const Quantum pixel,
const QuantumAny range)
{
Quantum
quantum;
if (range == 0)
return(MagickTrue);
#if !defined(MAGICKCORE_HDRI_SUPPORT)
quantum=(Quantum) (((MagickRealType) QuantumRange*((QuantumAny)
(((MagickRealType) range*pixel)/QuantumRange+0.5)))/range+0.5);
#else
quantum=(Quantum) (((MagickRealType) QuantumRange*((QuantumAny)
(((MagickRealType) range*(MagickRealType) pixel)/(MagickRealType) QuantumRange+
0.5)))/(MagickRealType) range);
#endif
return(pixel == quantum ? MagickTrue : MagickFalse);
}
static inline MagickBooleanType IsPixelGray(const PixelPacket *pixel)
{
MagickRealType
green_blue,
red_green;
red_green=(MagickRealType) pixel->red-(MagickRealType) pixel->green;
green_blue=(MagickRealType) pixel->green-(MagickRealType) pixel->blue;
if (((QuantumScale*AbsolutePixelValue(red_green)) < MagickEpsilon) &&
((QuantumScale*AbsolutePixelValue(green_blue)) < MagickEpsilon))
return(MagickTrue);
return(MagickFalse);
}
static inline MagickBooleanType IsPixelMonochrome(
const PixelPacket *pixel)
{
MagickRealType
green_blue,
red,
red_green;
red=(MagickRealType) pixel->red;
if ((AbsolutePixelValue(red) >= MagickEpsilon) &&
(AbsolutePixelValue(red-(double) QuantumRange) >= MagickEpsilon))
return(MagickFalse);
red_green=(MagickRealType) pixel->red-(double) pixel->green;
green_blue=(MagickRealType) pixel->green-(double) pixel->blue;
if (((QuantumScale*AbsolutePixelValue(red_green)) < MagickEpsilon) &&
((QuantumScale*AbsolutePixelValue(green_blue)) < MagickEpsilon))
return(MagickTrue);
return(MagickFalse);
}
static inline Quantum PixelPacketIntensity(const PixelPacket *pixel)
{
MagickRealType
intensity;
if ((pixel->red == pixel->green) && (pixel->green == pixel->blue))
return(pixel->red);
intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
0.072186f*pixel->blue);
return(ClampToQuantum(intensity));
}
static inline void SetPixelViaMagickPixel(const Image *magick_restrict image,
const MagickPixelPacket *magick_restrict magick_pixel,
PixelPacket *magick_restrict pixel)
{
pixel->red=ClampToQuantum(magick_pixel->red);
pixel->green=ClampToQuantum(magick_pixel->green);
pixel->blue=ClampToQuantum(magick_pixel->blue);
if (image->matte != MagickFalse)
pixel->opacity=ClampToQuantum(magick_pixel->opacity);
}
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/studio.h 0000644 00000024612 15051111170 0007454 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore private application programming interface declarations.
*/
#ifndef MAGICKCORE_STUDIO_H
#define MAGICKCORE_STUDIO_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if defined(WIN32) || defined(WIN64)
# define MAGICKCORE_WINDOWS_SUPPORT
#else
# define MAGICKCORE_POSIX_SUPPORT
#endif
#define MAGICKCORE_IMPLEMENTATION 1
#if !defined(MAGICKCORE_CONFIG_H)
# define MAGICKCORE_CONFIG_H
# if !defined(vms) && !defined(macintosh)
# include "magick/magick-config.h"
# else
# include "magick-config.h"
# endif
#if defined(MAGICKCORE__FILE_OFFSET_BITS) && !defined(_FILE_OFFSET_BITS)
# define _FILE_OFFSET_BITS MAGICKCORE__FILE_OFFSET_BITS
#endif
#if defined(_magickcore_const) && !defined(const)
# define const _magickcore_const
#endif
#if defined(_magickcore_inline) && !defined(inline)
# define inline _magickcore_inline
#endif
# if defined(__cplusplus) || defined(c_plusplus)
# undef inline
# endif
#endif
#if defined(MAGICKCORE_NAMESPACE_PREFIX)
# include "magick/methods.h"
#endif
#if !defined(const)
# define STDC
#endif
/* Define to 1 if assertions should be disabled. */
#if defined(MAGICKCORE_NDEBUG)
#define NDEBUG 1
#endif
#include <stdarg.h>
#include <stdio.h>
#if defined(MAGICKCORE_HAVE_SYS_STAT_H)
# include <sys/stat.h>
#endif
#if defined(MAGICKCORE_STDC_HEADERS)
# include <stdlib.h>
# include <stddef.h>
#else
# if defined(MAGICKCORE_HAVE_STDLIB_H)
# include <stdlib.h>
# endif
#endif
#if !defined(magick_restrict)
# if !defined(_magickcore_restrict)
# define magick_restrict restrict
# else
# define magick_restrict _magickcore_restrict
# endif
#endif
#if defined(MAGICKCORE_HAVE_STRING_H)
# if !defined(STDC_HEADERS) && defined(MAGICKCORE_HAVE_MEMORY_H)
# include <memory.h>
# endif
# include <string.h>
#endif
#if defined(MAGICKCORE_HAVE_STRINGS_H)
# include <strings.h>
#endif
#if defined(MAGICKCORE_HAVE_INTTYPES_H)
# include <inttypes.h>
#endif
#if defined(MAGICKCORE_HAVE_STDINT_H)
# include <stdint.h>
#endif
#if defined(MAGICKCORE_HAVE_UNISTD_H)
# include <unistd.h>
#endif
#if defined(MAGICKCORE_WINDOWS_SUPPORT) && defined(_DEBUG)
#define _CRTDBG_MAP_ALLOC
#endif
#if defined(MAGICKCORE_WINDOWS_SUPPORT)
# include <io.h>
#if !defined(__CYGWIN__)
# include <direct.h>
#endif
# if !defined(MAGICKCORE_HAVE_STRERROR)
# define HAVE_STRERROR
# endif
#endif
#include <ctype.h>
#include <locale.h>
#include <errno.h>
#include <fcntl.h>
#include <math.h>
#include <time.h>
#include <limits.h>
#include <signal.h>
#include <assert.h>
#if defined(MAGICKCORE_HAVE_XLOCALE_H)
# include <xlocale.h>
#endif
#if defined(MAGICKCORE_THREAD_SUPPORT)
# include <pthread.h>
#endif
#if defined(MAGICKCORE_WINDOWS_SUPPORT)
#if !defined(__CYGWIN__)
#include <winsock2.h>
#include <ws2tcpip.h>
#endif
#include <windows.h>
#ifdef _MSC_VER
#pragma comment (lib, "ws2_32.lib")
#endif
#endif
#if defined(MAGICKCORE_HAVE_SYS_SYSLIMITS_H)
# include <sys/syslimits.h>
#endif
#if defined(MAGICKCORE_HAVE_ARM_LIMITS_H)
# include <arm/limits.h>
#endif
#if defined(MAGICKCORE_HAVE_CL_CL_H) && !defined(MAGICK_PIXEL_RGBA)
# define MAGICKCORE_OPENCL_SUPPORT 1
#endif
#if defined(MAGICKCORE_HAVE_OPENCL_CL_H) && !defined(MAGICK_PIXEL_RGBA)
# define MAGICKCORE_OPENCL_SUPPORT 1
#endif
#if defined(_OPENMP) && ((_OPENMP >= 200203) || defined(__OPENCC__))
# include <omp.h>
# define MAGICKCORE_OPENMP_SUPPORT 1
#endif
#if defined(MAGICKCORE_HAVE_PREAD) && defined(MAGICKCORE_HAVE_DECL_PREAD) && !MAGICKCORE_HAVE_DECL_PREAD
ssize_t pread(int,void *,size_t,off_t);
#endif
#if defined(MAGICKCORE_HAVE_PWRITE) && defined(MAGICKCORE_HAVE_DECL_PWRITE) && !MAGICKCORE_HAVE_DECL_PWRITE
ssize_t pwrite(int,const void *,size_t,off_t);
#endif
#if defined(MAGICKCORE_HAVE_STRLCPY) && defined(MAGICKCORE_HAVE_DECL_STRLCPY) && !MAGICKCORE_HAVE_DECL_STRLCPY
extern size_t strlcpy(char *,const char *,size_t);
#endif
#if defined(MAGICKCORE_HAVE_VSNPRINTF) && defined(MAGICKCORE_HAVE_DECL_VSNPRINTF) && !MAGICKCORE_HAVE_DECL_VSNPRINTF
extern int vsnprintf(char *,size_t,const char *,va_list);
#endif
#include "magick/method-attribute.h"
#if defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(MAGICKCORE_POSIX_SUPPORT)
# include <sys/types.h>
# include <sys/stat.h>
# if defined(MAGICKCORE_POSIX_SUPPORT)
# if defined(MAGICKCORE_HAVE_SYS_NDIR_H) || defined(MAGICKCORE_HAVE_SYS_DIR_H) || defined(MAGICKCORE_HAVE_NDIR_H)
# define dirent direct
# define NAMLEN(dirent) (dirent)->d_namlen
# if defined(MAGICKCORE_HAVE_SYS_NDIR_H)
# include <sys/ndir.h>
# endif
# if defined(MAGICKCORE_HAVE_SYS_DIR_H)
# include <sys/dir.h>
# endif
# if defined(MAGICKCORE_HAVE_NDIR_H)
# include <ndir.h>
# endif
# else
# include <dirent.h>
# define NAMLEN(dirent) strlen((dirent)->d_name)
# endif
# include <sys/wait.h>
# include <pwd.h>
# endif
# if !defined(S_ISDIR)
# define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
# endif
# if !defined(S_ISREG)
# define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG)
# endif
# include "magick/magick-type.h"
# if !defined(MAGICKCORE_WINDOWS_SUPPORT)
# include <sys/time.h>
# if defined(MAGICKCORE_HAVE_SYS_TIMES_H)
# include <sys/times.h>
# endif
# if defined(MAGICKCORE_HAVE_SYS_RESOURCE_H)
# include <sys/resource.h>
# endif
# if defined(MAGICKCORE_HAVE_SYS_MMAN_H)
# include <sys/mman.h>
# endif
# if defined(MAGICKCORE_HAVE_SYS_SENDFILE_H)
# include <sys/sendfile.h>
# endif
# if defined(MAGICKCORE_HAVE_SYS_SOCKET_H)
# include <sys/socket.h>
# endif
# if defined(MAGICKCORE_HAVE_SYS_UIO_H)
# include <sys/uio.h>
# endif
#endif
#else
# include <types.h>
# include <stat.h>
# if defined(macintosh)
# if !defined(DISABLE_SIOUX)
# include <SIOUX.h>
# include <console.h>
# endif
# include <unix.h>
# endif
# include "magick/magick-type.h"
#endif
#if defined(S_IRUSR) && defined(S_IWUSR)
# define S_MODE (S_IRUSR | S_IWUSR)
#elif defined (MAGICKCORE_WINDOWS_SUPPORT)
# define S_MODE (_S_IREAD | _S_IWRITE)
#else
# define S_MODE 0600
#endif
#if defined(MAGICKCORE_WINDOWS_SUPPORT)
# include "magick/nt-base.h"
#endif
#if defined(macintosh)
# include "magick/mac.h"
#endif
#if defined(vms)
# include "magick/vms.h"
#endif
#undef HAVE_CONFIG_H
#undef gamma
#undef index
#undef pipe
#undef y1
/*
Review these platform specific definitions.
*/
#if ( defined(MAGICKCORE_POSIX_SUPPORT) && !defined(__OS2__) ) && !defined( __VMS )
# define DirectorySeparator "/"
# define DirectoryListSeparator ':'
# define EditorOptions " -title \"Edit Image Comment\" -e vi"
# define Exit exit
# define IsBasenameSeparator(c) ((c) == '/' ? MagickTrue : MagickFalse)
# define X11_PREFERENCES_PATH "~/."
# define ProcessPendingEvents(text)
# define ReadCommandlLine(argc,argv)
# define SetNotifyHandlers
#else
# if defined(vms)
# define X11_APPLICATION_PATH "decw$system_defaults:"
# define DirectorySeparator ""
# define DirectoryListSeparator ';'
# define EditorOptions ""
# define Exit exit
# define IsBasenameSeparator(c) \
(((c) == ']') || ((c) == ':') || ((c) == '/') ? MagickTrue : MagickFalse)
# define MAGICKCORE_LIBRARY_ABSOLUTE_PATH "sys$login:"
# define MAGICKCORE_SHARE_PATH "sys$login:"
# define X11_PREFERENCES_PATH "decw$user_defaults:"
# define ProcessPendingEvents(text)
# define ReadCommandlLine(argc,argv)
# define SetNotifyHandlers
# endif
# if defined(__OS2__)
# define DirectorySeparator "\\"
# define DirectoryListSeparator ';'
# define EditorOptions " -title \"Edit Image Comment\" -e vi"
# define Exit exit
# define IsBasenameSeparator(c) \
(((c) == '/') || ((c) == '\\') ? MagickTrue : MagickFalse)
# define PreferencesDefaults "~\."
# define ProcessPendingEvents(text)
# define ReadCommandlLine(argc,argv)
# define SetNotifyHandlers
#endif
# if defined(macintosh)
# define X11_APPLICATION_PATH "/usr/lib/X11/app-defaults/"
# define DirectorySeparator ":"
# define DirectoryListSeparator ';'
# define EditorOptions ""
# define IsBasenameSeparator(c) ((c) == ':' ? MagickTrue : MagickFalse)
# define MAGICKCORE_LIBRARY_ABSOLUTE_PATH ""
# define MAGICKCORE_SHARE_PATH ""
# define X11_PREFERENCES_PATH "~/."
# if defined(DISABLE_SIOUX)
# define ReadCommandlLine(argc,argv)
# define SetNotifyHandlers \
SetFatalErrorHandler(MacFatalErrorHandler); \
SetErrorHandler(MACErrorHandler); \
SetWarningHandler(MACWarningHandler)
# else
# define ReadCommandlLine(argc,argv) argc=ccommand(argv); puts(MagickVersion);
# define SetNotifyHandlers \
SetErrorHandler(MACErrorHandler); \
SetWarningHandler(MACWarningHandler)
# endif
# endif
# if defined(MAGICKCORE_WINDOWS_SUPPORT)
# define DirectorySeparator "\\"
# define DirectoryListSeparator ';'
# define EditorOptions ""
# define IsBasenameSeparator(c) \
(((c) == '/') || ((c) == '\\') ? MagickTrue : MagickFalse)
# define ProcessPendingEvents(text)
# if !defined(X11_PREFERENCES_PATH)
# define X11_PREFERENCES_PATH "~\\."
# endif
# define ReadCommandlLine(argc,argv)
# define SetNotifyHandlers \
SetErrorHandler(NTErrorHandler); \
SetWarningHandler(NTWarningHandler)
# if !defined(MAGICKCORE_HAVE_TIFFCONF_H)
# define HAVE_TIFFCONF_H
# endif
# endif
#endif
/*
Define system symbols if not already defined.
*/
#if !defined(STDIN_FILENO)
#define STDIN_FILENO 0x00
#endif
#if !defined(O_BINARY)
#define O_BINARY 0x00
#endif
#if !defined(PATH_MAX)
#define PATH_MAX 4096
#endif
#if defined(MAGICKCORE_LTDL_DELEGATE) || (defined(MAGICKCORE_WINDOWS_SUPPORT) && defined(_DLL) && !defined(_LIB))
# define MAGICKCORE_MODULES_SUPPORT
#endif
#if defined(_MAGICKMOD_)
# undef MAGICKCORE_BUILD_MODULES
# define MAGICKCORE_BUILD_MODULES
#endif
/*
Magick defines.
*/
#define MagickMaxRecursionDepth 600
#define Swap(x,y) ((x)^=(y), (y)^=(x), (x)^=(y))
#if defined(_MSC_VER)
# define DisableMSCWarning(nr) __pragma(warning(push)) \
__pragma(warning(disable:nr))
# define RestoreMSCWarning __pragma(warning(pop))
#else
# define DisableMSCWarning(nr)
# define RestoreMSCWarning
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/composite.h 0000644 00000006312 15051111170 0010144 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image composite methods.
*/
#ifndef MAGICKCORE_COMPOSITE_H
#define MAGICKCORE_COMPOSITE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedCompositeOp,
NoCompositeOp,
ModulusAddCompositeOp,
AtopCompositeOp,
BlendCompositeOp,
BumpmapCompositeOp,
ChangeMaskCompositeOp,
ClearCompositeOp,
ColorBurnCompositeOp,
ColorDodgeCompositeOp,
ColorizeCompositeOp,
CopyBlackCompositeOp,
CopyBlueCompositeOp,
CopyCompositeOp,
CopyCyanCompositeOp,
CopyGreenCompositeOp,
CopyMagentaCompositeOp,
CopyOpacityCompositeOp,
CopyRedCompositeOp,
CopyYellowCompositeOp,
DarkenCompositeOp,
DstAtopCompositeOp,
DstCompositeOp,
DstInCompositeOp,
DstOutCompositeOp,
DstOverCompositeOp,
DifferenceCompositeOp,
DisplaceCompositeOp,
DissolveCompositeOp,
ExclusionCompositeOp,
HardLightCompositeOp,
HueCompositeOp,
InCompositeOp,
LightenCompositeOp,
LinearLightCompositeOp,
LuminizeCompositeOp,
MinusDstCompositeOp,
ModulateCompositeOp,
MultiplyCompositeOp,
OutCompositeOp,
OverCompositeOp,
OverlayCompositeOp,
PlusCompositeOp,
ReplaceCompositeOp,
SaturateCompositeOp,
ScreenCompositeOp,
SoftLightCompositeOp,
SrcAtopCompositeOp,
SrcCompositeOp,
SrcInCompositeOp,
SrcOutCompositeOp,
SrcOverCompositeOp,
ModulusSubtractCompositeOp,
ThresholdCompositeOp,
XorCompositeOp,
/* These are new operators, added after the above was last sorted.
* The list should be re-sorted only when a new library version is
* created.
*/
DivideDstCompositeOp,
DistortCompositeOp,
BlurCompositeOp,
PegtopLightCompositeOp,
VividLightCompositeOp,
PinLightCompositeOp,
LinearDodgeCompositeOp,
LinearBurnCompositeOp,
MathematicsCompositeOp,
DivideSrcCompositeOp,
MinusSrcCompositeOp,
DarkenIntensityCompositeOp,
LightenIntensityCompositeOp,
HardMixCompositeOp,
StereoCompositeOp
} CompositeOperator;
/* Deprecated (renamed) Method Names for backward compatibility
* However the CompositeOp value has not changed, just renamed.
*/
#define AddCompositeOp ModulusAddCompositeOp
#define SubtractCompositeOp ModulusSubtractCompositeOp
#define MinusCompositeOp MinusDstCompositeOp
#define DivideCompositeOp DivideDstCompositeOp
extern MagickExport MagickBooleanType
CompositeImage(Image *,const CompositeOperator,const Image *,const ssize_t,
const ssize_t),
CompositeImageChannel(Image *,const ChannelType,const CompositeOperator,
const Image *,const ssize_t,const ssize_t),
TextureImage(Image *,const Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/compress.h 0000644 00000004035 15051111170 0007775 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image compression/decompression methods.
*/
#ifndef MAGICKCORE_COMPRESS_H
#define MAGICKCORE_COMPRESS_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedCompression,
NoCompression,
BZipCompression,
DXT1Compression,
DXT3Compression,
DXT5Compression,
FaxCompression,
Group4Compression,
JPEGCompression,
JPEG2000Compression, /* ISO/IEC std 15444-1 */
LosslessJPEGCompression,
LZWCompression,
RLECompression,
ZipCompression,
ZipSCompression,
PizCompression,
Pxr24Compression,
B44Compression,
B44ACompression,
LZMACompression, /* Lempel-Ziv-Markov chain algorithm */
JBIG1Compression, /* ISO/IEC std 11544 / ITU-T rec T.82 */
JBIG2Compression, /* ISO/IEC std 14492 / ITU-T rec T.88 */
ZstdCompression,
WebPCompression
} CompressionType;
typedef struct _Ascii85Info
Ascii85Info;
extern MagickExport MagickBooleanType
HuffmanDecodeImage(Image *),
HuffmanEncodeImage(const ImageInfo *,Image *,Image *),
LZWEncodeImage(Image *,const size_t,unsigned char *magick_restrict),
PackbitsEncodeImage(Image *,const size_t,unsigned char *magick_restrict),
ZLIBEncodeImage(Image *,const size_t,unsigned char *magick_restrict);
extern MagickExport void
Ascii85Encode(Image *,const unsigned char),
Ascii85Flush(Image *),
Ascii85Initialize(Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/property.h 0000644 00000003130 15051111170 0010021 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore property methods.
*/
#ifndef MAGICKCORE_PROPERTY_H
#define MAGICKCORE_PROPERTY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport char
*GetNextImageProperty(const Image *),
*InterpretImageProperties(const ImageInfo *,Image *,const char *),
*RemoveImageProperty(Image *,const char *);
extern MagickExport const char
*GetImageProperty(const Image *,const char *),
*GetMagickProperty(const ImageInfo *,Image *,const char *);
extern MagickExport MagickBooleanType
CloneImageProperties(Image *,const Image *),
DefineImageProperty(Image *,const char *),
DeleteImageProperty(Image *,const char *),
FormatImageProperty(Image *,const char *,const char *,...)
magick_attribute((__format__ (__printf__,3,4))),
SetImageProperty(Image *,const char *,const char *);
extern MagickExport void
DestroyImageProperties(Image *),
ResetImagePropertyIterator(const Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/colorspace.h 0000644 00000004633 15051111170 0010300 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image colorspace methods.
*/
#ifndef MAGICKCORE_COLORSPACE_H
#define MAGICKCORE_COLORSPACE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedColorspace,
RGBColorspace, /* Linear RGB colorspace */
GRAYColorspace, /* greyscale (non-linear) image (faked 1 channel) */
TransparentColorspace,
OHTAColorspace,
LabColorspace,
XYZColorspace,
YCbCrColorspace,
YCCColorspace,
YIQColorspace,
YPbPrColorspace,
YUVColorspace,
CMYKColorspace, /* negated linear RGB with black separated */
sRGBColorspace, /* Default: non-linear sRGB colorspace */
HSBColorspace,
HSLColorspace,
HWBColorspace,
Rec601LumaColorspace,
Rec601YCbCrColorspace,
Rec709LumaColorspace,
Rec709YCbCrColorspace,
LogColorspace,
CMYColorspace, /* negated linear RGB colorspace */
LuvColorspace,
HCLColorspace,
LCHColorspace, /* alias for LCHuv */
LMSColorspace,
LCHabColorspace, /* Cylindrical (Polar) Lab */
LCHuvColorspace, /* Cylindrical (Polar) Luv */
scRGBColorspace,
HSIColorspace,
HSVColorspace, /* alias for HSB */
HCLpColorspace,
YDbDrColorspace,
xyYColorspace,
LinearGRAYColorspace /* greyscale (linear) image (faked 1 channel) */
} ColorspaceType;
extern MagickExport ColorspaceType
GetImageColorspaceType(const Image *,ExceptionInfo *);
extern MagickExport MagickBooleanType
RGBTransformImage(Image *,const ColorspaceType),
SetImageColorspace(Image *,const ColorspaceType),
SetImageGray(Image *,ExceptionInfo *),
SetImageMonochrome(Image *,ExceptionInfo *),
TransformImageColorspace(Image *,const ColorspaceType),
TransformRGBImage(Image *,const ColorspaceType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/opencl.h 0000644 00000004725 15051111170 0007430 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore OpenCL public methods.
*/
#ifndef MAGICKCORE_OPENCL_H
#define MAGICKCORE_OPENCL_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/* OpenCL program modules */
typedef enum {
MAGICK_OPENCL_ACCELERATE = 0,
MAGICK_OPENCL_NUM_PROGRAMS /* !!! This has to be the last entry !!! */
} MagickOpenCLProgram;
typedef enum {
MAGICK_OPENCL_OFF = 0
, MAGICK_OPENCL_DEVICE_SELECT_AUTO = 1
, MAGICK_OPENCL_DEVICE_SELECT_USER = 2
, MAGICK_OPENCL_DEVICE_SELECT_AUTO_CLEAR_CACHE = 3
} ImageMagickOpenCLMode;
/* Parameter type accepted by SetMagickOpenCLEnvParm and GetMagickOpenCLEnvParm */
typedef enum {
MAGICK_OPENCL_ENV_PARAM_DEVICE /* cl_device_id (from OpenCL) */
, MAGICK_OPENCL_ENV_PARAM_OPENCL_DISABLED /* MagickBooleanType */
, MAGICK_OPENCL_ENV_PARAM_OPENCL_INITIALIZED /* MagickBooleanType */
, MAGICK_OPENCL_ENV_PARAM_PROGRAM_CACHE_DISABLED /* MagickBooleanType */
/* if true, disable the kernel binary cache */
, MAGICK_OPENCL_ENV_PARAM_REGENERATE_PROFILE /* MagickBooleanType */
/* if true, rerun microbenchmark in auto device selection */
, MAGICK_OPENCL_ENV_PARAM_PLATFORM_VENDOR /* char* */
, MAGICK_OPENCL_ENV_PARAM_DEVICE_NAME /* char* */
} MagickOpenCLEnvParam;
typedef struct _MagickCLEnv* MagickCLEnv;
extern MagickExport MagickBooleanType
GetMagickOpenCLEnvParam(MagickCLEnv,MagickOpenCLEnvParam,size_t,void*,
ExceptionInfo*),
InitImageMagickOpenCL(ImageMagickOpenCLMode,void*,void*,ExceptionInfo*),
InitOpenCLEnv(MagickCLEnv,ExceptionInfo*),
SetMagickOpenCLEnvParam(MagickCLEnv,MagickOpenCLEnvParam,size_t,void*,
ExceptionInfo*);
extern MagickExport MagickCLEnv
GetDefaultOpenCLEnv();
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/exception.h 0000644 00000010761 15051111170 0010143 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore exception methods.
*/
#ifndef MAGICKCORE_EXCEPTION_H
#define MAGICKCORE_EXCEPTION_H
#include <stdarg.h>
#include "magick/semaphore.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedException,
WarningException = 300,
ResourceLimitWarning = 300,
TypeWarning = 305,
OptionWarning = 310,
DelegateWarning = 315,
MissingDelegateWarning = 320,
CorruptImageWarning = 325,
FileOpenWarning = 330,
BlobWarning = 335,
StreamWarning = 340,
CacheWarning = 345,
CoderWarning = 350,
FilterWarning = 352,
ModuleWarning = 355,
DrawWarning = 360,
ImageWarning = 365,
WandWarning = 370,
RandomWarning = 375,
XServerWarning = 380,
MonitorWarning = 385,
RegistryWarning = 390,
ConfigureWarning = 395,
PolicyWarning = 399,
ErrorException = 400,
ResourceLimitError = 400,
TypeError = 405,
OptionError = 410,
DelegateError = 415,
MissingDelegateError = 420,
CorruptImageError = 425,
FileOpenError = 430,
BlobError = 435,
StreamError = 440,
CacheError = 445,
CoderError = 450,
FilterError = 452,
ModuleError = 455,
DrawError = 460,
ImageError = 465,
WandError = 470,
RandomError = 475,
XServerError = 480,
MonitorError = 485,
RegistryError = 490,
ConfigureError = 495,
PolicyError = 499,
FatalErrorException = 700,
ResourceLimitFatalError = 700,
TypeFatalError = 705,
OptionFatalError = 710,
DelegateFatalError = 715,
MissingDelegateFatalError = 720,
CorruptImageFatalError = 725,
FileOpenFatalError = 730,
BlobFatalError = 735,
StreamFatalError = 740,
CacheFatalError = 745,
CoderFatalError = 750,
FilterFatalError = 752,
ModuleFatalError = 755,
DrawFatalError = 760,
ImageFatalError = 765,
WandFatalError = 770,
RandomFatalError = 775,
XServerFatalError = 780,
MonitorFatalError = 785,
RegistryFatalError = 790,
ConfigureFatalError = 795,
PolicyFatalError = 799
} ExceptionType;
struct _ExceptionInfo
{
ExceptionType
severity;
int
error_number;
char
*reason,
*description;
void
*exceptions;
MagickBooleanType
relinquish;
SemaphoreInfo
*semaphore;
size_t
signature;
};
typedef void
(*ErrorHandler)(const ExceptionType,const char *,const char *);
typedef void
(*FatalErrorHandler)(const ExceptionType,const char *,const char *)
magick_attribute((__noreturn__));
typedef void
(*WarningHandler)(const ExceptionType,const char *,const char *);
extern MagickExport char
*GetExceptionMessage(const int);
extern MagickExport const char
*GetLocaleExceptionMessage(const ExceptionType,const char *);
extern MagickExport ErrorHandler
SetErrorHandler(ErrorHandler);
extern MagickExport ExceptionInfo
*AcquireExceptionInfo(void),
*CloneExceptionInfo(ExceptionInfo *),
*DestroyExceptionInfo(ExceptionInfo *);
extern MagickExport FatalErrorHandler
SetFatalErrorHandler(FatalErrorHandler);
extern MagickExport MagickBooleanType
ThrowException(ExceptionInfo *,const ExceptionType,const char *,
const char *),
ThrowMagickException(ExceptionInfo *,const char *,const char *,const size_t,
const ExceptionType,const char *,const char *,...)
magick_attribute((__format__ (__printf__,7,8))),
ThrowMagickExceptionList(ExceptionInfo *,const char *,const char *,
const size_t,const ExceptionType,const char *,const char *,va_list)
magick_attribute((__format__ (__printf__,7,0)));
extern MagickExport void
CatchException(ExceptionInfo *),
ClearMagickException(ExceptionInfo *),
InheritException(ExceptionInfo *,const ExceptionInfo *),
MagickError(const ExceptionType,const char *,const char *),
MagickFatalError(const ExceptionType,const char *,const char *)
magick_attribute((__noreturn__)),
MagickWarning(const ExceptionType,const char *,const char *);
extern MagickExport WarningHandler
SetWarningHandler(WarningHandler);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/api.h 0000644 00000001703 15051111170 0006712 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Deprecated as of ImageMagick 6.2.3.
MagickCore Application Programming Interface declarations.
*/
#ifndef MAGICKCORE_API_DEPRECATED_H
#define MAGICKCORE_API_DEPRECATED_H
#include "magick/MagickCore.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/effect.h 0000644 00000010251 15051111170 0007373 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image effects methods.
*/
#ifndef MAGICKCORE_EFFECT_H
#define MAGICKCORE_EFFECT_H
#include "magick/morphology.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedPreview,
RotatePreview,
ShearPreview,
RollPreview,
HuePreview,
SaturationPreview,
BrightnessPreview,
GammaPreview,
SpiffPreview,
DullPreview,
GrayscalePreview,
QuantizePreview,
DespecklePreview,
ReduceNoisePreview,
AddNoisePreview,
SharpenPreview,
BlurPreview,
ThresholdPreview,
EdgeDetectPreview,
SpreadPreview,
SolarizePreview,
ShadePreview,
RaisePreview,
SegmentPreview,
SwirlPreview,
ImplodePreview,
WavePreview,
OilPaintPreview,
CharcoalDrawingPreview,
JPEGPreview
} PreviewType;
extern MagickExport Image
*AdaptiveBlurImage(const Image *,const double,const double,ExceptionInfo *),
*AdaptiveBlurImageChannel(const Image *,const ChannelType,const double,
const double,ExceptionInfo *),
*AdaptiveSharpenImage(const Image *,const double,const double,
ExceptionInfo *),
*AdaptiveSharpenImageChannel(const Image *,const ChannelType,const double,
const double,ExceptionInfo *),
*BlurImage(const Image *,const double,const double,ExceptionInfo *),
*BlurImageChannel(const Image *,const ChannelType,const double,const double,
ExceptionInfo *),
*ConvolveImage(const Image *,const size_t,const double *,ExceptionInfo *),
*ConvolveImageChannel(const Image *,const ChannelType,const size_t,
const double *,ExceptionInfo *),
*DespeckleImage(const Image *,ExceptionInfo *),
*EdgeImage(const Image *,const double,ExceptionInfo *),
*EmbossImage(const Image *,const double,const double,ExceptionInfo *),
*FilterImage(const Image *,const KernelInfo *,ExceptionInfo *),
*FilterImageChannel(const Image *,const ChannelType,const KernelInfo *,
ExceptionInfo *),
*GaussianBlurImage(const Image *,const double,const double,ExceptionInfo *),
*GaussianBlurImageChannel(const Image *,const ChannelType,const double,
const double,ExceptionInfo *),
*KuwaharaImage(const Image *,const double,const double,ExceptionInfo *),
*KuwaharaImageChannel(const Image *,const ChannelType,const double,
const double,ExceptionInfo *),
*LocalContrastImage(const Image *,const double,const double,ExceptionInfo *),
*MotionBlurImage(const Image *,const double,const double,const double,
ExceptionInfo *),
*MotionBlurImageChannel(const Image *,const ChannelType,const double,
const double,const double,ExceptionInfo *),
*PreviewImage(const Image *,const PreviewType,ExceptionInfo *),
*RotationalBlurImage(const Image *,const double,ExceptionInfo *),
*RotationalBlurImageChannel(const Image *,const ChannelType,const double,
ExceptionInfo *),
*SelectiveBlurImage(const Image *,const double,const double,const double,
ExceptionInfo *),
*SelectiveBlurImageChannel(const Image *,const ChannelType,const double,
const double,const double,ExceptionInfo *),
*ShadeImage(const Image *,const MagickBooleanType,const double,const double,
ExceptionInfo *),
*SharpenImage(const Image *,const double,const double,ExceptionInfo *),
*SharpenImageChannel(const Image *,const ChannelType,const double,
const double,ExceptionInfo *),
*SpreadImage(const Image *,const double,ExceptionInfo *),
*UnsharpMaskImage(const Image *,const double,const double,const double,
const double,ExceptionInfo *),
*UnsharpMaskImageChannel(const Image *,const ChannelType,const double,
const double,const double,const double,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/annotate.h 0000644 00000002431 15051111170 0007751 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image annotation methods.
*/
#ifndef MAGICKCORE_ANNOTATE_H
#define MAGICKCORE_ANNOTATE_H
#include "magick/draw.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
AnnotateComponentGenesis(void),
AnnotateImage(Image *,const DrawInfo *),
GetMultilineTypeMetrics(Image *,const DrawInfo *,TypeMetric *),
GetTypeMetrics(Image *,const DrawInfo *,TypeMetric *);
extern MagickExport ssize_t
FormatMagickCaption(Image *,DrawInfo *,const MagickBooleanType,TypeMetric *,
char **);
extern MagickExport void
AnnotateComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/segment.h 0000644 00000002116 15051111170 0007602 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image segment methods.
*/
#ifndef MAGICKCORE_SEGMENT_H
#define MAGICKCORE_SEGMENT_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
GetImageDynamicThreshold(const Image *,const double,const double,
MagickPixelPacket *,ExceptionInfo *),
SegmentImage(Image *,const ColorspaceType,const MagickBooleanType,
const double,const double);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/histogram.h 0000644 00000002743 15051111170 0010143 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore histogram methods.
*/
#ifndef MAGICKCORE_HISTOGRAM_H
#define MAGICKCORE_HISTOGRAM_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _ColorPacket
{
PixelPacket
pixel;
IndexPacket
index;
MagickSizeType
count;
} ColorPacket;
extern MagickExport ColorPacket
*GetImageHistogram(const Image *,size_t *,ExceptionInfo *);
extern MagickExport Image
*UniqueImageColors(const Image *,ExceptionInfo *);
extern MagickExport MagickBooleanType
IdentifyPaletteImage(const Image *,ExceptionInfo *),
IsHistogramImage(const Image *,ExceptionInfo *),
IsPaletteImage(const Image *,ExceptionInfo *),
MinMaxStretchImage(Image *,const ChannelType,const double,const double);
extern MagickExport size_t
GetNumberColors(const Image *,FILE *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/quantize.h 0000644 00000003704 15051111170 0010004 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image quantization methods.
*/
#ifndef MAGICKCORE_QUANTIZE_H
#define MAGICKCORE_QUANTIZE_H
#include "magick/colorspace.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedDitherMethod,
NoDitherMethod,
RiemersmaDitherMethod,
FloydSteinbergDitherMethod
} DitherMethod;
typedef struct _QuantizeInfo
{
size_t
number_colors;
size_t
tree_depth;
MagickBooleanType
dither;
ColorspaceType
colorspace;
MagickBooleanType
measure_error;
size_t
signature;
DitherMethod
dither_method;
} QuantizeInfo;
extern MagickExport MagickBooleanType
CompressImageColormap(Image *),
GetImageQuantizeError(Image *),
PosterizeImage(Image *,const size_t,const MagickBooleanType),
PosterizeImageChannel(Image *,const ChannelType,const size_t,
const MagickBooleanType),
QuantizeImage(const QuantizeInfo *,Image *),
QuantizeImages(const QuantizeInfo *,Image *),
RemapImage(const QuantizeInfo *,Image *,const Image *),
RemapImages(const QuantizeInfo *,Image *,const Image *);
extern MagickExport QuantizeInfo
*AcquireQuantizeInfo(const ImageInfo *),
*CloneQuantizeInfo(const QuantizeInfo *),
*DestroyQuantizeInfo(QuantizeInfo *);
extern MagickExport void
GetQuantizeInfo(QuantizeInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/ImageMagick.h 0000644 00000001723 15051111170 0010301 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Deprecated as of ImageMagick 6.2.3.
MagickCore Application Programming Interface declarations.
*/
#ifndef MAGICKCORE_IMAGEMAGICK_DEPRECATED_H
#define MAGICKCORE_IMAGEMAGICK_DEPRECATED_H
#include "magick/MagickCore.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/distort.h 0000644 00000005227 15051111170 0007636 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image distortion methods.
*/
#ifndef MAGICKCORE_DISTORT_H
#define MAGICKCORE_DISTORT_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/*
These two enum are linked, with common enumerated values. Both
DistortImages() and SparseColor() often share code to determine functional
coefficients for common methods.
Caution should be taken to ensure that only the common methods contain the
same enumerated value, while all others remain unique across both
enumerations.
*/
typedef enum
{
UndefinedDistortion,
AffineDistortion,
AffineProjectionDistortion,
ScaleRotateTranslateDistortion,
PerspectiveDistortion,
PerspectiveProjectionDistortion,
BilinearForwardDistortion,
BilinearDistortion = BilinearForwardDistortion,
BilinearReverseDistortion,
PolynomialDistortion,
ArcDistortion,
PolarDistortion,
DePolarDistortion,
Cylinder2PlaneDistortion,
Plane2CylinderDistortion,
BarrelDistortion,
BarrelInverseDistortion,
ShepardsDistortion,
ResizeDistortion,
SentinelDistortion
} DistortImageMethod;
typedef enum
{
UndefinedColorInterpolate = UndefinedDistortion,
BarycentricColorInterpolate = AffineDistortion,
BilinearColorInterpolate = BilinearReverseDistortion,
PolynomialColorInterpolate = PolynomialDistortion,
ShepardsColorInterpolate = ShepardsDistortion,
/*
Methods unique to SparseColor().
*/
VoronoiColorInterpolate = SentinelDistortion,
InverseColorInterpolate,
ManhattanColorInterpolate
} SparseColorMethod;
extern MagickExport Image
*AffineTransformImage(const Image *,const AffineMatrix *,ExceptionInfo *),
*DistortImage(const Image *,const DistortImageMethod,const size_t,
const double *,MagickBooleanType,ExceptionInfo *exception),
*DistortResizeImage(const Image *,const size_t,const size_t,ExceptionInfo *),
*RotateImage(const Image *,const double,ExceptionInfo *),
*SparseColorImage(const Image *,const ChannelType,const SparseColorMethod,
const size_t,const double *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/resize.h 0000644 00000003352 15051111170 0007444 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image resize methods.
*/
#ifndef MAGICKCORE_RESIZE_H
#define MAGICKCORE_RESIZE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _ResizeFilter
ResizeFilter;
extern MagickExport Image
*AdaptiveResizeImage(const Image *,const size_t,const size_t,ExceptionInfo *),
*InterpolativeResizeImage(const Image *,const size_t,const size_t,
const InterpolatePixelMethod,ExceptionInfo *),
*LiquidRescaleImage(const Image *,const size_t,const size_t,const double,
const double,ExceptionInfo *),
*MagnifyImage(const Image *,ExceptionInfo *),
*MinifyImage(const Image *,ExceptionInfo *),
*ResampleImage(const Image *,const double,const double,const FilterTypes,
const double,ExceptionInfo *),
*ResizeImage(const Image *,const size_t,const size_t,const FilterTypes,
const double,ExceptionInfo *),
*SampleImage(const Image *,const size_t,const size_t,ExceptionInfo *),
*ScaleImage(const Image *,const size_t,const size_t,ExceptionInfo *),
*ThumbnailImage(const Image *,const size_t,const size_t,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/locale_.h 0000644 00000005161 15051111170 0007541 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore locale methods.
*/
#ifndef MAGICKCORE_LOCALE_H
#define MAGICKCORE_LOCALE_H
#include "magick/hashmap.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _LocaleInfo
{
char
*path,
*tag,
*message;
MagickBooleanType
stealth;
struct _LocaleInfo
*previous,
*next; /* deprecated, use GetLocaleInfoList() */
size_t
signature;
} LocaleInfo;
extern MagickExport char
**GetLocaleList(const char *,size_t *,ExceptionInfo *);
extern MagickExport const char
*GetLocaleMessage(const char *);
extern MagickExport const LocaleInfo
*GetLocaleInfo_(const char *,ExceptionInfo *),
**GetLocaleInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport double
InterpretLocaleValue(const char *magick_restrict,char **magick_restrict);
extern MagickExport int
LocaleCompare(const char *,const char *) magick_attribute((__pure__)),
LocaleLowercase(const int),
LocaleNCompare(const char *,const char *,const size_t)
magick_attribute((__pure__)),
LocaleUppercase(const int);
extern MagickExport LinkedListInfo
*DestroyLocaleOptions(LinkedListInfo *),
*GetLocaleOptions(const char *,ExceptionInfo *);
extern MagickExport MagickBooleanType
ListLocaleInfo(FILE *,ExceptionInfo *),
LocaleComponentGenesis(void);
extern MagickExport ssize_t
FormatLocaleFile(FILE *,const char *magick_restrict,...)
magick_attribute((__format__ (__printf__,2,3))),
FormatLocaleFileList(FILE *,const char *magick_restrict,va_list)
magick_attribute((__format__ (__printf__,2,0))),
FormatLocaleString(char *magick_restrict,const size_t,
const char *magick_restrict,...)
magick_attribute((__format__ (__printf__,3,4))),
FormatLocaleStringList(char *magick_restrict,const size_t,
const char *magick_restrict,
va_list) magick_attribute((__format__ (__printf__,3,0)));
extern MagickExport void
LocaleComponentTerminus(void),
LocaleLower(char *),
LocaleUpper(char *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/xwindow.h 0000644 00000002130 15051111170 0007633 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore X11 window methods.
*/
#ifndef MAGICKCORE_XWINDOW_H
#define MAGICKCORE_XWINDOW_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _XImportInfo
{
MagickBooleanType
frame,
borders,
screen,
descend,
silent;
} XImportInfo;
extern MagickExport Image
*XImportImage(const ImageInfo *,XImportInfo *);
extern MagickExport void
XGetImportInfo(XImportInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/color.h 0000644 00000005715 15051111170 0007266 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image color methods.
*/
#ifndef MAGICKCORE_COLOR_H
#define MAGICKCORE_COLOR_H
#include "magick/pixel.h"
#include "magick/exception.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedCompliance,
NoCompliance = 0x0000,
CSSCompliance = 0x0001,
SVGCompliance = 0x0001,
X11Compliance = 0x0002,
XPMCompliance = 0x0004,
MVGCompliance = 0x0008,
AllCompliance = 0x7fffffff
} ComplianceType;
typedef struct _ColorInfo
{
char
*path,
*name;
ComplianceType
compliance;
MagickPixelPacket
color;
MagickBooleanType
exempt,
stealth;
struct _ColorInfo
*previous,
*next; /* deprecated, use GetColorInfoList() */
size_t
signature;
} ColorInfo;
typedef struct _ErrorInfo
{
double
mean_error_per_pixel,
normalized_mean_error,
normalized_maximum_error;
} ErrorInfo;
extern MagickExport char
**GetColorList(const char *,size_t *,ExceptionInfo *);
extern MagickExport const ColorInfo
*GetColorInfo(const char *,ExceptionInfo *),
**GetColorInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport MagickBooleanType
ColorComponentGenesis(void),
IsColorSimilar(const Image *,const PixelPacket *,const PixelPacket *),
IsImageSimilar(const Image *,const Image *,ssize_t *x,ssize_t *y,
ExceptionInfo *),
IsMagickColorSimilar(const MagickPixelPacket *,const MagickPixelPacket *),
IsOpacitySimilar(const Image *,const PixelPacket *,const PixelPacket *),
ListColorInfo(FILE *,ExceptionInfo *),
QueryColorCompliance(const char *,const ComplianceType,PixelPacket *,
ExceptionInfo *),
QueryColorDatabase(const char *,PixelPacket *,ExceptionInfo *),
QueryColorname(const Image *,const PixelPacket *,const ComplianceType,char *,
ExceptionInfo *),
QueryMagickColorCompliance(const char *,const ComplianceType,
MagickPixelPacket *,ExceptionInfo *),
QueryMagickColor(const char *,MagickPixelPacket *,ExceptionInfo *),
QueryMagickColorname(const Image *,const MagickPixelPacket *,
const ComplianceType,char *,ExceptionInfo *);
extern MagickExport void
ColorComponentTerminus(void),
ConcatenateColorComponent(const MagickPixelPacket *,const ChannelType,
const ComplianceType,char *),
GetColorTuple(const MagickPixelPacket *,const MagickBooleanType,char *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/image-view.h 0000644 00000005301 15051111170 0010171 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image view methods.
*/
#ifndef MAGICKCORE_IMAGE_VIEW_H
#define MAGICKCORE_IMAGE_VIEW_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _ImageView
ImageView;
typedef MagickBooleanType
(*DuplexTransferImageViewMethod)(const ImageView *,const ImageView *,
ImageView *,const ssize_t,const int,void *),
(*GetImageViewMethod)(const ImageView *,const ssize_t,const int,void *),
(*SetImageViewMethod)(ImageView *,const ssize_t,const int,void *),
(*TransferImageViewMethod)(const ImageView *,ImageView *,const ssize_t,
const int,void *),
(*UpdateImageViewMethod)(ImageView *,const ssize_t,const int,void *);
extern MagickExport char
*GetImageViewException(const ImageView *,ExceptionType *);
extern MagickExport const IndexPacket
*GetImageViewVirtualIndexes(const ImageView *);
extern MagickExport const PixelPacket
*GetImageViewVirtualPixels(const ImageView *);
extern MagickExport Image
*GetImageViewImage(const ImageView *);
extern MagickExport ImageView
*CloneImageView(const ImageView *),
*DestroyImageView(ImageView *),
*NewImageView(Image *),
*NewImageViewRegion(Image *,const ssize_t,const ssize_t,const size_t,
const size_t);
extern MagickExport IndexPacket
*GetImageViewAuthenticIndexes(const ImageView *);
extern MagickExport MagickBooleanType
DuplexTransferImageViewIterator(ImageView *,ImageView *,ImageView *,
DuplexTransferImageViewMethod,void *),
GetImageViewIterator(ImageView *,GetImageViewMethod,void *),
IsImageView(const ImageView *),
SetImageViewIterator(ImageView *,SetImageViewMethod,void *),
TransferImageViewIterator(ImageView *,ImageView *,TransferImageViewMethod,
void *),
UpdateImageViewIterator(ImageView *,UpdateImageViewMethod,void *);
extern MagickExport PixelPacket
*GetImageViewAuthenticPixels(const ImageView *);
extern MagickExport RectangleInfo
GetImageViewExtent(const ImageView *);
extern MagickExport void
SetImageViewDescription(ImageView *,const char *),
SetImageViewThreads(ImageView *,const size_t);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/option.h 0000644 00000012446 15051111170 0007457 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore option methods.
*/
#ifndef MAGICKCORE_OPTION_H
#define MAGICKCORE_OPTION_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
MagickUndefinedOptions = -1,
MagickAlignOptions = 0,
MagickAlphaOptions,
MagickBooleanOptions,
MagickCacheOptions,
MagickChannelOptions,
MagickClassOptions,
MagickClipPathOptions,
MagickCoderOptions,
MagickColorOptions,
MagickColorspaceOptions,
MagickCommandOptions,
MagickComposeOptions,
MagickCompressOptions,
MagickConfigureOptions,
MagickDataTypeOptions,
MagickDebugOptions,
MagickDecorateOptions,
MagickDelegateOptions,
MagickDirectionOptions,
MagickDisposeOptions,
MagickDistortOptions,
MagickDitherOptions,
MagickEndianOptions,
MagickEvaluateOptions,
MagickFillRuleOptions,
MagickFilterOptions,
MagickFontOptions,
MagickFontsOptions,
MagickFormatOptions,
MagickFunctionOptions,
MagickGravityOptions,
MagickIntentOptions,
MagickInterlaceOptions,
MagickInterpolateOptions,
MagickKernelOptions,
MagickLayerOptions,
MagickLineCapOptions,
MagickLineJoinOptions,
MagickListOptions,
MagickLocaleOptions,
MagickLogEventOptions,
MagickLogOptions,
MagickMagicOptions,
MagickMethodOptions,
MagickMetricOptions,
MagickMimeOptions,
MagickModeOptions,
MagickModuleOptions,
MagickMorphologyOptions,
MagickNoiseOptions,
MagickOrientationOptions,
MagickPixelIntensityOptions,
MagickPolicyOptions,
MagickPolicyDomainOptions,
MagickPolicyRightsOptions,
MagickPreviewOptions,
MagickPrimitiveOptions,
MagickQuantumFormatOptions,
MagickResolutionOptions,
MagickResourceOptions,
MagickSparseColorOptions,
MagickStatisticOptions,
MagickStorageOptions,
MagickStretchOptions,
MagickStyleOptions,
MagickThresholdOptions,
MagickTypeOptions,
MagickValidateOptions,
MagickVirtualPixelOptions,
MagickComplexOptions,
MagickIntensityOptions,
MagickGradientOptions,
MagickWeightOptions,
MagickComplianceOptions,
MagickAutoThresholdOptions,
MagickPagesizeOptions
} CommandOption;
typedef enum
{
UndefinedValidate,
NoValidate = 0x00000,
ColorspaceValidate = 0x00001,
CompareValidate = 0x00002,
CompositeValidate = 0x00004,
ConvertValidate = 0x00008,
FormatsDiskValidate = 0x00010,
FormatsMapValidate = 0x00020,
FormatsMemoryValidate = 0x00040,
IdentifyValidate = 0x00080,
ImportExportValidate = 0x00100,
MontageValidate = 0x00200,
StreamValidate = 0x00400,
AllValidate = 0x7fffffff
} ValidateType;
typedef struct _OptionInfo
{
const char
*mnemonic;
ssize_t
type,
flags;
MagickBooleanType
stealth;
} OptionInfo;
/*
Flags to describe classes of image processing options.
*/
typedef enum
{
UndefinedOptionFlag = 0x0000,
FireOptionFlag = 0x0001, /* Option sequence firing point */
ImageInfoOptionFlag = 0x0002, /* Sets ImageInfo, no image needed */
DrawInfoOptionFlag = 0x0004, /* Sets DrawInfo, no image needed */
QuantizeInfoOptionFlag = 0x0008, /* Sets QuantizeInfo, no image needed */
GlobalOptionFlag = 0x0010, /* Sets Global Option, no image needed */
SimpleOperatorOptionFlag = 0x0100, /* Simple Image processing operator */
ListOperatorOptionFlag = 0x0200, /* Multi-Image List processing operator */
SpecialOperatorOptionFlag = 0x0400, /* Specially handled Operator Option */
GenesisOptionFlag = 0x0400, /* Genesis Command Wrapper Option */
NonConvertOptionFlag = 0x4000, /* Option not used by Convert */
DeprecateOptionFlag = 0x8000 /* Deprecate option, give warning */
} CommandOptionFlags;
extern MagickExport char
**GetCommandOptions(const CommandOption),
*GetNextImageOption(const ImageInfo *),
*RemoveImageOption(ImageInfo *,const char *);
extern MagickExport const char
*CommandOptionToMnemonic(const CommandOption,const ssize_t),
*GetImageOption(const ImageInfo *,const char *);
extern MagickExport MagickBooleanType
CloneImageOptions(ImageInfo *,const ImageInfo *),
DefineImageOption(ImageInfo *,const char *),
DeleteImageOption(ImageInfo *,const char *),
IsCommandOption(const char *),
IsOptionMember(const char *,const char *),
ListCommandOptions(FILE *,const CommandOption,ExceptionInfo *),
SetImageOption(ImageInfo *,const char *,const char *);
extern MagickExport ssize_t
GetCommandOptionFlags(const CommandOption,const MagickBooleanType,
const char *),
ParseChannelOption(const char *),
ParseCommandOption(const CommandOption,const MagickBooleanType,const char *);
extern MagickExport void
DestroyImageOptions(ImageInfo *),
ResetImageOptions(const ImageInfo *),
ResetImageOptionIterator(const ImageInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/draw.h 0000644 00000013177 15051111170 0007106 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore drawing methods.
*/
#ifndef MAGICKCORE_DRAW_H
#define MAGICKCORE_DRAW_H
#include "magick/geometry.h"
#include "magick/image.h"
#include "magick/pixel.h"
#include "magick/type.h"
#include "magick/color.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedAlign,
LeftAlign,
CenterAlign,
RightAlign
} AlignType;
typedef enum
{
UndefinedPathUnits,
UserSpace,
UserSpaceOnUse,
ObjectBoundingBox
} ClipPathUnits;
typedef enum
{
UndefinedDecoration,
NoDecoration,
UnderlineDecoration,
OverlineDecoration,
LineThroughDecoration
} DecorationType;
typedef enum
{
UndefinedDirection,
RightToLeftDirection,
LeftToRightDirection,
TopToBottomDirection
} DirectionType;
typedef enum
{
UndefinedRule,
#undef EvenOddRule
EvenOddRule,
NonZeroRule
} FillRule;
typedef enum
{
UndefinedGradient,
LinearGradient,
RadialGradient
} GradientType;
typedef enum
{
UndefinedCap,
ButtCap,
RoundCap,
SquareCap
} LineCap;
typedef enum
{
UndefinedJoin,
MiterJoin,
RoundJoin,
BevelJoin
} LineJoin;
typedef enum
{
UndefinedMethod,
PointMethod,
ReplaceMethod,
FloodfillMethod,
FillToBorderMethod,
ResetMethod
} PaintMethod;
typedef enum
{
UndefinedPrimitive,
PointPrimitive,
LinePrimitive,
RectanglePrimitive,
RoundRectanglePrimitive,
ArcPrimitive,
EllipsePrimitive,
CirclePrimitive,
PolylinePrimitive,
PolygonPrimitive,
BezierPrimitive,
ColorPrimitive,
MattePrimitive,
TextPrimitive,
ImagePrimitive,
PathPrimitive
} PrimitiveType;
typedef enum
{
UndefinedReference,
GradientReference
} ReferenceType;
typedef enum
{
UndefinedSpread,
PadSpread,
ReflectSpread,
RepeatSpread
} SpreadMethod;
typedef struct _PointInfo
{
double
x,
y;
} PointInfo;
typedef struct _StopInfo
{
MagickPixelPacket
color;
MagickRealType
offset;
} StopInfo;
typedef struct _GradientInfo
{
GradientType
type;
RectangleInfo
bounding_box;
SegmentInfo
gradient_vector;
StopInfo
*stops;
size_t
number_stops;
SpreadMethod
spread;
MagickBooleanType
debug;
size_t
signature;
PointInfo
center;
MagickRealType
radius,
angle;
PointInfo
radii;
} GradientInfo;
typedef struct _ElementReference
{
char
*id;
ReferenceType
type;
GradientInfo
gradient;
size_t
signature;
struct _ElementReference
*previous,
*next;
} ElementReference;
typedef struct _DrawInfo
{
char
*primitive,
*geometry;
RectangleInfo
viewbox;
AffineMatrix
affine;
GravityType
gravity;
PixelPacket
fill,
stroke;
double
stroke_width;
GradientInfo
gradient;
Image
*fill_pattern,
*tile,
*stroke_pattern;
MagickBooleanType
stroke_antialias,
text_antialias;
FillRule
fill_rule;
LineCap
linecap;
LineJoin
linejoin;
size_t
miterlimit;
double
dash_offset;
DecorationType
decorate;
CompositeOperator
compose;
char
*text;
size_t
face;
char
*font,
*metrics,
*family;
StyleType
style;
StretchType
stretch;
size_t
weight;
char
*encoding;
double
pointsize;
char
*density;
AlignType
align;
PixelPacket
undercolor,
border_color;
char
*server_name;
double
*dash_pattern;
char
*clip_mask;
SegmentInfo
bounds;
ClipPathUnits
clip_units;
Quantum
opacity;
MagickBooleanType
render;
ElementReference
element_reference;
MagickBooleanType
debug;
size_t
signature;
double
kerning,
interword_spacing,
interline_spacing;
DirectionType
direction;
double
fill_opacity,
stroke_opacity;
MagickBooleanType
clip_path;
Image
*clipping_mask;
ComplianceType
compliance;
Image
*composite_mask;
char
*id;
ImageInfo
*image_info;
} DrawInfo;
typedef struct _PrimitiveInfo
{
PointInfo
point;
size_t
coordinates;
PrimitiveType
primitive;
PaintMethod
method;
char
*text;
MagickBooleanType
closed_subpath;
} PrimitiveInfo;
typedef struct _TypeMetric
{
PointInfo
pixels_per_em;
double
ascent,
descent,
width,
height,
max_advance,
underline_position,
underline_thickness;
SegmentInfo
bounds;
PointInfo
origin;
} TypeMetric;
extern MagickExport DrawInfo
*AcquireDrawInfo(void),
*CloneDrawInfo(const ImageInfo *,const DrawInfo *),
*DestroyDrawInfo(DrawInfo *);
extern MagickExport MagickBooleanType
DrawAffineImage(Image *,const Image *,const AffineMatrix *),
DrawClipPath(Image *,const DrawInfo *,const char *),
DrawGradientImage(Image *,const DrawInfo *),
DrawImage(Image *,const DrawInfo *),
DrawPatternPath(Image *,const DrawInfo *,const char *,Image **),
DrawPrimitive(Image *,const DrawInfo *,const PrimitiveInfo *);
extern MagickExport void
GetAffineMatrix(AffineMatrix *),
GetDrawInfo(const ImageInfo *,DrawInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/enhance.h 0000644 00000005662 15051111170 0007552 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image enhance methods.
*/
#ifndef MAGICKCORE_ENHANCE_H
#define MAGICKCORE_ENHANCE_H
#include "magick/pixel.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
AutoGammaImage(Image *),
AutoGammaImageChannel(Image *,const ChannelType),
AutoLevelImage(Image *),
AutoLevelImageChannel(Image *,const ChannelType),
BrightnessContrastImage(Image *,const double,const double),
BrightnessContrastImageChannel(Image *,const ChannelType,const double,
const double),
ClutImage(Image *,const Image *),
ClutImageChannel(Image *,const ChannelType,const Image *),
ColorDecisionListImage(Image *,const char *),
ContrastImage(Image *,const MagickBooleanType),
ContrastStretchImage(Image *,const char *),
ContrastStretchImageChannel(Image *,const ChannelType,const double,
const double),
EqualizeImage(Image *image),
EqualizeImageChannel(Image *image,const ChannelType),
GammaImage(Image *,const char *),
GammaImageChannel(Image *,const ChannelType,const double),
GrayscaleImage(Image *,const PixelIntensityMethod),
HaldClutImage(Image *,const Image *),
HaldClutImageChannel(Image *,const ChannelType,const Image *),
LevelImage(Image *,const char *),
LevelImageChannel(Image *,const ChannelType,const double,const double,
const double),
LevelizeImage(Image *,const double,const double,const double),
LevelizeImageChannel(Image *,const ChannelType,const double,const double,
const double),
LevelColorsImage(Image *,const MagickPixelPacket *,const MagickPixelPacket *,
const MagickBooleanType),
LevelColorsImageChannel(Image *,const ChannelType,const MagickPixelPacket *,
const MagickPixelPacket *,const MagickBooleanType),
LinearStretchImage(Image *,const double,const double),
ModulateImage(Image *,const char *),
NegateImage(Image *,const MagickBooleanType),
NegateImageChannel(Image *,const ChannelType,const MagickBooleanType),
NormalizeImage(Image *),
NormalizeImageChannel(Image *,const ChannelType),
SigmoidalContrastImage(Image *,const MagickBooleanType,const char *),
SigmoidalContrastImageChannel(Image *,const ChannelType,
const MagickBooleanType,const double,const double);
extern MagickExport Image
*EnhanceImage(const Image *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/random_.h 0000644 00000003203 15051111170 0007555 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore random methods.
*/
#ifndef MAGICKCORE_RANDOM__H
#define MAGICKCORE_RANDOM__H
#include "magick/string_.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/*
Typedef declarations.
*/
typedef struct _RandomInfo
RandomInfo;
/*
Method declarations.
*/
extern MagickExport double
GetRandomValue(RandomInfo *),
GetPseudoRandomValue(RandomInfo *magick_restrict);
extern MagickExport MagickBooleanType
RandomComponentGenesis(void);
extern MagickExport RandomInfo
*AcquireRandomInfo(void),
*DestroyRandomInfo(RandomInfo *);
extern MagickExport StringInfo
*GetRandomKey(RandomInfo *,const size_t);
extern MagickExport unsigned long
GetRandomSecretKey(const RandomInfo *);
extern MagickExport void
RandomComponentTerminus(void),
SeedPseudoRandomGenerator(const unsigned long),
SetRandomKey(RandomInfo *,const size_t,unsigned char *),
SetRandomSecretKey(const unsigned long),
SetRandomTrueRandom(const MagickBooleanType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/constitute.h 0000644 00000003036 15051111170 0010343 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image constitute methods.
*/
#ifndef MAGICKCORE_CONSTITUTE_H
#define MAGICKCORE_CONSTITUTE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedPixel,
CharPixel,
DoublePixel,
FloatPixel,
IntegerPixel,
LongPixel,
QuantumPixel,
ShortPixel
} StorageType;
extern MagickExport Image
*ConstituteImage(const size_t,const size_t,const char *,const StorageType,
const void *,ExceptionInfo *),
*PingImage(const ImageInfo *,ExceptionInfo *),
*PingImages(const ImageInfo *,ExceptionInfo *),
*ReadImage(const ImageInfo *,ExceptionInfo *),
*ReadImages(const ImageInfo *,ExceptionInfo *),
*ReadInlineImage(const ImageInfo *,const char *,ExceptionInfo *);
extern MagickExport MagickBooleanType
WriteImage(const ImageInfo *,Image *),
WriteImages(const ImageInfo *,Image *,const char *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/magic.h 0000644 00000003166 15051111170 0007226 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore magic methods.
*/
#ifndef MAGICKCORE_MAGIC_H
#define MAGICKCORE_MAGIC_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _MagicInfo
{
char
*path,
*name,
*target;
unsigned char
*magic;
size_t
length;
MagickOffsetType
offset;
MagickBooleanType
exempt,
stealth;
struct _MagicInfo
*previous,
*next; /* deprecated, use GetMagicInfoList() */
size_t
signature;
} MagicInfo;
extern MagickExport char
**GetMagicList(const char *,size_t *,ExceptionInfo *);
extern MagickExport const char
*GetMagicName(const MagicInfo *);
extern MagickExport MagickBooleanType
ListMagicInfo(FILE *,ExceptionInfo *),
MagicComponentGenesis(void);
extern MagickExport const MagicInfo
*GetMagicInfo(const unsigned char *,const size_t,ExceptionInfo *),
**GetMagicInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport void
MagicComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/animate.h 0000644 00000001676 15051111170 0007570 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore methods to interactively animate an image sequence.
*/
#ifndef MAGICKCORE_ANIMATE_H
#define MAGICKCORE_ANIMATE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
AnimateImages(const ImageInfo *,Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/MagickCore.h 0000644 00000011122 15051111170 0010141 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore Application Programming Interface declarations.
*/
#ifndef MAGICKCORE_CORE_H
#define MAGICKCORE_CORE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if !defined(MAGICKCORE_CONFIG_H)
# define MAGICKCORE_CONFIG_H
# if !defined(vms) && !defined(macintosh)
# include "magick/magick-config.h"
# else
# include "magick-config.h"
# endif
#if defined(_magickcore_const) && !defined(const)
# define const _magickcore_const
#endif
#if defined(_magickcore_inline) && !defined(inline)
# define inline _magickcore_inline
#endif
#if !defined(magick_restrict)
# if !defined(_magickcore_restrict)
# define magick_restrict restrict
# else
# define magick_restrict _magickcore_restrict
# endif
#endif
# if defined(__cplusplus) || defined(c_plusplus)
# undef inline
# endif
#endif
#define MAGICKCORE_CHECK_VERSION(major,minor,micro) \
((MAGICKCORE_MAJOR_VERSION > (major)) || \
((MAGICKCORE_MAJOR_VERSION == (major)) && \
(MAGICKCORE_MINOR_VERSION > (minor))) || \
((MAGICKCORE_MAJOR_VERSION == (major)) && \
(MAGICKCORE_MINOR_VERSION == (minor)) && \
(MAGICKCORE_MICRO_VERSION >= (micro))))
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
#include <sys/types.h>
#include <time.h>
#if defined(WIN32) || defined(WIN64)
# define MAGICKCORE_WINDOWS_SUPPORT
#else
# define MAGICKCORE_POSIX_SUPPORT
#endif
#include "magick/method-attribute.h"
#if defined(MAGICKCORE_NAMESPACE_PREFIX)
# include "magick/methods.h"
#endif
#include "magick/magick-type.h"
#include "magick/animate.h"
#include "magick/annotate.h"
#include "magick/artifact.h"
#include "magick/attribute.h"
#include "magick/blob.h"
#include "magick/cache.h"
#include "magick/cache-view.h"
#include "magick/channel.h"
#include "magick/cipher.h"
#include "magick/client.h"
#include "magick/coder.h"
#include "magick/color.h"
#include "magick/colorspace.h"
#include "magick/colormap.h"
#include "magick/compare.h"
#include "magick/composite.h"
#include "magick/compress.h"
#include "magick/configure.h"
#include "magick/constitute.h"
#include "magick/decorate.h"
#include "magick/delegate.h"
#include "magick/deprecate.h"
#include "magick/display.h"
#include "magick/distort.h"
#include "magick/distribute-cache.h"
#include "magick/draw.h"
#include "magick/effect.h"
#include "magick/enhance.h"
#include "magick/exception.h"
#include "magick/feature.h"
#include "magick/fourier.h"
#include "magick/fx.h"
#include "magick/gem.h"
#include "magick/geometry.h"
#include "magick/hashmap.h"
#include "magick/histogram.h"
#include "magick/identify.h"
#include "magick/image.h"
#include "magick/image-view.h"
#include "magick/layer.h"
#include "magick/list.h"
#include "magick/locale_.h"
#include "magick/log.h"
#include "magick/magic.h"
#include "magick/magick.h"
#include "magick/matrix.h"
#include "magick/memory_.h"
#include "magick/module.h"
#include "magick/mime.h"
#include "magick/monitor.h"
#include "magick/montage.h"
#include "magick/morphology.h"
#include "magick/opencl.h"
#include "magick/option.h"
#include "magick/paint.h"
#include "magick/pixel.h"
#include "magick/pixel-accessor.h"
#include "magick/policy.h"
#include "magick/prepress.h"
#include "magick/profile.h"
#include "magick/property.h"
#include "magick/quantize.h"
#include "magick/quantum.h"
#include "magick/registry.h"
#include "magick/random_.h"
#include "magick/resample.h"
#include "magick/resize.h"
#include "magick/resource_.h"
#include "magick/segment.h"
#include "magick/shear.h"
#include "magick/signature.h"
#include "magick/splay-tree.h"
#include "magick/static.h"
#include "magick/stream.h"
#include "magick/statistic.h"
#include "magick/string_.h"
#include "magick/timer.h"
#include "magick/token.h"
#include "magick/transform.h"
#include "magick/threshold.h"
#include "magick/type.h"
#include "magick/utility.h"
#include "magick/version.h"
#include "magick/vision.h"
#include "magick/visual-effects.h"
#include "magick/xml-tree.h"
#include "magick/xwindow.h"
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/colormap.h 0000644 00000001775 15051111170 0007766 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image colormap methods.
*/
#ifndef MAGICKCORE_COLORMAP_H
#define MAGICKCORE_COLORMAP_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
AcquireImageColormap(Image *,const size_t),
CycleColormapImage(Image *,const ssize_t),
SortColormapByIntensity(Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/threshold.h 0000644 00000004607 15051111170 0010143 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image threshold methods.
*/
#ifndef MAGICKCORE_THRESHOLD_H
#define MAGICKCORE_THRESHOLD_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedThresholdMethod,
KapurThresholdMethod,
OTSUThresholdMethod,
TriangleThresholdMethod
} AutoThresholdMethod;
typedef struct _ThresholdMap
ThresholdMap;
extern MagickExport Image
*AdaptiveThresholdImage(const Image *,const size_t,const size_t,const ssize_t,
ExceptionInfo *);
extern MagickExport ThresholdMap
*DestroyThresholdMap(ThresholdMap *),
*GetThresholdMap(const char *,ExceptionInfo *);
extern MagickExport MagickBooleanType
AutoThresholdImage(Image *,const AutoThresholdMethod,ExceptionInfo *),
BilevelImage(Image *,const double),
BilevelImageChannel(Image *,const ChannelType,const double),
BlackThresholdImage(Image *,const char *),
BlackThresholdImageChannel(Image *,const ChannelType,const char *,
ExceptionInfo *),
ClampImage(Image *),
ClampImageChannel(Image *,const ChannelType),
ListThresholdMaps(FILE *,ExceptionInfo *),
OrderedDitherImage(Image *), /* deprecated */
OrderedDitherImageChannel(Image *,const ChannelType,ExceptionInfo *),
OrderedPosterizeImage(Image *,const char *,ExceptionInfo *),
OrderedPosterizeImageChannel(Image *,const ChannelType,const char *,
ExceptionInfo *),
PerceptibleImage(Image *,const double),
PerceptibleImageChannel(Image *,const ChannelType,const double),
RandomThresholdImage(Image *,const char *,ExceptionInfo *),
RandomThresholdImageChannel(Image *,const ChannelType,const char *,
ExceptionInfo *),
WhiteThresholdImage(Image *,const char *),
WhiteThresholdImageChannel(Image *,const ChannelType,const char *,
ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/client.h 0000644 00000002027 15051111170 0007417 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore client methods.
*/
#ifndef MAGICKCORE_CLIENT_H
#define MAGICKCORE_CLIENT_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport const char
*GetClientPath(void) magick_attribute((__const__)),
*GetClientName(void) magick_attribute((__const__)),
*SetClientName(const char *),
*SetClientPath(const char *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/pixel.h 0000644 00000011301 15051111170 0007255 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image constitute methods.
*/
#ifndef MAGICKCORE_PIXEL_H
#define MAGICKCORE_PIXEL_H
#include "magick/colorspace.h"
#include "magick/constitute.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/*
Pixel enum declarations.
*/
typedef enum
{
UndefinedInterpolatePixel,
AverageInterpolatePixel, /* Average 4 nearest neighbours */
BicubicInterpolatePixel, /* Catmull-Rom interpolation */
BilinearInterpolatePixel, /* Triangular filter interpolation */
FilterInterpolatePixel, /* Use resize filter - (very slow) */
IntegerInterpolatePixel, /* Integer (floor) interpolation */
MeshInterpolatePixel, /* Triangular mesh interpolation */
NearestNeighborInterpolatePixel, /* Nearest neighbour only */
SplineInterpolatePixel, /* Cubic Spline (blurred) interpolation */
Average9InterpolatePixel, /* Average 9 nearest neighbours */
Average16InterpolatePixel, /* Average 16 nearest neighbours */
BlendInterpolatePixel, /* blend of nearest 1, 2 or 4 pixels */
BackgroundInterpolatePixel, /* just return background color */
CatromInterpolatePixel /* Catmull-Rom interpolation */
} InterpolatePixelMethod;
typedef enum
{
PixelRed = 0,
PixelCyan = 0,
PixelGray = 0,
PixelY = 0,
PixelGreen = 1,
PixelMagenta = 1,
PixelCb = 1,
PixelBlue = 2,
PixelYellow = 2,
PixelCr = 2,
PixelAlpha = 3,
PixelBlack = 4,
PixelIndex = 4,
MaskPixelComponent = 5
} PixelComponent;
typedef enum
{
UndefinedPixelIntensityMethod = 0,
AveragePixelIntensityMethod,
BrightnessPixelIntensityMethod,
LightnessPixelIntensityMethod,
Rec601LumaPixelIntensityMethod,
Rec601LuminancePixelIntensityMethod,
Rec709LumaPixelIntensityMethod,
Rec709LuminancePixelIntensityMethod,
RMSPixelIntensityMethod,
MSPixelIntensityMethod
} PixelIntensityMethod;
/*
Pixel typedef declarations.
*/
typedef struct _DoublePixelPacket
{
double
red,
green,
blue,
opacity,
index;
} DoublePixelPacket;
typedef struct _LongPixelPacket
{
unsigned int
red,
green,
blue,
opacity,
index;
} LongPixelPacket;
typedef struct _MagickPixelPacket
{
ClassType
storage_class;
ColorspaceType
colorspace;
MagickBooleanType
matte;
double
fuzz;
size_t
depth;
MagickRealType
red,
green,
blue,
opacity,
index;
} MagickPixelPacket;
typedef Quantum IndexPacket;
typedef struct _PixelPacket
{
#if defined(MAGICKCORE_WORDS_BIGENDIAN)
#define MAGICK_PIXEL_RGBA 1
Quantum
red,
green,
blue,
opacity;
#else
#define MAGICK_PIXEL_BGRA 1
Quantum
blue,
green,
red,
opacity;
#endif
} PixelPacket;
typedef struct _QuantumPixelPacket
{
Quantum
red,
green,
blue,
opacity,
index;
} QuantumPixelPacket;
typedef struct _CacheView
CacheView_;
/*
Pixel method declarations.
*/
extern MagickExport MagickBooleanType
ExportImagePixels(const Image *,const ssize_t,const ssize_t,const size_t,
const size_t,const char *,const StorageType,void *,ExceptionInfo *),
ImportImagePixels(Image *,const ssize_t,const ssize_t,const size_t,
const size_t,const char *,const StorageType,const void *),
InterpolateMagickPixelPacket(const Image *magick_restrict,const CacheView_ *,
const InterpolatePixelMethod,const double,const double,MagickPixelPacket *,
ExceptionInfo *);
extern MagickExport MagickPixelPacket
*CloneMagickPixelPacket(const MagickPixelPacket *);
extern MagickExport MagickRealType
DecodePixelGamma(const MagickRealType) magick_hot_spot,
EncodePixelGamma(const MagickRealType) magick_hot_spot,
GetMagickPixelIntensity(const Image *image,
const MagickPixelPacket *magick_restrict) magick_hot_spot,
GetPixelIntensity(const Image *image,const PixelPacket *magick_restrict)
magick_hot_spot;
extern MagickExport void
ConformMagickPixelPacket(Image *,const MagickPixelPacket *,
MagickPixelPacket *,ExceptionInfo *),
GetMagickPixelPacket(const Image *,MagickPixelPacket *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/resample.h 0000644 00000005142 15051111170 0007752 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore graphic resample methods.
*/
#ifndef MAGICKCORE_RESAMPLE_H
#define MAGICKCORE_RESAMPLE_H
#include "magick/cache-view.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/*
WARNING: The order of this table must also match the order of a table
located in AcquireResizeFilter() in "resize.c" otherwise the users filter
will not match the actual filter that is setup.
*/
typedef enum
{
UndefinedFilter,
PointFilter,
BoxFilter,
TriangleFilter,
HermiteFilter,
HanningFilter,
HammingFilter,
BlackmanFilter,
GaussianFilter,
QuadraticFilter,
CubicFilter,
CatromFilter,
MitchellFilter,
JincFilter,
SincFilter,
SincFastFilter,
KaiserFilter,
WelshFilter,
ParzenFilter,
BohmanFilter,
BartlettFilter,
LagrangeFilter,
LanczosFilter,
LanczosSharpFilter,
Lanczos2Filter,
Lanczos2SharpFilter,
RobidouxFilter,
RobidouxSharpFilter,
CosineFilter,
SplineFilter,
LanczosRadiusFilter,
SentinelFilter /* a count of all the filters, not a real filter */
} FilterTypes;
/*
Backward compatibility for the more correctly named Jinc Filter. Original
source of this filter is from "zoom" but it refers to a reference by Pratt,
who does not actualy name the filter.
*/
#define BesselFilter JincFilter
typedef struct _ResampleFilter
ResampleFilter;
extern MagickExport MagickBooleanType
ResamplePixelColor(ResampleFilter *,const double,const double,
MagickPixelPacket *),
SetResampleFilterInterpolateMethod(ResampleFilter *,
const InterpolatePixelMethod),
SetResampleFilterVirtualPixelMethod(ResampleFilter *,
const VirtualPixelMethod);
extern MagickExport ResampleFilter
*AcquireResampleFilter(const Image *,ExceptionInfo *),
*DestroyResampleFilter(ResampleFilter *);
extern MagickExport void
ScaleResampleFilter(ResampleFilter *,const double,const double,const double,
const double),
SetResampleFilter(ResampleFilter *,const FilterTypes,const double);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/type.h 0000644 00000004154 15051111170 0007125 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image type methods.
*/
#ifndef MAGICKCORE_TYPE_H
#define MAGICKCORE_TYPE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedStretch,
NormalStretch,
UltraCondensedStretch,
ExtraCondensedStretch,
CondensedStretch,
SemiCondensedStretch,
SemiExpandedStretch,
ExpandedStretch,
ExtraExpandedStretch,
UltraExpandedStretch,
AnyStretch
} StretchType;
typedef enum
{
UndefinedStyle,
NormalStyle,
ItalicStyle,
ObliqueStyle,
AnyStyle,
BoldStyle /* deprecated */
} StyleType;
typedef struct _TypeInfo
{
size_t
face;
char
*path,
*name,
*description,
*family;
StyleType
style;
StretchType
stretch;
size_t
weight;
char
*encoding,
*foundry,
*format,
*metrics,
*glyphs;
MagickBooleanType
stealth;
struct _TypeInfo
*previous,
*next; /* deprecated, use GetTypeInfoList() */
size_t
signature;
} TypeInfo;
extern MagickExport char
**GetTypeList(const char *,size_t *,ExceptionInfo *);
extern MagickExport MagickBooleanType
ListTypeInfo(FILE *,ExceptionInfo *),
TypeComponentGenesis(void);
extern MagickExport const TypeInfo
*GetTypeInfo(const char *,ExceptionInfo *),
*GetTypeInfoByFamily(const char *,const StyleType,const StretchType,
const size_t,ExceptionInfo *),
**GetTypeInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport void
TypeComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/gem.h 0000644 00000005721 15051111170 0006715 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore private graphic gems methods.
*/
#ifndef MAGICKCORE_GEM_H
#define MAGICKCORE_GEM_H
#include "magick/random_.h"
#include "magick/visual-effects.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport double
ExpandAffine(const AffineMatrix *) magick_attribute((__pure__)),
GenerateDifferentialNoise(RandomInfo *,const Quantum,const NoiseType,
const MagickRealType);
extern MagickExport size_t
GetOptimalKernelWidth(const double,const double),
GetOptimalKernelWidth1D(const double,const double),
GetOptimalKernelWidth2D(const double,const double);
extern MagickExport void
ConvertHCLToRGB(const double,const double,const double,Quantum *,Quantum *,
Quantum *),
ConvertHCLpToRGB(const double,const double,const double,Quantum *,Quantum *,
Quantum *),
ConvertHSBToRGB(const double,const double,const double,Quantum *,Quantum *,
Quantum *),
ConvertHSIToRGB(const double,const double,const double,Quantum *,Quantum *,
Quantum *),
ConvertHSLToRGB(const double,const double,const double,Quantum *,Quantum *,
Quantum *),
ConvertHSVToRGB(const double,const double,const double,Quantum *,Quantum *,
Quantum *),
ConvertHWBToRGB(const double,const double,const double,Quantum *,Quantum *,
Quantum *),
ConvertLCHabToRGB(const double,const double,const double,Quantum *,Quantum *,
Quantum *),
ConvertLCHuvToRGB(const double,const double,const double,Quantum *,Quantum *,
Quantum *),
ConvertRGBToHCL(const Quantum,const Quantum,const Quantum,double *,double *,
double *),
ConvertRGBToHCLp(const Quantum,const Quantum,const Quantum,double *,double *,
double *),
ConvertRGBToHSB(const Quantum,const Quantum,const Quantum,double *,double *,
double *),
ConvertRGBToHSI(const Quantum,const Quantum,const Quantum,double *,double *,
double *),
ConvertRGBToHSL(const Quantum,const Quantum,const Quantum,double *,double *,
double *),
ConvertRGBToHSV(const Quantum,const Quantum,const Quantum,double *,double *,
double *),
ConvertRGBToHWB(const Quantum,const Quantum,const Quantum,double *,double *,
double *),
ConvertRGBToLCHab(const Quantum,const Quantum,const Quantum,double *,double *,
double *),
ConvertRGBToLCHuv(const Quantum,const Quantum,const Quantum,double *,double *,
double *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/coder.h 0000644 00000003150 15051111170 0007233 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image coder methods.
*/
#ifndef MAGICKCORE_CODER_H
#define MAGICKCORE_CODER_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _CoderInfo
{
char
*path,
*magick,
*name;
MagickBooleanType
exempt,
stealth;
struct _CoderInfo
*previous,
*next; /* deprecated, use GetCoderInfoList() */
size_t
signature;
} CoderInfo;
extern MagickExport char
**GetCoderList(const char *,size_t *,ExceptionInfo *);
extern MagickExport const CoderInfo
*GetCoderInfo(const char *,ExceptionInfo *),
**GetCoderInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport MagickBooleanType
CoderComponentGenesis(void),
ListCoderInfo(FILE *,ExceptionInfo *);
MagickExport void
CoderComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/magick-baseconfig-64.h 0000644 00000132436 15051111170 0011731 0 ustar 00 #ifndef _MAGICK_MAGICK_BASECONFIG_H
#define _MAGICK_MAGICK_BASECONFIG_H 1
/* magick/magick-baseconfig.h. Generated automatically at end of configure. */
/* config/config.h. Generated from config.h.in by configure. */
/* config/config.h.in. Generated from configure.ac by autoheader. */
/* Define if building universal (internal helper macro) */
/* #undef AC_APPLE_UNIVERSAL_BUILD */
/* Define if you have AUTOTRACE library */
/* #undef AUTOTRACE_DELEGATE */
/* Define if coders and filters are to be built as modules. */
#ifndef MAGICKCORE_BUILD_MODULES
#define MAGICKCORE_BUILD_MODULES 1
#endif
/* Define if you have the bzip2 library */
#ifndef MAGICKCORE_BZLIB_DELEGATE
#define MAGICKCORE_BZLIB_DELEGATE 1
#endif
/* Define if you have CAIRO library */
#ifndef MAGICKCORE_CAIRO_DELEGATE
#define MAGICKCORE_CAIRO_DELEGATE 1
#endif
/* permit enciphering and deciphering image pixels */
#ifndef MAGICKCORE_CIPHER_SUPPORT
#define MAGICKCORE_CIPHER_SUPPORT 1
#endif
/* coders subdirectory. */
#ifndef MAGICKCORE_CODER_DIRNAME
#define MAGICKCORE_CODER_DIRNAME "coders"
#endif
/* Directory where architecture-dependent configuration files live. */
#ifndef MAGICKCORE_CONFIGURE_PATH
#define MAGICKCORE_CONFIGURE_PATH "/etc/ImageMagick-6/"
#endif
/* Subdirectory of lib where architecture-dependent configuration files live.
*/
#ifndef MAGICKCORE_CONFIGURE_RELATIVE_PATH
#define MAGICKCORE_CONFIGURE_RELATIVE_PATH "ImageMagick-6"
#endif
/* Define if you have DJVU library */
#ifndef MAGICKCORE_DJVU_DELEGATE
#define MAGICKCORE_DJVU_DELEGATE 1
#endif
/* Directory where ImageMagick documents live. */
#ifndef MAGICKCORE_DOCUMENTATION_PATH
#define MAGICKCORE_DOCUMENTATION_PATH "/usr/share/doc/ImageMagick-6/"
#endif
/* Define if you have Display Postscript */
/* #undef DPS_DELEGATE */
/* exclude deprecated methods in MagickCore API */
/* #undef EXCLUDE_DEPRECATED */
/* Directory where executables are installed. */
#ifndef MAGICKCORE_EXECUTABLE_PATH
#define MAGICKCORE_EXECUTABLE_PATH "/usr/bin/"
#endif
/* Define if you have FFTW library */
/* #undef FFTW_DELEGATE */
/* filter subdirectory. */
#ifndef MAGICKCORE_FILTER_DIRNAME
#define MAGICKCORE_FILTER_DIRNAME "filters"
#endif
/* Define if you have FLIF library */
/* #undef FLIF_DELEGATE */
/* Define if you have FONTCONFIG library */
#ifndef MAGICKCORE_FONTCONFIG_DELEGATE
#define MAGICKCORE_FONTCONFIG_DELEGATE 1
#endif
/* Define if you have FlashPIX library */
/* #undef FPX_DELEGATE */
/* Define if you have FREETYPE library */
#ifndef MAGICKCORE_FREETYPE_DELEGATE
#define MAGICKCORE_FREETYPE_DELEGATE 1
#endif
/* Define if you have Ghostscript library or framework */
#ifndef MAGICKCORE_GS_DELEGATE
#define MAGICKCORE_GS_DELEGATE 1
#endif
/* Define if you have GVC library */
#ifndef MAGICKCORE_GVC_DELEGATE
#define MAGICKCORE_GVC_DELEGATE 1
#endif
/* Define to 1 if you have the 'acosh' function. */
#ifndef MAGICKCORE_HAVE_ACOSH
#define MAGICKCORE_HAVE_ACOSH 1
#endif
/* Define to 1 if you have the 'aligned_malloc' function. */
/* #undef HAVE_ALIGNED_MALLOC */
/* Define to 1 if you have the <arm/limits.h> header file. */
/* #undef HAVE_ARM_LIMITS_H */
/* Define to 1 if you have the <arpa/inet.h> header file. */
#ifndef MAGICKCORE_HAVE_ARPA_INET_H
#define MAGICKCORE_HAVE_ARPA_INET_H 1
#endif
/* Define to 1 if you have the 'asinh' function. */
#ifndef MAGICKCORE_HAVE_ASINH
#define MAGICKCORE_HAVE_ASINH 1
#endif
/* Define to 1 if you have the 'atanh' function. */
#ifndef MAGICKCORE_HAVE_ATANH
#define MAGICKCORE_HAVE_ATANH 1
#endif
/* Define to 1 if you have the 'atexit' function. */
#ifndef MAGICKCORE_HAVE_ATEXIT
#define MAGICKCORE_HAVE_ATEXIT 1
#endif
/* Define to 1 if you have the 'atoll' function. */
#ifndef MAGICKCORE_HAVE_ATOLL
#define MAGICKCORE_HAVE_ATOLL 1
#endif
/* define if bool is a built-in type */
#ifndef MAGICKCORE_HAVE_BOOL
#define MAGICKCORE_HAVE_BOOL /**/
#endif
/* Define to 1 if you have the 'cabs' function. */
#ifndef MAGICKCORE_HAVE_CABS
#define MAGICKCORE_HAVE_CABS 1
#endif
/* Define to 1 if you have the 'carg' function. */
#ifndef MAGICKCORE_HAVE_CARG
#define MAGICKCORE_HAVE_CARG 1
#endif
/* Define to 1 if you have the 'cimag' function. */
#ifndef MAGICKCORE_HAVE_CIMAG
#define MAGICKCORE_HAVE_CIMAG 1
#endif
/* Define to 1 if you have the 'clock' function. */
#ifndef MAGICKCORE_HAVE_CLOCK
#define MAGICKCORE_HAVE_CLOCK 1
#endif
/* Define to 1 if you have the 'clock_getres' function. */
#ifndef MAGICKCORE_HAVE_CLOCK_GETRES
#define MAGICKCORE_HAVE_CLOCK_GETRES 1
#endif
/* Define to 1 if you have the 'clock_gettime' function. */
#ifndef MAGICKCORE_HAVE_CLOCK_GETTIME
#define MAGICKCORE_HAVE_CLOCK_GETTIME 1
#endif
/* Define to 1 if clock_gettime supports CLOCK_REALTIME. */
#ifndef MAGICKCORE_HAVE_CLOCK_REALTIME
#define MAGICKCORE_HAVE_CLOCK_REALTIME 1
#endif
/* Define to 1 if you have the <CL/cl.h> header file. */
/* #undef HAVE_CL_CL_H */
/* Define to 1 if you have the <complex.h> header file. */
#ifndef MAGICKCORE_HAVE_COMPLEX_H
#define MAGICKCORE_HAVE_COMPLEX_H 1
#endif
/* Define to 1 if you have the 'creal' function. */
#ifndef MAGICKCORE_HAVE_CREAL
#define MAGICKCORE_HAVE_CREAL 1
#endif
/* Define to 1 if you have the 'ctime_r' function. */
#ifndef MAGICKCORE_HAVE_CTIME_R
#define MAGICKCORE_HAVE_CTIME_R 1
#endif
/* Define to 1 if you have the declaration of 'pread', and to 0 if you don't.
*/
#ifndef MAGICKCORE_HAVE_DECL_PREAD
#define MAGICKCORE_HAVE_DECL_PREAD 1
#endif
/* Define to 1 if you have the declaration of 'pwrite', and to 0 if you don't.
*/
#ifndef MAGICKCORE_HAVE_DECL_PWRITE
#define MAGICKCORE_HAVE_DECL_PWRITE 1
#endif
/* Define to 1 if you have the declaration of 'strerror_r', and to 0 if you
don't. */
#ifndef MAGICKCORE_HAVE_DECL_STRERROR_R
#define MAGICKCORE_HAVE_DECL_STRERROR_R 1
#endif
/* Define to 1 if you have the declaration of 'strlcpy', and to 0 if you
don't. */
#ifndef MAGICKCORE_HAVE_DECL_STRLCPY
#define MAGICKCORE_HAVE_DECL_STRLCPY 0
#endif
/* Define to 1 if you have the declaration of 'tzname', and to 0 if you don't.
*/
/* #undef HAVE_DECL_TZNAME */
/* Define to 1 if you have the declaration of 'vsnprintf', and to 0 if you
don't. */
#ifndef MAGICKCORE_HAVE_DECL_VSNPRINTF
#define MAGICKCORE_HAVE_DECL_VSNPRINTF 1
#endif
/* Define to 1 if you have the 'directio' function. */
/* #undef HAVE_DIRECTIO */
/* Define to 1 if you have the <dirent.h> header file, and it defines 'DIR'.
*/
#ifndef MAGICKCORE_HAVE_DIRENT_H
#define MAGICKCORE_HAVE_DIRENT_H 1
#endif
/* Define to 1 if you have the <dlfcn.h> header file. */
#ifndef MAGICKCORE_HAVE_DLFCN_H
#define MAGICKCORE_HAVE_DLFCN_H 1
#endif
/* Define to 1 if you have the 'erf' function. */
#ifndef MAGICKCORE_HAVE_ERF
#define MAGICKCORE_HAVE_ERF 1
#endif
/* Define to 1 if you have the <errno.h> header file. */
#ifndef MAGICKCORE_HAVE_ERRNO_H
#define MAGICKCORE_HAVE_ERRNO_H 1
#endif
/* Define to 1 if you have the 'execvp' function. */
#ifndef MAGICKCORE_HAVE_EXECVP
#define MAGICKCORE_HAVE_EXECVP 1
#endif
/* Define to 1 if you have the 'fchmod' function. */
#ifndef MAGICKCORE_HAVE_FCHMOD
#define MAGICKCORE_HAVE_FCHMOD 1
#endif
/* Define to 1 if you have the <fcntl.h> header file. */
#ifndef MAGICKCORE_HAVE_FCNTL_H
#define MAGICKCORE_HAVE_FCNTL_H 1
#endif
/* Define to 1 if you have the <float.h> header file. */
#ifndef MAGICKCORE_HAVE_FLOAT_H
#define MAGICKCORE_HAVE_FLOAT_H 1
#endif
/* Define to 1 if you have the 'floor' function. */
#ifndef MAGICKCORE_HAVE_FLOOR
#define MAGICKCORE_HAVE_FLOOR 1
#endif
/* Define to 1 if you have the 'fork' function. */
#ifndef MAGICKCORE_HAVE_FORK
#define MAGICKCORE_HAVE_FORK 1
#endif
/* Define to 1 if fseeko (and ftello) are declared in stdio.h. */
#ifndef MAGICKCORE_HAVE_FSEEKO
#define MAGICKCORE_HAVE_FSEEKO 1
#endif
/* Define to 1 if you have the 'ftime' function. */
#ifndef MAGICKCORE_HAVE_FTIME
#define MAGICKCORE_HAVE_FTIME 1
#endif
/* Define to 1 if you have the 'ftruncate' function. */
#ifndef MAGICKCORE_HAVE_FTRUNCATE
#define MAGICKCORE_HAVE_FTRUNCATE 1
#endif
/* Define to 1 if you have the 'getcwd' function. */
#ifndef MAGICKCORE_HAVE_GETCWD
#define MAGICKCORE_HAVE_GETCWD 1
#endif
/* Define to 1 if you have the 'getc_unlocked' function. */
#ifndef MAGICKCORE_HAVE_GETC_UNLOCKED
#define MAGICKCORE_HAVE_GETC_UNLOCKED 1
#endif
/* Define to 1 if you have the 'getdtablesize' function. */
#ifndef MAGICKCORE_HAVE_GETDTABLESIZE
#define MAGICKCORE_HAVE_GETDTABLESIZE 1
#endif
/* Define to 1 if you have the 'getentropy' function. */
#ifndef MAGICKCORE_HAVE_GETENTROPY
#define MAGICKCORE_HAVE_GETENTROPY 1
#endif
/* Define to 1 if you have the 'getexecname' function. */
/* #undef HAVE_GETEXECNAME */
/* Define to 1 if you have the 'getpagesize' function. */
#ifndef MAGICKCORE_HAVE_GETPAGESIZE
#define MAGICKCORE_HAVE_GETPAGESIZE 1
#endif
/* Define to 1 if you have the 'getpid' function. */
#ifndef MAGICKCORE_HAVE_GETPID
#define MAGICKCORE_HAVE_GETPID 1
#endif
/* Define to 1 if you have the 'getpwnam_r' function. */
#ifndef MAGICKCORE_HAVE_GETPWNAM_R
#define MAGICKCORE_HAVE_GETPWNAM_R 1
#endif
/* Define to 1 if you have the 'getrlimit' function. */
#ifndef MAGICKCORE_HAVE_GETRLIMIT
#define MAGICKCORE_HAVE_GETRLIMIT 1
#endif
/* Define to 1 if you have the 'getrusage' function. */
#ifndef MAGICKCORE_HAVE_GETRUSAGE
#define MAGICKCORE_HAVE_GETRUSAGE 1
#endif
/* Define to 1 if you have the 'gettimeofday' function. */
#ifndef MAGICKCORE_HAVE_GETTIMEOFDAY
#define MAGICKCORE_HAVE_GETTIMEOFDAY 1
#endif
/* Define to 1 if you have the 'gmtime_r' function. */
#ifndef MAGICKCORE_HAVE_GMTIME_R
#define MAGICKCORE_HAVE_GMTIME_R 1
#endif
/* [Compile with hugepage support] */
/* #undef HAVE_HUGEPAGES */
/* Define to 1 if the system has the type 'intmax_t'. */
#ifndef MAGICKCORE_HAVE_INTMAX_T
#define MAGICKCORE_HAVE_INTMAX_T 1
#endif
/* Define to 1 if the system has the type 'intptr_t'. */
#ifndef MAGICKCORE_HAVE_INTPTR_T
#define MAGICKCORE_HAVE_INTPTR_T 1
#endif
/* Define to 1 if you have the <inttypes.h> header file. */
#ifndef MAGICKCORE_HAVE_INTTYPES_H
#define MAGICKCORE_HAVE_INTTYPES_H 1
#endif
/* Define to 1 if you have the 'isnan' function. */
#ifndef MAGICKCORE_HAVE_ISNAN
#define MAGICKCORE_HAVE_ISNAN 1
#endif
/* Define to 1 if you have the 'j0' function. */
#ifndef MAGICKCORE_HAVE_J0
#define MAGICKCORE_HAVE_J0 1
#endif
/* Define to 1 if you have the 'j1' function. */
#ifndef MAGICKCORE_HAVE_J1
#define MAGICKCORE_HAVE_J1 1
#endif
/* Define if you have jemalloc memory allocation library */
/* #undef HAVE_JEMALLOC */
/* Define if you have the <lcms2.h> header file. */
#ifndef MAGICKCORE_HAVE_LCMS2_H
#define MAGICKCORE_HAVE_LCMS2_H 1
#endif
/* Define if you have the <lcms2/lcms2.h> header file. */
/* #undef HAVE_LCMS2_LCMS2_H */
/* Define to 1 if you have the 'gcov' library (-lgcov). */
/* #undef HAVE_LIBGCOV */
/* Define to 1 if you have the <limits.h> header file. */
#ifndef MAGICKCORE_HAVE_LIMITS_H
#define MAGICKCORE_HAVE_LIMITS_H 1
#endif
/* Define if you have Linux-compatible sendfile() */
#ifndef MAGICKCORE_HAVE_LINUX_SENDFILE
#define MAGICKCORE_HAVE_LINUX_SENDFILE 1
#endif
/* Define to 1 if you have the <linux/unistd.h> header file. */
#ifndef MAGICKCORE_HAVE_LINUX_UNISTD_H
#define MAGICKCORE_HAVE_LINUX_UNISTD_H 1
#endif
/* Define to 1 if you have the 'lltostr' function. */
/* #undef HAVE_LLTOSTR */
/* Define to 1 if you have the <locale.h> header file. */
#ifndef MAGICKCORE_HAVE_LOCALE_H
#define MAGICKCORE_HAVE_LOCALE_H 1
#endif
/* Define to 1 if you have the 'localtime_r' function. */
#ifndef MAGICKCORE_HAVE_LOCALTIME_R
#define MAGICKCORE_HAVE_LOCALTIME_R 1
#endif
/* Define to 1 if the system has the type 'long long int'. */
#ifndef MAGICKCORE_HAVE_LONG_LONG_INT
#define MAGICKCORE_HAVE_LONG_LONG_INT 1
#endif
/* Define to 1 if you have the 'lstat' function. */
#ifndef MAGICKCORE_HAVE_LSTAT
#define MAGICKCORE_HAVE_LSTAT 1
#endif
/* Define to 1 if you have the <machine/param.h> header file. */
/* #undef HAVE_MACHINE_PARAM_H */
/* Define to 1 if you have the <mach-o/dyld.h> header file. */
/* #undef HAVE_MACH_O_DYLD_H */
/* Define to 1 if you have the <malloc.h> header file. */
#ifndef MAGICKCORE_HAVE_MALLOC_H
#define MAGICKCORE_HAVE_MALLOC_H 1
#endif
/* Define to 1 if <wchar.h> declares mbstate_t. */
#ifndef MAGICKCORE_HAVE_MBSTATE_T
#define MAGICKCORE_HAVE_MBSTATE_T 1
#endif
/* Define to 1 if you have the 'memmove' function. */
#ifndef MAGICKCORE_HAVE_MEMMOVE
#define MAGICKCORE_HAVE_MEMMOVE 1
#endif
/* Define to 1 if you have the 'memset' function. */
#ifndef MAGICKCORE_HAVE_MEMSET
#define MAGICKCORE_HAVE_MEMSET 1
#endif
/* Define to 1 if you have the <minix/config.h> header file. */
/* #undef HAVE_MINIX_CONFIG_H */
/* Define to 1 if you have the 'mkdir' function. */
#ifndef MAGICKCORE_HAVE_MKDIR
#define MAGICKCORE_HAVE_MKDIR 1
#endif
/* Define to 1 if you have the 'mkstemp' function. */
#ifndef MAGICKCORE_HAVE_MKSTEMP
#define MAGICKCORE_HAVE_MKSTEMP 1
#endif
/* Define to 1 if you have a working 'mmap' system call. */
#ifndef MAGICKCORE_HAVE_MMAP
#define MAGICKCORE_HAVE_MMAP 1
#endif
/* Define if you have the mtmalloc memory allocation library */
/* #undef HAVE_MTMALLOC */
/* Define to 1 if you have the 'munmap' function. */
#ifndef MAGICKCORE_HAVE_MUNMAP
#define MAGICKCORE_HAVE_MUNMAP 1
#endif
/* define if the compiler implements namespaces */
#ifndef MAGICKCORE_HAVE_NAMESPACES
#define MAGICKCORE_HAVE_NAMESPACES /**/
#endif
/* Define if g++ supports namespace std. */
#ifndef MAGICKCORE_HAVE_NAMESPACE_STD
#define MAGICKCORE_HAVE_NAMESPACE_STD /**/
#endif
/* Define to 1 if you have the 'nanosleep' function. */
#ifndef MAGICKCORE_HAVE_NANOSLEEP
#define MAGICKCORE_HAVE_NANOSLEEP 1
#endif
/* Define to 1 if you have the <ndir.h> header file, and it defines 'DIR'. */
/* #undef HAVE_NDIR_H */
/* Define to 1 if you have the <netdb.h> header file. */
#ifndef MAGICKCORE_HAVE_NETDB_H
#define MAGICKCORE_HAVE_NETDB_H 1
#endif
/* Define to 1 if you have the <netinet/in.h> header file. */
#ifndef MAGICKCORE_HAVE_NETINET_IN_H
#define MAGICKCORE_HAVE_NETINET_IN_H 1
#endif
/* Define to 1 if you have the 'newlocale' function. */
#ifndef MAGICKCORE_HAVE_NEWLOCALE
#define MAGICKCORE_HAVE_NEWLOCALE 1
#endif
/* Define to 1 if you have the <OpenCL/cl.h> header file. */
/* #undef HAVE_OPENCL_CL_H */
/* Define to 1 if you have the <OS.h> header file. */
/* #undef HAVE_OS_H */
/* Define to 1 if you have the 'pclose' function. */
#ifndef MAGICKCORE_HAVE_PCLOSE
#define MAGICKCORE_HAVE_PCLOSE 1
#endif
/* Define to 1 if you have the 'poll' function. */
#ifndef MAGICKCORE_HAVE_POLL
#define MAGICKCORE_HAVE_POLL 1
#endif
/* Define to 1 if you have the 'popen' function. */
#ifndef MAGICKCORE_HAVE_POPEN
#define MAGICKCORE_HAVE_POPEN 1
#endif
/* Define to 1 if you have the 'posix_fadvise' function. */
#ifndef MAGICKCORE_HAVE_POSIX_FADVISE
#define MAGICKCORE_HAVE_POSIX_FADVISE 1
#endif
/* Define to 1 if you have the 'posix_fallocate' function. */
#ifndef MAGICKCORE_HAVE_POSIX_FALLOCATE
#define MAGICKCORE_HAVE_POSIX_FALLOCATE 1
#endif
/* Define to 1 if you have the 'posix_madvise' function. */
#ifndef MAGICKCORE_HAVE_POSIX_MADVISE
#define MAGICKCORE_HAVE_POSIX_MADVISE 1
#endif
/* Define to 1 if you have the 'posix_memalign' function. */
#ifndef MAGICKCORE_HAVE_POSIX_MEMALIGN
#define MAGICKCORE_HAVE_POSIX_MEMALIGN 1
#endif
/* Define to 1 if you have the 'posix_spawnp' function. */
#ifndef MAGICKCORE_HAVE_POSIX_SPAWNP
#define MAGICKCORE_HAVE_POSIX_SPAWNP 1
#endif
/* Define to 1 if you have the 'pow' function. */
#ifndef MAGICKCORE_HAVE_POW
#define MAGICKCORE_HAVE_POW 1
#endif
/* Define to 1 if you have the 'pread' function. */
#ifndef MAGICKCORE_HAVE_PREAD
#define MAGICKCORE_HAVE_PREAD 1
#endif
/* Define to 1 if you have the <process.h> header file. */
/* #undef HAVE_PROCESS_H */
/* Define if you have POSIX threads libraries and header files. */
#ifndef MAGICKCORE_HAVE_PTHREAD
#define MAGICKCORE_HAVE_PTHREAD 1
#endif
/* Have PTHREAD_PRIO_INHERIT. */
#ifndef MAGICKCORE_HAVE_PTHREAD_PRIO_INHERIT
#define MAGICKCORE_HAVE_PTHREAD_PRIO_INHERIT 1
#endif
/* Define to 1 if you have the 'putenv' function. */
#ifndef MAGICKCORE_HAVE_PUTENV
#define MAGICKCORE_HAVE_PUTENV 1
#endif
/* Define to 1 if you have the 'pwrite' function. */
#ifndef MAGICKCORE_HAVE_PWRITE
#define MAGICKCORE_HAVE_PWRITE 1
#endif
/* Define to 1 if you have the 'qsort_r' function. */
#ifndef MAGICKCORE_HAVE_QSORT_R
#define MAGICKCORE_HAVE_QSORT_R 1
#endif
/* Define to 1 if you have the 'raise' function. */
#ifndef MAGICKCORE_HAVE_RAISE
#define MAGICKCORE_HAVE_RAISE 1
#endif
/* Define to 1 if you have the 'rand_r' function. */
#ifndef MAGICKCORE_HAVE_RAND_R
#define MAGICKCORE_HAVE_RAND_R 1
#endif
/* Define to 1 if you have the 'readlink' function. */
#ifndef MAGICKCORE_HAVE_READLINK
#define MAGICKCORE_HAVE_READLINK 1
#endif
/* Define to 1 if you have the 'realpath' function. */
#ifndef MAGICKCORE_HAVE_REALPATH
#define MAGICKCORE_HAVE_REALPATH 1
#endif
/* Define to 1 if you have the 'seekdir' function. */
#ifndef MAGICKCORE_HAVE_SEEKDIR
#define MAGICKCORE_HAVE_SEEKDIR 1
#endif
/* Define to 1 if you have the 'select' function. */
#ifndef MAGICKCORE_HAVE_SELECT
#define MAGICKCORE_HAVE_SELECT 1
#endif
/* Define to 1 if you have the 'sendfile' function. */
#ifndef MAGICKCORE_HAVE_SENDFILE
#define MAGICKCORE_HAVE_SENDFILE 1
#endif
/* Define to 1 if you have the 'setlocale' function. */
#ifndef MAGICKCORE_HAVE_SETLOCALE
#define MAGICKCORE_HAVE_SETLOCALE 1
#endif
/* Define to 1 if you have the 'setvbuf' function. */
#ifndef MAGICKCORE_HAVE_SETVBUF
#define MAGICKCORE_HAVE_SETVBUF 1
#endif
/* X11 server supports shape extension */
#ifndef MAGICKCORE_HAVE_SHAPE
#define MAGICKCORE_HAVE_SHAPE 1
#endif
/* X11 server supports shared memory extension */
#ifndef MAGICKCORE_HAVE_SHARED_MEMORY
#define MAGICKCORE_HAVE_SHARED_MEMORY 1
#endif
/* Define to 1 if you have the 'sigaction' function. */
#ifndef MAGICKCORE_HAVE_SIGACTION
#define MAGICKCORE_HAVE_SIGACTION 1
#endif
/* Define to 1 if you have the 'sigemptyset' function. */
#ifndef MAGICKCORE_HAVE_SIGEMPTYSET
#define MAGICKCORE_HAVE_SIGEMPTYSET 1
#endif
/* Define to 1 if you have the 'socket' function. */
#ifndef MAGICKCORE_HAVE_SOCKET
#define MAGICKCORE_HAVE_SOCKET 1
#endif
/* Define to 1 if you have the 'spawnvp' function. */
/* #undef HAVE_SPAWNVP */
/* Define to 1 if you have the 'sqrt' function. */
#ifndef MAGICKCORE_HAVE_SQRT
#define MAGICKCORE_HAVE_SQRT 1
#endif
/* Define to 1 if you have the 'stat' function. */
#ifndef MAGICKCORE_HAVE_STAT
#define MAGICKCORE_HAVE_STAT 1
#endif
/* Define to 1 if you have the <stdarg.h> header file. */
#ifndef MAGICKCORE_HAVE_STDARG_H
#define MAGICKCORE_HAVE_STDARG_H 1
#endif
/* Define to 1 if stdbool.h conforms to C99. */
#ifndef MAGICKCORE_HAVE_STDBOOL_H
#define MAGICKCORE_HAVE_STDBOOL_H 1
#endif
/* Define to 1 if you have the <stddef.h> header file. */
#ifndef MAGICKCORE_HAVE_STDDEF_H
#define MAGICKCORE_HAVE_STDDEF_H 1
#endif
/* Define to 1 if you have the <stdint.h> header file. */
#ifndef MAGICKCORE_HAVE_STDINT_H
#define MAGICKCORE_HAVE_STDINT_H 1
#endif
/* Define to 1 if you have the <stdio.h> header file. */
/* #undef HAVE_STDIO_H */
/* Define to 1 if you have the <stdlib.h> header file. */
#ifndef MAGICKCORE_HAVE_STDLIB_H
#define MAGICKCORE_HAVE_STDLIB_H 1
#endif
/* Define to 1 if you have the 'strcasecmp' function. */
#ifndef MAGICKCORE_HAVE_STRCASECMP
#define MAGICKCORE_HAVE_STRCASECMP 1
#endif
/* Define to 1 if you have the 'strcasestr' function. */
#ifndef MAGICKCORE_HAVE_STRCASESTR
#define MAGICKCORE_HAVE_STRCASESTR 1
#endif
/* Define to 1 if you have the 'strchr' function. */
#ifndef MAGICKCORE_HAVE_STRCHR
#define MAGICKCORE_HAVE_STRCHR 1
#endif
/* Define to 1 if you have the 'strcspn' function. */
#ifndef MAGICKCORE_HAVE_STRCSPN
#define MAGICKCORE_HAVE_STRCSPN 1
#endif
/* Define to 1 if you have the 'strdup' function. */
#ifndef MAGICKCORE_HAVE_STRDUP
#define MAGICKCORE_HAVE_STRDUP 1
#endif
/* Define to 1 if you have the 'strerror' function. */
#ifndef MAGICKCORE_HAVE_STRERROR
#define MAGICKCORE_HAVE_STRERROR 1
#endif
/* Define if you have 'strerror_r'. */
#ifndef MAGICKCORE_HAVE_STRERROR_R
#define MAGICKCORE_HAVE_STRERROR_R 1
#endif
/* Define to 1 if cpp supports the ANSI # stringizing operator. */
#ifndef MAGICKCORE_HAVE_STRINGIZE
#define MAGICKCORE_HAVE_STRINGIZE 1
#endif
/* Define to 1 if you have the <strings.h> header file. */
#ifndef MAGICKCORE_HAVE_STRINGS_H
#define MAGICKCORE_HAVE_STRINGS_H 1
#endif
/* Define to 1 if you have the <string.h> header file. */
#ifndef MAGICKCORE_HAVE_STRING_H
#define MAGICKCORE_HAVE_STRING_H 1
#endif
/* Define to 1 if you have the 'strlcat' function. */
/* #undef HAVE_STRLCAT */
/* Define to 1 if you have the 'strlcpy' function. */
/* #undef HAVE_STRLCPY */
/* Define to 1 if you have the 'strncasecmp' function. */
#ifndef MAGICKCORE_HAVE_STRNCASECMP
#define MAGICKCORE_HAVE_STRNCASECMP 1
#endif
/* Define to 1 if you have the 'strpbrk' function. */
#ifndef MAGICKCORE_HAVE_STRPBRK
#define MAGICKCORE_HAVE_STRPBRK 1
#endif
/* Define to 1 if you have the 'strrchr' function. */
#ifndef MAGICKCORE_HAVE_STRRCHR
#define MAGICKCORE_HAVE_STRRCHR 1
#endif
/* Define to 1 if you have the 'strspn' function. */
#ifndef MAGICKCORE_HAVE_STRSPN
#define MAGICKCORE_HAVE_STRSPN 1
#endif
/* Define to 1 if you have the 'strstr' function. */
#ifndef MAGICKCORE_HAVE_STRSTR
#define MAGICKCORE_HAVE_STRSTR 1
#endif
/* Define to 1 if you have the 'strtod' function. */
#ifndef MAGICKCORE_HAVE_STRTOD
#define MAGICKCORE_HAVE_STRTOD 1
#endif
/* Define to 1 if you have the 'strtod_l' function. */
#ifndef MAGICKCORE_HAVE_STRTOD_L
#define MAGICKCORE_HAVE_STRTOD_L 1
#endif
/* Define to 1 if you have the 'strtol' function. */
#ifndef MAGICKCORE_HAVE_STRTOL
#define MAGICKCORE_HAVE_STRTOL 1
#endif
/* Define to 1 if you have the 'strtoul' function. */
#ifndef MAGICKCORE_HAVE_STRTOUL
#define MAGICKCORE_HAVE_STRTOUL 1
#endif
/* Define to 1 if 'tm_zone' is a member of 'struct tm'. */
#ifndef MAGICKCORE_HAVE_STRUCT_TM_TM_ZONE
#define MAGICKCORE_HAVE_STRUCT_TM_TM_ZONE 1
#endif
/* Define to 1 if you have the <sun_prefetch.h> header file. */
/* #undef HAVE_SUN_PREFETCH_H */
/* Define to 1 if you have the 'symlink' function. */
#ifndef MAGICKCORE_HAVE_SYMLINK
#define MAGICKCORE_HAVE_SYMLINK 1
#endif
/* Define to 1 if you have the 'sysconf' function. */
#ifndef MAGICKCORE_HAVE_SYSCONF
#define MAGICKCORE_HAVE_SYSCONF 1
#endif
/* Define to 1 if you have the 'system' function. */
#ifndef MAGICKCORE_HAVE_SYSTEM
#define MAGICKCORE_HAVE_SYSTEM 1
#endif
/* Define to 1 if you have the <sys/dir.h> header file, and it defines 'DIR'.
*/
/* #undef HAVE_SYS_DIR_H */
/* Define to 1 if you have the <sys/ipc.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_IPC_H
#define MAGICKCORE_HAVE_SYS_IPC_H 1
#endif
/* Define to 1 if you have the <sys/mman.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_MMAN_H
#define MAGICKCORE_HAVE_SYS_MMAN_H 1
#endif
/* Define to 1 if you have the <sys/ndir.h> header file, and it defines 'DIR'.
*/
/* #undef HAVE_SYS_NDIR_H */
/* Define to 1 if you have the <sys/param.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_PARAM_H
#define MAGICKCORE_HAVE_SYS_PARAM_H 1
#endif
/* Define to 1 if you have the <sys/resource.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_RESOURCE_H
#define MAGICKCORE_HAVE_SYS_RESOURCE_H 1
#endif
/* Define to 1 if you have the <sys/sendfile.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_SENDFILE_H
#define MAGICKCORE_HAVE_SYS_SENDFILE_H 1
#endif
/* Define to 1 if you have the <sys/socket.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_SOCKET_H
#define MAGICKCORE_HAVE_SYS_SOCKET_H 1
#endif
/* Define to 1 if you have the <sys/stat.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_STAT_H
#define MAGICKCORE_HAVE_SYS_STAT_H 1
#endif
/* Define to 1 if you have the <sys/syslimits.h> header file. */
/* #undef HAVE_SYS_SYSLIMITS_H */
/* Define to 1 if you have the <sys/times.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_TIMES_H
#define MAGICKCORE_HAVE_SYS_TIMES_H 1
#endif
/* Define to 1 if you have the <sys/time.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_TIME_H
#define MAGICKCORE_HAVE_SYS_TIME_H 1
#endif
/* Define to 1 if you have the <sys/types.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_TYPES_H
#define MAGICKCORE_HAVE_SYS_TYPES_H 1
#endif
/* Define to 1 if you have the <sys/uio.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_UIO_H
#define MAGICKCORE_HAVE_SYS_UIO_H 1
#endif
/* Define to 1 if you have the <sys/wait.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_WAIT_H
#define MAGICKCORE_HAVE_SYS_WAIT_H 1
#endif
/* Define if you have the tcmalloc memory allocation library */
/* #undef HAVE_TCMALLOC */
/* Define to 1 if you have the 'telldir' function. */
#ifndef MAGICKCORE_HAVE_TELLDIR
#define MAGICKCORE_HAVE_TELLDIR 1
#endif
/* Define to 1 if you have the 'tempnam' function. */
#ifndef MAGICKCORE_HAVE_TEMPNAM
#define MAGICKCORE_HAVE_TEMPNAM 1
#endif
/* Define to 1 if you have the 'times' function. */
#ifndef MAGICKCORE_HAVE_TIMES
#define MAGICKCORE_HAVE_TIMES 1
#endif
/* Define to 1 if your 'struct tm' has 'tm_zone'. Deprecated, use
'HAVE_STRUCT_TM_TM_ZONE' instead. */
#ifndef MAGICKCORE_HAVE_TM_ZONE
#define MAGICKCORE_HAVE_TM_ZONE 1
#endif
/* Define to 1 if you don't have 'tm_zone' but do have the external array
'tzname'. */
/* #undef HAVE_TZNAME */
/* Define to 1 if the system has the type 'uintmax_t'. */
#ifndef MAGICKCORE_HAVE_UINTMAX_T
#define MAGICKCORE_HAVE_UINTMAX_T 1
#endif
/* Define to 1 if the system has the type 'uintptr_t'. */
#ifndef MAGICKCORE_HAVE_UINTPTR_T
#define MAGICKCORE_HAVE_UINTPTR_T 1
#endif
/* Define to 1 if you have the 'ulltostr' function. */
/* #undef HAVE_ULLTOSTR */
/* Define if you have umem memory allocation library */
/* #undef HAVE_UMEM */
/* Define to 1 if you have the <unistd.h> header file. */
#ifndef MAGICKCORE_HAVE_UNISTD_H
#define MAGICKCORE_HAVE_UNISTD_H 1
#endif
/* Define to 1 if the system has the type 'unsigned long long int'. */
#ifndef MAGICKCORE_HAVE_UNSIGNED_LONG_LONG_INT
#define MAGICKCORE_HAVE_UNSIGNED_LONG_LONG_INT 1
#endif
/* Define to 1 if you have the 'uselocale' function. */
#ifndef MAGICKCORE_HAVE_USELOCALE
#define MAGICKCORE_HAVE_USELOCALE 1
#endif
/* Define to 1 if you have the 'usleep' function. */
#ifndef MAGICKCORE_HAVE_USLEEP
#define MAGICKCORE_HAVE_USLEEP 1
#endif
/* Define to 1 if you have the 'utime' function. */
#ifndef MAGICKCORE_HAVE_UTIME
#define MAGICKCORE_HAVE_UTIME 1
#endif
/* Define to 1 if you have the <utime.h> header file. */
#ifndef MAGICKCORE_HAVE_UTIME_H
#define MAGICKCORE_HAVE_UTIME_H 1
#endif
/* Define to 1 if you have the 'vfprintf' function. */
#ifndef MAGICKCORE_HAVE_VFPRINTF
#define MAGICKCORE_HAVE_VFPRINTF 1
#endif
/* Define to 1 if you have the 'vfprintf_l' function. */
/* #undef HAVE_VFPRINTF_L */
/* Define to 1 if you have the 'vsnprintf' function. */
#ifndef MAGICKCORE_HAVE_VSNPRINTF
#define MAGICKCORE_HAVE_VSNPRINTF 1
#endif
/* Define to 1 if you have the 'vsnprintf_l' function. */
/* #undef HAVE_VSNPRINTF_L */
/* Define to 1 if you have the 'vsprintf' function. */
#ifndef MAGICKCORE_HAVE_VSPRINTF
#define MAGICKCORE_HAVE_VSPRINTF 1
#endif
/* Define to 1 if you have the 'waitpid' function. */
#ifndef MAGICKCORE_HAVE_WAITPID
#define MAGICKCORE_HAVE_WAITPID 1
#endif
/* Define to 1 if you have the <wchar.h> header file. */
#ifndef MAGICKCORE_HAVE_WCHAR_H
#define MAGICKCORE_HAVE_WCHAR_H 1
#endif
/* Define to 1 if you have the <xlocale.h> header file. */
/* #undef HAVE_XLOCALE_H */
/* Define to 1 if you have the '_aligned_malloc' function. */
/* #undef HAVE__ALIGNED_MALLOC */
/* Define to 1 if the system has the type '_Bool'. */
#ifndef MAGICKCORE_HAVE__BOOL
#define MAGICKCORE_HAVE__BOOL 1
#endif
/* Define to 1 if you have the '_exit' function. */
#ifndef MAGICKCORE_HAVE__EXIT
#define MAGICKCORE_HAVE__EXIT 1
#endif
/* Define to 1 if you have the '_NSGetExecutablePath' function. */
/* #undef HAVE__NSGETEXECUTABLEPATH */
/* Define to 1 if you have the '_pclose' function. */
/* #undef HAVE__PCLOSE */
/* Define to 1 if you have the '_popen' function. */
/* #undef HAVE__POPEN */
/* Define to 1 if you have the '_wfopen' function. */
/* #undef HAVE__WFOPEN */
/* Define to 1 if you have the '_wstat' function. */
/* #undef HAVE__WSTAT */
/* define if your compiler has __attribute__ */
#ifndef MAGICKCORE_HAVE___ATTRIBUTE__
#define MAGICKCORE_HAVE___ATTRIBUTE__ 1
#endif
/* Whether hdri is enabled or not */
#ifndef MAGICKCORE_HDRI_ENABLE_OBSOLETE_IN_H
#define MAGICKCORE_HDRI_ENABLE_OBSOLETE_IN_H 0
#endif
/* Define if you have libheif library */
/* #undef HEIC_DELEGATE */
/* Directory where ImageMagick architecture headers live. */
#ifndef MAGICKCORE_INCLUDEARCH_PATH
#define MAGICKCORE_INCLUDEARCH_PATH "/usr/include/ImageMagick-6/"
#endif
/* Directory where ImageMagick headers live. */
#ifndef MAGICKCORE_INCLUDE_PATH
#define MAGICKCORE_INCLUDE_PATH "/usr/include/ImageMagick-6/"
#endif
/* ImageMagick is formally installed under prefix */
#ifndef MAGICKCORE_INSTALLED_SUPPORT
#define MAGICKCORE_INSTALLED_SUPPORT 1
#endif
/* Define if you have JBIG library */
#ifndef MAGICKCORE_JBIG_DELEGATE
#define MAGICKCORE_JBIG_DELEGATE 1
#endif
/* Define if you have JPEG library */
#ifndef MAGICKCORE_JPEG_DELEGATE
#define MAGICKCORE_JPEG_DELEGATE 1
#endif
/* Define if you have LCMS library */
#ifndef MAGICKCORE_LCMS_DELEGATE
#define MAGICKCORE_LCMS_DELEGATE 1
#endif
/* Define if you have OPENJP2 library */
#ifndef MAGICKCORE_LIBOPENJP2_DELEGATE
#define MAGICKCORE_LIBOPENJP2_DELEGATE 1
#endif
/* Directory where architecture-dependent files live. */
#ifndef MAGICKCORE_LIBRARY_ABSOLUTE_PATH
#define MAGICKCORE_LIBRARY_ABSOLUTE_PATH "/usr/lib64/ImageMagick-6.9.13/"
#endif
/* Subdirectory of lib where ImageMagick architecture dependent files are
installed. */
#ifndef MAGICKCORE_LIBRARY_RELATIVE_PATH
#define MAGICKCORE_LIBRARY_RELATIVE_PATH "ImageMagick-6.9.13"
#endif
/* Binaries in libraries path base name (will be during install linked to bin)
*/
#ifndef MAGICKCORE_LIB_BIN_BASEDIRNAME
#define MAGICKCORE_LIB_BIN_BASEDIRNAME "bin"
#endif
/* Define if you have LQR library */
/* #undef LQR_DELEGATE */
/* Define if using libltdl to support dynamically loadable modules and OpenCL
*/
#ifndef MAGICKCORE_LTDL_DELEGATE
#define MAGICKCORE_LTDL_DELEGATE 1
#endif
/* Native module suffix */
#ifndef MAGICKCORE_LTDL_MODULE_EXT
#define MAGICKCORE_LTDL_MODULE_EXT ".so"
#endif
/* Define to the sub-directory where libtool stores uninstalled libraries. */
#ifndef MAGICKCORE_LT_OBJDIR
#define MAGICKCORE_LT_OBJDIR ".libs/"
#endif
/* Define if you have LZMA library */
#ifndef MAGICKCORE_LZMA_DELEGATE
#define MAGICKCORE_LZMA_DELEGATE 1
#endif
/* Define to prepend to default font search path. */
/* #undef MAGICK_FONT_PATH */
/* Target Host CPU */
#ifndef MAGICKCORE_MAGICK_TARGET_CPU
#define MAGICKCORE_MAGICK_TARGET_CPU x86_64
#endif
/* Target Host OS */
#ifndef MAGICKCORE_MAGICK_TARGET_OS
#define MAGICKCORE_MAGICK_TARGET_OS linux-gnu
#endif
/* Target Host Vendor */
#ifndef MAGICKCORE_MAGICK_TARGET_VENDOR
#define MAGICKCORE_MAGICK_TARGET_VENDOR redhat
#endif
/* Module directory name without ABI part. */
#ifndef MAGICKCORE_MODULES_BASEDIRNAME
#define MAGICKCORE_MODULES_BASEDIRNAME "modules"
#endif
/* Module directory dirname */
/* #undef MODULES_DIRNAME */
/* Magick API method prefix */
/* #undef NAMESPACE_PREFIX */
/* Magick API method prefix tag */
/* #undef NAMESPACE_PREFIX_TAG */
/* Define to 1 if assertions should be disabled. */
/* #undef NDEBUG */
/* Define if you have OPENEXR library */
#ifndef MAGICKCORE_OPENEXR_DELEGATE
#define MAGICKCORE_OPENEXR_DELEGATE 1
#endif
/* Define to the address where bug reports for this package should be sent. */
#ifndef MAGICKCORE_PACKAGE_BUGREPORT
#define MAGICKCORE_PACKAGE_BUGREPORT "https://github.com/ImageMagick/ImageMagick6/issues"
#endif
/* Define to the full name of this package. */
#ifndef MAGICKCORE_PACKAGE_NAME
#define MAGICKCORE_PACKAGE_NAME "ImageMagick"
#endif
/* Define to the full name and version of this package. */
#ifndef MAGICKCORE_PACKAGE_STRING
#define MAGICKCORE_PACKAGE_STRING "ImageMagick 6.9.13-25"
#endif
/* Define to the one symbol short name of this package. */
#ifndef MAGICKCORE_PACKAGE_TARNAME
#define MAGICKCORE_PACKAGE_TARNAME "ImageMagick"
#endif
/* Define to the home page for this package. */
#ifndef MAGICKCORE_PACKAGE_URL
#define MAGICKCORE_PACKAGE_URL "https://legacy.imagemagick.org"
#endif
/* Define to the version of this package. */
#ifndef MAGICKCORE_PACKAGE_VERSION
#define MAGICKCORE_PACKAGE_VERSION "6.9.13-25"
#endif
/* Define if you have PANGOCAIRO library */
#ifndef MAGICKCORE_PANGOCAIRO_DELEGATE
#define MAGICKCORE_PANGOCAIRO_DELEGATE 1
#endif
/* Define if you have PANGO library */
#ifndef MAGICKCORE_PANGO_DELEGATE
#define MAGICKCORE_PANGO_DELEGATE 1
#endif
/* enable pipes (|) in filenames */
/* #undef PIPES_SUPPORT */
/* Define if you have PNG library */
#ifndef MAGICKCORE_PNG_DELEGATE
#define MAGICKCORE_PNG_DELEGATE 1
#endif
/* Define to necessary symbol if this constant uses a non-standard name on
your system. */
/* #undef PTHREAD_CREATE_JOINABLE */
/* Pixel cache memory threshold (defaults to available memory) */
/* #undef PixelCacheThreshold */
/* Number of bits in a pixel Quantum (8/16/32/64) */
#ifndef MAGICKCORE_QUANTUM_DEPTH_OBSOLETE_IN_H
#define MAGICKCORE_QUANTUM_DEPTH_OBSOLETE_IN_H 16
#endif
/* Define if you have RAQM library */
#ifndef MAGICKCORE_RAQM_DELEGATE
#define MAGICKCORE_RAQM_DELEGATE 1
#endif
/* Define if you have LIBRAW library */
#ifndef MAGICKCORE_RAW_R_DELEGATE
#define MAGICKCORE_RAW_R_DELEGATE 1
#endif
/* Define if you have RSVG library */
#ifndef MAGICKCORE_RSVG_DELEGATE
#define MAGICKCORE_RSVG_DELEGATE 1
#endif
/* Setjmp/longjmp are thread safe */
#ifndef MAGICKCORE_SETJMP_IS_THREAD_SAFE
#define MAGICKCORE_SETJMP_IS_THREAD_SAFE 1
#endif
/* Sharearch directory name without ABI part. */
#ifndef MAGICKCORE_SHAREARCH_BASEDIRNAME
#define MAGICKCORE_SHAREARCH_BASEDIRNAME "config"
#endif
/* Sharearch directory dirname */
/* #undef SHAREARCH_DIRNAME */
/* Directory where architecture-independent configuration files live. */
#ifndef MAGICKCORE_SHARE_PATH
#define MAGICKCORE_SHARE_PATH "/usr/share/ImageMagick-6/"
#endif
/* Subdirectory of lib where architecture-independent configuration files
live. */
#ifndef MAGICKCORE_SHARE_RELATIVE_PATH
#define MAGICKCORE_SHARE_RELATIVE_PATH "ImageMagick-6"
#endif
/* The size of 'double', as computed by sizeof. */
#ifndef MAGICKCORE_SIZEOF_DOUBLE
#define MAGICKCORE_SIZEOF_DOUBLE 8
#endif
/* The size of 'double_t', as computed by sizeof. */
#ifndef MAGICKCORE_SIZEOF_DOUBLE_T
#define MAGICKCORE_SIZEOF_DOUBLE_T 8
#endif
/* The size of 'float', as computed by sizeof. */
#ifndef MAGICKCORE_SIZEOF_FLOAT
#define MAGICKCORE_SIZEOF_FLOAT 4
#endif
/* The size of 'float_t', as computed by sizeof. */
#ifndef MAGICKCORE_SIZEOF_FLOAT_T
#define MAGICKCORE_SIZEOF_FLOAT_T 4
#endif
/* The size of 'long double', as computed by sizeof. */
#ifndef MAGICKCORE_SIZEOF_LONG_DOUBLE
#define MAGICKCORE_SIZEOF_LONG_DOUBLE 16
#endif
/* The size of 'size_t', as computed by sizeof. */
#ifndef MAGICKCORE_SIZEOF_SIZE_T
#define MAGICKCORE_SIZEOF_SIZE_T 8
#endif
/* The size of 'unsigned long long', as computed by sizeof. */
#ifndef MAGICKCORE_SIZEOF_UNSIGNED_LONG_LONG
#define MAGICKCORE_SIZEOF_UNSIGNED_LONG_LONG 8
#endif
/* The size of 'void *', as computed by sizeof. */
#ifndef MAGICKCORE_SIZEOF_VOID_P
#define MAGICKCORE_SIZEOF_VOID_P 8
#endif
/* Define to 1 if the 'S_IS*' macros in <sys/stat.h> do not work properly. */
/* #undef STAT_MACROS_BROKEN */
/* Define to 1 if all of the C89 standard headers exist (not just the ones
required in a freestanding environment). This macro is provided for
backward compatibility; new code need not use it. */
#ifndef MAGICKCORE_STDC_HEADERS
#define MAGICKCORE_STDC_HEADERS 1
#endif
/* Define to 1 if strerror_r returns char *. */
#ifndef MAGICKCORE_STRERROR_R_CHAR_P
#define MAGICKCORE_STRERROR_R_CHAR_P 1
#endif
/* Define if you have POSIX threads libraries and header files. */
#ifndef MAGICKCORE_THREAD_SUPPORT
#define MAGICKCORE_THREAD_SUPPORT 1
#endif
/* Define if you have TIFF library */
#ifndef MAGICKCORE_TIFF_DELEGATE
#define MAGICKCORE_TIFF_DELEGATE 1
#endif
/* Define to 1 if your <sys/time.h> declares 'struct tm'. */
/* #undef TM_IN_SYS_TIME */
/* Enable extensions on AIX, Interix, z/OS. */
#ifndef _ALL_SOURCE
# define _ALL_SOURCE 1
#endif
/* Enable general extensions on macOS. */
#ifndef _DARWIN_C_SOURCE
/* # undef _DARWIN_C_SOURCE */
#endif
/* Enable general extensions on Solaris. */
#ifndef __EXTENSIONS__
# define __EXTENSIONS__ 1
#endif
/* Enable GNU extensions on systems that have them. */
#ifndef _GNU_SOURCE
# define _GNU_SOURCE 1
#endif
/* Enable X/Open compliant socket functions that do not require linking
with -lxnet on HP-UX 11.11. */
#ifndef _HPUX_ALT_XOPEN_SOCKET_API
/* # undef _HPUX_ALT_XOPEN_SOCKET_API */
#endif
/* Identify the host operating system as Minix.
This macro does not affect the system headers' behavior.
A future release of Autoconf may stop defining this macro. */
#ifndef _MINIX
/* # undef _MINIX */
#endif
/* Enable general extensions on NetBSD.
Enable NetBSD compatibility extensions on Minix. */
#ifndef _NETBSD_SOURCE
/* # undef _NETBSD_SOURCE */
#endif
/* Enable OpenBSD compatibility extensions on NetBSD.
Oddly enough, this does nothing on OpenBSD. */
#ifndef _OPENBSD_SOURCE
/* # undef _OPENBSD_SOURCE */
#endif
/* Define to 1 if needed for POSIX-compatible behavior. */
#ifndef _POSIX_SOURCE
/* # undef _POSIX_SOURCE */
#endif
/* Define to 2 if needed for POSIX-compatible behavior. */
#ifndef _POSIX_1_SOURCE
/* # undef _POSIX_1_SOURCE */
#endif
/* Enable POSIX-compatible threading on Solaris. */
#ifndef _POSIX_PTHREAD_SEMANTICS
# define _POSIX_PTHREAD_SEMANTICS 1
#endif
/* Enable extensions specified by ISO/IEC TS 18661-5:2014. */
#ifndef __STDC_WANT_IEC_60559_ATTRIBS_EXT__
/* # undef __STDC_WANT_IEC_60559_ATTRIBS_EXT__ */
#endif
/* Enable extensions specified by ISO/IEC TS 18661-1:2014. */
#ifndef __STDC_WANT_IEC_60559_BFP_EXT__
/* # undef __STDC_WANT_IEC_60559_BFP_EXT__ */
#endif
/* Enable extensions specified by ISO/IEC TS 18661-2:2015. */
#ifndef __STDC_WANT_IEC_60559_DFP_EXT__
/* # undef __STDC_WANT_IEC_60559_DFP_EXT__ */
#endif
/* Enable extensions specified by C23 Annex F. */
#ifndef __STDC_WANT_IEC_60559_EXT__
/* # undef __STDC_WANT_IEC_60559_EXT__ */
#endif
/* Enable extensions specified by ISO/IEC TS 18661-4:2015. */
#ifndef __STDC_WANT_IEC_60559_FUNCS_EXT__
/* # undef __STDC_WANT_IEC_60559_FUNCS_EXT__ */
#endif
/* Enable extensions specified by C23 Annex H and ISO/IEC TS 18661-3:2015. */
#ifndef __STDC_WANT_IEC_60559_TYPES_EXT__
/* # undef __STDC_WANT_IEC_60559_TYPES_EXT__ */
#endif
/* Enable extensions specified by ISO/IEC TR 24731-2:2010. */
#ifndef __STDC_WANT_LIB_EXT2__
/* # undef __STDC_WANT_LIB_EXT2__ */
#endif
/* Enable extensions specified by ISO/IEC 24747:2009. */
#ifndef __STDC_WANT_MATH_SPEC_FUNCS__
/* # undef __STDC_WANT_MATH_SPEC_FUNCS__ */
#endif
/* Enable extensions on HP NonStop. */
#ifndef _TANDEM_SOURCE
# define _TANDEM_SOURCE 1
#endif
/* Enable X/Open extensions. Define to 500 only if necessary
to make mbstate_t available. */
#ifndef _XOPEN_SOURCE
/* # undef _XOPEN_SOURCE */
#endif
/* Define if you have WEBPMUX library */
#ifndef MAGICKCORE_WEBPMUX_DELEGATE
#define MAGICKCORE_WEBPMUX_DELEGATE 1
#endif
/* Define if you have WEBP library */
#ifndef MAGICKCORE_WEBP_DELEGATE
#define MAGICKCORE_WEBP_DELEGATE 1
#endif
/* Define to use the Windows GDI32 library */
/* #undef WINGDI32_DELEGATE */
/* Define if using the dmalloc debugging malloc package */
/* #undef WITH_DMALLOC */
/* Define if you have WMF library */
#ifndef MAGICKCORE_WMF_DELEGATE
#define MAGICKCORE_WMF_DELEGATE 1
#endif
/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
significant byte first (like Motorola and SPARC, unlike Intel). */
#if defined AC_APPLE_UNIVERSAL_BUILD
# if defined __BIG_ENDIAN__
# define WORDS_BIGENDIAN 1
# endif
#else
# ifndef WORDS_BIGENDIAN
/* # undef WORDS_BIGENDIAN */
# endif
#endif
/* Location of X11 configure files */
#ifndef MAGICKCORE_X11_CONFIGURE_PATH
#define MAGICKCORE_X11_CONFIGURE_PATH ""
#endif
/* Define if you have X11 library */
#ifndef MAGICKCORE_X11_DELEGATE
#define MAGICKCORE_X11_DELEGATE 1
#endif
/* Define if you have XML library */
#ifndef MAGICKCORE_XML_DELEGATE
#define MAGICKCORE_XML_DELEGATE 1
#endif
/* Define to 1 if the X Window System is missing or not being used. */
/* #undef X_DISPLAY_MISSING */
/* Build self-contained, embeddable, zero-configuration ImageMagick */
/* #undef ZERO_CONFIGURATION_SUPPORT */
/* Define if you have ZLIB library */
#ifndef MAGICKCORE_ZLIB_DELEGATE
#define MAGICKCORE_ZLIB_DELEGATE 1
#endif
/* Define if you have ZSTD library */
#ifndef MAGICKCORE_ZSTD_DELEGATE
#define MAGICKCORE_ZSTD_DELEGATE 1
#endif
/* Number of bits in a file offset, on hosts where this is settable. */
/* #undef _FILE_OFFSET_BITS */
/* enable run-time bounds-checking */
/* #undef _FORTIFY_SOURCE */
/* Define to 1 if necessary to make fseeko visible. */
/* #undef _LARGEFILE_SOURCE */
/* Define to 1 on platforms where this makes off_t a 64-bit type. */
/* #undef _LARGE_FILES */
/* Number of bits in time_t, on hosts where this is settable. */
/* #undef _TIME_BITS */
/* Define for Solaris 2.5.1 so the uint32_t typedef from <sys/synch.h>,
<pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
#define below would cause a syntax error. */
/* #undef _UINT32_T */
/* Define for Solaris 2.5.1 so the uint64_t typedef from <sys/synch.h>,
<pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
#define below would cause a syntax error. */
/* #undef _UINT64_T */
/* Define for Solaris 2.5.1 so the uint8_t typedef from <sys/synch.h>,
<pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
#define below would cause a syntax error. */
/* #undef _UINT8_T */
/* Define to 1 if type 'char' is unsigned and your compiler does not
predefine this macro. */
#ifndef __CHAR_UNSIGNED__
/* # undef __CHAR_UNSIGNED__ */
#endif
/* Define to 1 on platforms where this makes time_t a 64-bit type. */
/* #undef __MINGW_USE_VC2005_COMPAT */
/* Define to appropriate substitute if compiler does not have __func__ */
/* #undef __func__ */
/* Define to empty if 'const' does not conform to ANSI C. */
/* #undef const */
/* Define as 'int' if <sys/types.h> doesn't define. */
/* #undef gid_t */
/* Define to '__inline__' or '__inline' if that's what the C compiler
calls it, or to nothing if 'inline' is not supported under any name. */
#ifndef __cplusplus
/* #undef inline */
#endif
/* Define to the type of a signed integer type of width exactly 16 bits if
such a type exists and the standard includes do not define it. */
/* #undef int16_t */
/* Define to the type of a signed integer type of width exactly 32 bits if
such a type exists and the standard includes do not define it. */
/* #undef int32_t */
/* Define to the type of a signed integer type of width exactly 64 bits if
such a type exists and the standard includes do not define it. */
/* #undef int64_t */
/* Define to the type of a signed integer type of width exactly 8 bits if such
a type exists and the standard includes do not define it. */
/* #undef int8_t */
/* Define to the widest signed integer type if <stdint.h> and <inttypes.h> do
not define. */
/* #undef intmax_t */
/* Define to the type of a signed integer type wide enough to hold a pointer,
if such a type exists, and if the system does not define it. */
/* #undef intptr_t */
/* Define to a type if <wchar.h> does not define. */
/* #undef mbstate_t */
/* Define to 'int' if <sys/types.h> does not define. */
/* #undef mode_t */
/* Define to 'long int' if <sys/types.h> does not define. */
/* #undef off_t */
/* Define as a signed integer type capable of holding a process identifier. */
/* #undef pid_t */
/* Define to the equivalent of the C99 'restrict' keyword, or to
nothing if this is not supported. Do not define if restrict is
supported only directly. */
#ifndef _magickcore_restrict
#define _magickcore_restrict __restrict
#endif
/* Work around a bug in older versions of Sun C++, which did not
#define __restrict__ or support _Restrict or __restrict__
even though the corresponding Sun C compiler ended up with
"#define restrict _Restrict" or "#define restrict __restrict__"
in the previous line. This workaround can be removed once
we assume Oracle Developer Studio 12.5 (2016) or later. */
#if defined __SUNPRO_CC && !defined __RESTRICT && !defined __restrict__
# define _Restrict
# define __restrict__
#endif
/* Define as 'unsigned int' if <stddef.h> doesn't define. */
/* #undef size_t */
/* Define as 'int' if <sys/types.h> doesn't define. */
/* #undef ssize_t */
/* Define as 'int' if <sys/types.h> doesn't define. */
/* #undef uid_t */
/* Define to the type of an unsigned integer type of width exactly 16 bits if
such a type exists and the standard includes do not define it. */
/* #undef uint16_t */
/* Define to the type of an unsigned integer type of width exactly 32 bits if
such a type exists and the standard includes do not define it. */
/* #undef uint32_t */
/* Define to the type of an unsigned integer type of width exactly 64 bits if
such a type exists and the standard includes do not define it. */
/* #undef uint64_t */
/* Define to the type of an unsigned integer type of width exactly 8 bits if
such a type exists and the standard includes do not define it. */
/* #undef uint8_t */
/* Define to the widest unsigned integer type if <stdint.h> and <inttypes.h>
do not define. */
/* #undef uintmax_t */
/* Define to the type of an unsigned integer type wide enough to hold a
pointer, if such a type exists, and if the system does not define it. */
/* #undef uintptr_t */
/* Define to empty if the keyword 'volatile' does not work. Warning: valid
code using 'volatile' can become incorrect without. Disable with care. */
/* #undef volatile */
/* once: _MAGICK_MAGICK_BASECONFIG_H */
#endif
magick/deprecate.h 0000644 00000042106 15051111170 0010077 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore deprecated methods.
*/
#ifndef MAGICKCORE_DEPRECATE_H
#define MAGICKCORE_DEPRECATE_H
#include <stdarg.h>
#include "magick/blob.h"
#include "magick/cache-view.h"
#include "magick/draw.h"
#include "magick/constitute.h"
#include "magick/magick-config.h"
#include "magick/pixel.h"
#include "magick/quantize.h"
#include "magick/quantum.h"
#include "magick/registry.h"
#include "magick/semaphore.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if !defined(MAGICKCORE_EXCLUDE_DEPRECATED)
#if !defined(magick_attribute)
# if !defined(__clang__) && !defined(__GNUC__)
# define magick_attribute(x) /*nothing*/
# else
# define magick_attribute __attribute__
# endif
#endif
#define Downscale(quantum) ScaleQuantumToChar(quantum)
#define LABColorspace LabColorspace
#define CompressPixelGamma(pixel) DecodePixelGamma(pixel)
#define DecodesRGBGamma(pixel) DecodePixelGamma(pixel)
#define EncodesRGBGamma(pixel) EncodePixelGamma(pixel)
#define ExpandPixelGamma(pixel) EncodePixelGamma(pixel)
#define Intensity(color) PixelIntensityToQuantum(color)
#define LiberateUniqueFileResource(resource) \
RelinquishUniqueFileResource(resource)
#define LiberateMagickResource(resource) RelinquishMagickResource(resource)
#define LiberateSemaphore(semaphore) RelinquishSemaphore(semaphore)
#define MagickHuge 3.4e+38F
#define MaxRGB QuantumRange /* deprecated */
#define QuantumDepth MAGICKCORE_QUANTUM_DEPTH
#define RunlengthEncodedCompression RLECompression
#define Upscale(value) ScaleCharToQuantum(value)
#define XDownscale(value) ScaleShortToQuantum(value)
#define XUpscale(quantum) ScaleQuantumToShort(quantum)
typedef enum
{
UndefinedMagickLayerMethod
} MagickLayerMethod;
typedef MagickOffsetType ExtendedSignedIntegralType;
typedef MagickSizeType ExtendedUnsignedIntegralType;
typedef MagickRealType ExtendedRationalType;
typedef struct _ViewInfo ViewInfo;
typedef MagickBooleanType
(*MonitorHandler)(const char *,const MagickOffsetType,const MagickSizeType,
ExceptionInfo *);
typedef struct _ImageAttribute
{
char
*key,
*value;
MagickBooleanType
compression;
struct _ImageAttribute
*previous,
*next; /* deprecated */
} ImageAttribute;
extern MagickExport CacheView
*CloseCacheView(CacheView *) magick_attribute((deprecated)),
*OpenCacheView(const Image *) magick_attribute((deprecated));
extern MagickExport char
*AllocateString(const char *) magick_attribute((deprecated)),
*InterpretImageAttributes(const ImageInfo *,Image *,const char *)
magick_attribute((deprecated)),
*PostscriptGeometry(const char *) magick_attribute((deprecated)),
*TranslateText(const ImageInfo *,Image *,const char *)
magick_attribute((deprecated));
extern MagickExport const ImageAttribute
*GetImageAttribute(const Image *,const char *),
*GetImageClippingPathAttribute(Image *) magick_attribute((deprecated)),
*GetNextImageAttribute(const Image *) magick_attribute((deprecated));
extern MagickExport const IndexPacket
*AcquireCacheViewIndexes(const CacheView *) magick_attribute((deprecated)),
*AcquireIndexes(const Image *) magick_attribute((deprecated));
extern MagickExport const PixelPacket
*AcquirePixels(const Image *) magick_attribute((deprecated)),
*AcquireCacheViewPixels(const CacheView *,const ssize_t,const ssize_t,
const size_t,const size_t,ExceptionInfo *)
magick_attribute((deprecated)),
*AcquireImagePixels(const Image *,const ssize_t,const ssize_t,const size_t,
const size_t,ExceptionInfo *) magick_attribute((deprecated));
extern MagickExport FILE
*OpenMagickStream(const char *,const char *);
extern MagickExport Image
*AllocateImage(const ImageInfo *) magick_attribute((deprecated)),
*AverageImages(const Image *,ExceptionInfo *),
*ExtractSubimageFromImage(Image *,const Image *,ExceptionInfo *)
magick_attribute((deprecated)),
*GetImageFromMagickRegistry(const char *,ssize_t *id,ExceptionInfo *)
magick_attribute((deprecated)),
*GetImageList(const Image *,const ssize_t,ExceptionInfo *)
magick_attribute((deprecated)),
*GetNextImage(const Image *) magick_attribute((deprecated)),
*GetPreviousImage(const Image *) magick_attribute((deprecated)),
*FlattenImages(Image *,ExceptionInfo *) magick_attribute((deprecated)),
*MaximumImages(const Image *,ExceptionInfo *),
*MedianFilterImage(const Image *,const double,ExceptionInfo *),
*ModeImage(const Image *,const double,ExceptionInfo *),
*MinimumImages(const Image *,ExceptionInfo *),
*MosaicImages(Image *,ExceptionInfo *) magick_attribute((deprecated)),
*PopImageList(Image **) magick_attribute((deprecated)),
*RadialBlurImage(const Image *,const double,ExceptionInfo *)
magick_attribute((deprecated)),
*RadialBlurImageChannel(const Image *,const ChannelType,const double,
ExceptionInfo *) magick_attribute((deprecated)),
*RecolorImage(const Image *,const size_t,const double *,ExceptionInfo *)
magick_attribute((deprecated)),
*ReduceNoiseImage(const Image *,const double,ExceptionInfo *),
*ShiftImageList(Image **) magick_attribute((deprecated)),
*SpliceImageList(Image *,const ssize_t,const size_t,const Image *,
ExceptionInfo *) magick_attribute((deprecated)),
*ZoomImage(const Image *,const size_t,const size_t,ExceptionInfo *)
magick_attribute((deprecated));
extern MagickExport IndexPacket
*GetCacheViewIndexes(CacheView *) magick_attribute((deprecated)),
*GetIndexes(const Image *) magick_attribute((deprecated)),
ValidateColormapIndex(Image *,const size_t) magick_attribute((deprecated));
extern MagickExport int
GetImageGeometry(Image *,const char *,const unsigned int,RectangleInfo *)
magick_attribute((deprecated)),
ParseImageGeometry(const char *,ssize_t *,ssize_t *,size_t *,size_t *)
magick_attribute((deprecated)),
SystemCommand(const MagickBooleanType,const MagickBooleanType,const char *,
ExceptionInfo *) magick_attribute((deprecated));
extern MagickExport MagickBooleanType
AcquireOneCacheViewPixel(const CacheView *,const ssize_t,const ssize_t,
PixelPacket *,ExceptionInfo *) magick_attribute((deprecated)),
AcquireOneCacheViewVirtualPixel(const CacheView *,const VirtualPixelMethod,
const ssize_t,const ssize_t,PixelPacket *,ExceptionInfo *)
magick_attribute((deprecated)),
AffinityImage(const QuantizeInfo *,Image *,const Image *)
magick_attribute((deprecated)),
AffinityImages(const QuantizeInfo *,Image *,const Image *)
magick_attribute((deprecated)),
AllocateImageColormap(Image *,const size_t)
magick_attribute((deprecated)),
ClipPathImage(Image *,const char *,const MagickBooleanType)
magick_attribute((deprecated)),
CloneImageAttributes(Image *,const Image *) magick_attribute((deprecated)),
ColorFloodfillImage(Image *,const DrawInfo *,const PixelPacket,const ssize_t,
const ssize_t,const PaintMethod) magick_attribute((deprecated)),
ConstituteComponentGenesis(void) magick_attribute((deprecated)),
DeleteImageAttribute(Image *,const char *) magick_attribute((deprecated)),
DeleteMagickRegistry(const ssize_t) magick_attribute((deprecated)),
DescribeImage(Image *,FILE *,const MagickBooleanType)
magick_attribute((deprecated)),
FormatImageAttribute(Image *,const char *,const char *,...)
magick_attribute((__format__ (__printf__,3,4)))
magick_attribute((deprecated)),
FormatImageAttributeList(Image *,const char *,const char *,va_list)
magick_attribute((__format__ (__printf__,3,0)))
magick_attribute((deprecated)),
FormatImagePropertyList(Image *,const char *,const char *,va_list)
magick_attribute((__format__ (__printf__,3,0))),
FuzzyColorCompare(const Image *,const PixelPacket *,const PixelPacket *)
magick_attribute((deprecated)),
FuzzyOpacityCompare(const Image *,const PixelPacket *,const PixelPacket *)
magick_attribute((deprecated)),
InitializeModuleList(ExceptionInfo *) magick_attribute((deprecated)),
IsMagickInstantiated(void) magick_attribute((deprecated)),
LevelImageColors(Image *,const ChannelType,const MagickPixelPacket *,
const MagickPixelPacket *, const MagickBooleanType)
magick_attribute((deprecated)),
LoadMimeLists(const char *,ExceptionInfo *) magick_attribute((deprecated)),
MagickMonitor(const char *,const MagickOffsetType,const MagickSizeType,
void *) magick_attribute((deprecated)),
MapImage(Image *,const Image *,const MagickBooleanType)
magick_attribute((deprecated)),
MapImages(Image *,const Image *,const MagickBooleanType)
magick_attribute((deprecated)),
MatteFloodfillImage(Image *,const PixelPacket,const Quantum,const ssize_t,
const ssize_t,const PaintMethod) magick_attribute((deprecated)),
OpaqueImage(Image *,const PixelPacket,const PixelPacket)
magick_attribute((deprecated)),
PaintFloodfillImage(Image *,const ChannelType,const MagickPixelPacket *,
const ssize_t,const ssize_t,const DrawInfo *,const PaintMethod)
magick_attribute((deprecated)),
PaintOpaqueImage(Image *,const MagickPixelPacket *,const MagickPixelPacket *)
magick_attribute((deprecated)),
PaintOpaqueImageChannel(Image *,const ChannelType,const MagickPixelPacket *,
const MagickPixelPacket *) magick_attribute((deprecated)),
PaintTransparentImage(Image *,const MagickPixelPacket *,const Quantum)
magick_attribute((deprecated)),
SetExceptionInfo(ExceptionInfo *,ExceptionType)
magick_attribute((deprecated)),
SetImageAttribute(Image *,const char *,const char *)
magick_attribute((deprecated)),
SyncCacheViewPixels(CacheView *) magick_attribute((deprecated)),
SyncImagePixels(Image *) magick_attribute((deprecated)),
TransparentImage(Image *,const PixelPacket,const Quantum)
magick_attribute((deprecated));
extern MagickExport MagickPixelPacket
AcquireOneMagickPixel(const Image *,const ssize_t,const ssize_t,
ExceptionInfo *) magick_attribute((deprecated));
extern MagickExport MonitorHandler
GetMonitorHandler(void) magick_attribute((deprecated)),
SetMonitorHandler(MonitorHandler) magick_attribute((deprecated));
extern MagickExport MagickOffsetType
SizeBlob(Image *image) magick_attribute((deprecated));
extern MagickExport MagickPixelPacket
InterpolatePixelColor(const Image *,CacheView *,const InterpolatePixelMethod,
const double,const double,ExceptionInfo *) magick_attribute((deprecated));
extern MagickExport MagickStatusType
ParseSizeGeometry(const Image *,const char *,RectangleInfo *)
magick_attribute((deprecated));
extern MagickExport PixelPacket
AcquireOnePixel(const Image *,const ssize_t,const ssize_t,ExceptionInfo *)
magick_attribute((deprecated)),
AcquireOneVirtualPixel(const Image *,const VirtualPixelMethod,const ssize_t,
const ssize_t,ExceptionInfo *) magick_attribute((deprecated)),
*GetCacheView(CacheView *,const ssize_t,const ssize_t,const size_t,
const size_t) magick_attribute((deprecated)),
*GetCacheViewPixels(CacheView *,const ssize_t,const ssize_t,const size_t,
const size_t) magick_attribute((deprecated)),
*GetImagePixels(Image *,const ssize_t,const ssize_t,const size_t,
const size_t) magick_attribute((deprecated)),
GetOnePixel(Image *,const ssize_t,const ssize_t)
magick_attribute((deprecated)),
*GetPixels(const Image *) magick_attribute((deprecated)),
*SetCacheViewPixels(CacheView *,const ssize_t,const ssize_t,const size_t,
const size_t) magick_attribute((deprecated)),
*SetImagePixels(Image *,const ssize_t,const ssize_t,const size_t,
const size_t) magick_attribute((deprecated));
extern MagickExport MagickRealType
InversesRGBCompandor(const MagickRealType) magick_attribute((deprecated)),
sRGBCompandor(const MagickRealType) magick_attribute((deprecated));
extern MagickExport size_t
GetImageListSize(const Image *) magick_attribute((deprecated)),
PopImagePixels(Image *,const QuantumType,unsigned char *)
magick_attribute((deprecated)),
PushImagePixels(Image *,const QuantumType,const unsigned char *)
magick_attribute((deprecated));
extern MagickExport ssize_t
FormatMagickString(char *,const size_t,const char *,...)
magick_attribute((__format__ (__printf__,3,4)))
magick_attribute((deprecated)),
FormatMagickStringList(char *,const size_t,const char *,va_list)
magick_attribute((__format__ (__printf__,3,0))),
GetImageListIndex(const Image *) magick_attribute((deprecated)),
SetMagickRegistry(const RegistryType,const void *,const size_t,
ExceptionInfo *) magick_attribute((deprecated));
extern MagickExport unsigned int
ChannelImage(Image *,const ChannelType) magick_attribute((deprecated)),
ChannelThresholdImage(Image *,const char *) magick_attribute((deprecated)),
DispatchImage(const Image *,const ssize_t,const ssize_t,const size_t,
const size_t,const char *,const StorageType,void *,ExceptionInfo *)
magick_attribute((deprecated)),
FuzzyColorMatch(const PixelPacket *,const PixelPacket *,const double)
magick_attribute((deprecated)),
GetNumberScenes(const Image *) magick_attribute((deprecated)),
GetMagickGeometry(const char *,ssize_t *,ssize_t *,size_t *,size_t *)
magick_attribute((deprecated)),
IsSubimage(const char *,const unsigned int) magick_attribute((deprecated)),
PushImageList(Image **,const Image *,ExceptionInfo *)
magick_attribute((deprecated)),
QuantizationError(Image *) magick_attribute((deprecated)),
RandomChannelThresholdImage(Image *,const char *,const char *,
ExceptionInfo *) magick_attribute((deprecated)),
SetImageList(Image **,const Image *,const ssize_t,ExceptionInfo *)
magick_attribute((deprecated)),
TransformColorspace(Image *,const ColorspaceType)
magick_attribute((deprecated)),
ThresholdImage(Image *,const double) magick_attribute((deprecated)),
ThresholdImageChannel(Image *,const char *) magick_attribute((deprecated)),
UnshiftImageList(Image **,const Image *,ExceptionInfo *)
magick_attribute((deprecated));
extern MagickExport void
*AcquireMemory(const size_t) magick_attribute((deprecated)),
AcquireSemaphoreInfo(SemaphoreInfo **) magick_attribute((deprecated)),
AllocateNextImage(const ImageInfo *,Image *) magick_attribute((deprecated)),
*CloneMemory(void *,const void *,const size_t) magick_attribute((deprecated)),
ConstituteComponentTerminus(void) magick_attribute((deprecated)),
DestroyConstitute(void),
DestroyImageAttributes(Image *) magick_attribute((deprecated)),
DestroyImages(Image *) magick_attribute((deprecated)),
DestroyMagick(void) magick_attribute((deprecated)),
DestroyMagickRegistry(void) magick_attribute((deprecated)),
*GetConfigureBlob(const char *,char *,size_t *,ExceptionInfo *)
magick_attribute((deprecated)),
GetExceptionInfo(ExceptionInfo *),
*GetMagickRegistry(const ssize_t,RegistryType *,size_t *,ExceptionInfo *)
magick_attribute((deprecated)),
GetTokenToken(const char *,const char **,char *),
IdentityAffine(AffineMatrix *) magick_attribute((deprecated)),
LiberateMemory(void **) magick_attribute((deprecated)),
LiberateSemaphoreInfo(SemaphoreInfo **) magick_attribute((deprecated)),
FormatString(char *,const char *,...)
magick_attribute((__format__ (__printf__,2,3)))
magick_attribute((deprecated)),
FormatStringList(char *,const char *,va_list)
magick_attribute((__format__ (__printf__,2,0)))
magick_attribute((deprecated)),
HSLTransform(const double,const double,const double,Quantum *,Quantum *,
Quantum *) magick_attribute((deprecated)),
InitializeMagick(const char *) magick_attribute((deprecated)),
MagickIncarnate(const char *) magick_attribute((deprecated)),
ReacquireMemory(void **,const size_t) magick_attribute((deprecated)),
RelinquishSemaphoreInfo(SemaphoreInfo *) magick_attribute((deprecated)),
ResetImageAttributeIterator(const Image *) magick_attribute((deprecated)),
SetCacheThreshold(const size_t) magick_attribute((deprecated)),
SetImage(Image *,const Quantum) magick_attribute((deprecated)),
Strip(char *) magick_attribute((deprecated)),
TemporaryFilename(char *) magick_attribute((deprecated)),
TransformHSL(const Quantum,const Quantum,const Quantum,double *,double *,
double *) magick_attribute((deprecated));
#if defined(MAGICKCORE_WINGDI32_DELEGATE)
extern MagickExport void
*CropImageToHBITMAP(Image *,const RectangleInfo *,ExceptionInfo *),
*ImageToHBITMAP(Image *,ExceptionInfo *);
#endif
/*
Inline methods.
*/
static inline double MagickEpsilonReciprocal(const double x)
{
double
sign;
sign=x < 0.0 ? -1.0 : 1.0;
if ((sign*x) >= MagickEpsilon)
return(1.0/x);
return(sign/MagickEpsilon);
}
static inline Quantum PixelIntensityToQuantum(
const Image *magick_restrict image,const PixelPacket *magick_restrict pixel)
{
return(ClampToQuantum(GetPixelIntensity(image,pixel)));
}
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/token.h 0000644 00000003126 15051111170 0007262 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore token methods.
*/
#ifndef MAGICKCORE_TOKEN_H
#define MAGICKCORE_TOKEN_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/*
Typedef declarations.
*/
typedef struct _TokenInfo
TokenInfo;
extern MagickExport int
Tokenizer(TokenInfo *,const unsigned int,char *,const size_t,const char *,
const char *,const char *,const char *,const char,char *,int *,char *);
extern MagickExport MagickBooleanType
GlobExpression(const char *magick_restrict,const char *magick_restrict,
const MagickBooleanType) magick_attribute((__pure__)),
IsGlob(const char *) magick_attribute((__pure__)),
IsMagickTrue(const char *) magick_attribute((__pure__));
extern MagickExport size_t
GetNextToken(const char *magick_restrict,const char **magick_restrict,
const size_t,char *magick_restrict) magick_hot_spot;
extern MagickExport TokenInfo
*AcquireTokenInfo(void),
*DestroyTokenInfo(TokenInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/magick-config-64.h 0000644 00000015126 15051111170 0011072 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickConfig not autogenerated (fixed stuff)
*/
#ifndef MAGICKCORE_MAGICK_CONFIG_H
#define MAGICKCORE_MAGICK_CONFIG_H
#include "magick/magick-baseconfig.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/* Compatibility block */
#if !defined(MAGICKCORE_QUANTUM_DEPTH) && defined(MAGICKCORE_QUANTUM_DEPTH_OBSOLETE_IN_H)
# warning "you should set MAGICKCORE_QUANTUM_DEPTH to sensible default set it to configure time default"
# warning "this is an obsolete behavior please fix your makefile"
# define MAGICKCORE_QUANTUM_DEPTH MAGICKCORE_QUANTUM_DEPTH_OBSOLETE_IN_H
#endif
/* Number of bits in a pixel Quantum (8/16/32/64) */
#ifndef MAGICKCORE_QUANTUM_DEPTH
# error "you should set MAGICKCORE_QUANTUM_DEPTH"
#endif
/* check values */
#if MAGICKCORE_QUANTUM_DEPTH != 8
# if MAGICKCORE_QUANTUM_DEPTH != 16
# if MAGICKCORE_QUANTUM_DEPTH != 32
# if MAGICKCORE_QUANTUM_DEPTH != 64
# error "MAGICKCORE_QUANTUM_DEPTH is not 8/16/32/64 bits"
# endif
# endif
# endif
#endif
#if !defined(MAGICKCORE_HDRI_ENABLE) && defined(MAGICKCORE_HDRI_ENABLE_OBSOLETE_IN_H)
# warning "you should set MAGICKCORE_HDRI_ENABLE to sensible default set it to configure time default"
# warning "this is an obsolete behavior please fix yours makefile"
# define MAGICKCORE_HDRI_ENABLE MAGICKCORE_HDRI_ENABLE_OBSOLETE_IN_H
#endif
/* whether HDRI is enable */
#if !defined(MAGICKCORE_HDRI_ENABLE)
# error "you should set MAGICKCORE_HDRI_ENABLE"
#endif
#if MAGICKCORE_HDRI_ENABLE
# define MAGICKCORE_HDRI_SUPPORT 1
#endif
#if defined __CYGWIN32__ && !defined __CYGWIN__
/* For backwards compatibility with Cygwin b19 and
earlier, we define __CYGWIN__ here, so that
we can rely on checking just for that macro. */
# define __CYGWIN__ __CYGWIN32__
#endif
/*! stringify */
#define MAGICKCORE_STRING_QUOTE(str) #str
#define MAGICKCORE_STRING_XQUOTE(str) MAGICKCORE_STRING_QUOTE(str)
/* ABI SUFFIX */
#ifndef MAGICKCORE_HDRI_SUPPORT
#define MAGICKCORE_ABI_SUFFIX "Q" MAGICKCORE_STRING_XQUOTE(MAGICKCORE_QUANTUM_DEPTH)
#else
#define MAGICKCORE_ABI_SUFFIX "Q" MAGICKCORE_STRING_XQUOTE(MAGICKCORE_QUANTUM_DEPTH) "HDRI"
#endif
/* some path game */
#if !defined __CYGWIN__
# if defined (_WIN32) || defined (_WIN64) || defined (__MSDOS__) || defined (__DJGPP__) || defined (__OS2__)
/* Use Windows separators on all _WIN32 defining
environments, except Cygwin. */
# define MAGICKCORE_DIR_SEPARATOR_CHAR '\\'
# define MAGICKCORE_DIR_SEPARATOR "\\"
# define MAGICKCORE_PATH_SEPARATOR_CHAR ';'
# define MAGICKCORE_PATH_SEPARATOR ";"
# endif
#endif
/* posix */
#ifndef MAGICKCORE_DIR_SEPARATOR_CHAR
/* Assume that not having this is an indicator that all
are missing. */
# define MAGICKCORE_DIR_SEPARATOR_CHAR '/'
# define MAGICKCORE_DIR_SEPARATOR "/"
# define MAGICKCORE_PATH_SEPARATOR_CHAR ':'
# define MAGICKCORE_PATH_SEPARATOR ":"
#endif /* !DIR_SEPARATOR_CHAR */
# if defined(MAGICKCORE_POSIX_SUPPORT) || defined(__MINGW32__)
/* module dir */
#ifndef MAGICKCORE_MODULES_DIRNAME
# define MAGICKCORE_MODULES_DIRNAME MAGICKCORE_MODULES_BASEDIRNAME "-" MAGICKCORE_ABI_SUFFIX
#endif
#ifndef MAGICKCORE_MODULES_PATH
# define MAGICKCORE_MODULES_PATH MAGICKCORE_LIBRARY_ABSOLUTE_PATH MAGICKCORE_DIR_SEPARATOR MAGICKCORE_MODULES_DIRNAME
#endif
#ifndef MAGICKCORE_MODULES_RELATIVE_PATH
#define MAGICKCORE_MODULES_RELATIVE_PATH MAGICKCORE_LIBRARY_RELATIVE_PATH MAGICKCORE_DIR_SEPARATOR MAGICKCORE_MODULES_DIRNAME
#endif
/* Subdirectory under lib to place ImageMagick coder module files */
#ifndef MAGICKCORE_CODER_PATH
# if defined(vms)
# define MAGICKCORE_CODER_PATH "sys$login:"
# else
# define MAGICKCORE_CODER_PATH MAGICKCORE_MODULES_PATH MAGICKCORE_DIR_SEPARATOR MAGICKCORE_CODER_DIRNAME
# endif
#endif
#ifndef MAGICKCORE_CODER_RELATIVE_PATH
# define MAGICKCORE_CODER_RELATIVE_PATH MAGICKCORE_MODULES_RELATIVE_PATH MAGICKCORE_DIR_SEPARATOR MAGICKCORE_CODER_DIRNAME
#endif
/* subdirectory under lib to place ImageMagick filter module files */
#ifndef MAGICKCORE_FILTER_PATH
# if defined(vms)
# define MAGICKCORE_FILTER_PATH "sys$login:"
# else
# define MAGICKCORE_FILTER_PATH MAGICKCORE_MODULES_PATH MAGICKCORE_DIR_SEPARATOR MAGICKCORE_FILTER_DIRNAME
# endif
#endif
#ifndef MAGICKCORE_FILTER_RELATIVE_PATH
# define MAGICKCORE_FILTER_RELATIVE_PATH MAGICKCORE_MODULES_RELATIVE_PATH MAGICKCORE_DIR_SEPARATOR MAGICKCORE_FILTER_DIRNAME
#endif
/* sharearch dir */
#ifndef MAGICKCORE_SHAREARCH_DIRNAME
# define MAGICKCORE_SHAREARCH_DIRNAME MAGICKCORE_SHAREARCH_BASEDIRNAME "-" MAGICKCORE_ABI_SUFFIX
#endif
#ifndef MAGICKCORE_SHAREARCH_PATH
# define MAGICKCORE_SHAREARCH_PATH MAGICKCORE_LIBRARY_ABSOLUTE_PATH MAGICKCORE_DIR_SEPARATOR MAGICKCORE_SHAREARCH_DIRNAME MAGICKCORE_DIR_SEPARATOR
#endif
#ifndef MAGICKCORE_SHAREARCH_RELATIVE_PATH
#define MAGICKCORE_SHAREARCH_RELATIVE_PATH MAGICKCORE_LIBRARY_RELATIVE_PATH MAGICKCORE_DIR_SEPARATOR MAGICKCORE_SHAREARCH_DIRNAME
#endif
/* for Clang compatibility */
#ifndef __has_builtin
# define __has_builtin(x) 0
#endif
#if defined(__GNUC__) && !defined(__clang__)
# define MAGICKCORE_DIAGNOSTIC_PUSH() \
_Pragma("GCC diagnostic push")
# define MAGICKCORE_DIAGNOSTIC_IGNORE_MAYBE_UNINITIALIZED() \
_Pragma("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
# define MAGICKCORE_DIAGNOSTIC_POP() \
_Pragma("GCC diagnostic pop")
#else
# define MAGICKCORE_DIAGNOSTIC_PUSH()
# define MAGICKCORE_DIAGNOSTIC_IGNORE_MAYBE_UNINITIALIZED()
# define MAGICKCORE_DIAGNOSTIC_POP()
#endif
#define MAGICKCORE_BITS_BELOW(power_of_2) \
((power_of_2)-1)
#define MAGICKCORE_MAX_ALIGNMENT_PADDING(power_of_2) \
MAGICKCORE_BITS_BELOW(power_of_2)
#define MAGICKCORE_IS_NOT_ALIGNED(n, power_of_2) \
((n) & MAGICKCORE_BITS_BELOW(power_of_2))
#define MAGICKCORE_IS_NOT_POWER_OF_2(n) \
MAGICKCORE_IS_NOT_ALIGNED((n), (n))
#define MAGICKCORE_ALIGN_DOWN(n, power_of_2) \
((n) & ~MAGICKCORE_BITS_BELOW(power_of_2))
#define MAGICKCORE_ALIGN_UP(n, power_of_2) \
MAGICKCORE_ALIGN_DOWN((n) + MAGICKCORE_MAX_ALIGNMENT_PADDING(power_of_2),power_of_2)
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/memory_.h 0000644 00000006325 15051111170 0007615 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore memory methods.
*/
#ifndef MAGICKCORE_MEMORY_H
#define MAGICKCORE_MEMORY_H
#include <errno.h>
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _MemoryInfo
MemoryInfo;
typedef void
*(*AcquireMemoryHandler)(size_t) magick_alloc_size(1),
(*DestroyMemoryHandler)(void *),
*(*ResizeMemoryHandler)(void *,size_t) magick_alloc_size(2),
*(*AcquireAlignedMemoryHandler)(const size_t,const size_t),
(*RelinquishAlignedMemoryHandler)(void *);
extern MagickExport MemoryInfo
*AcquireVirtualMemory(const size_t,const size_t) magick_alloc_sizes(1,2),
*RelinquishVirtualMemory(MemoryInfo *);
extern MagickExport size_t
GetMaxMemoryRequest(void);
extern MagickExport void
*AcquireAlignedMemory(const size_t,const size_t)
magick_attribute((__malloc__)) magick_alloc_sizes(1,2),
*AcquireMagickMemory(const size_t) magick_attribute((__malloc__))
magick_alloc_size(1),
*AcquireCriticalMemory(const size_t),
*AcquireQuantumMemory(const size_t,const size_t)
magick_attribute((__malloc__)) magick_alloc_sizes(1,2),
*CopyMagickMemory(void *magick_restrict,const void *magick_restrict,
const size_t) magick_attribute((__nonnull__)),
DestroyMagickMemory(void),
GetMagickMemoryMethods(AcquireMemoryHandler *,ResizeMemoryHandler *,
DestroyMemoryHandler *),
*GetVirtualMemoryBlob(const MemoryInfo *),
*RelinquishAlignedMemory(void *),
*RelinquishMagickMemory(void *),
*ResetMagickMemory(void *,int,const size_t),
*ResizeMagickMemory(void *,const size_t)
magick_attribute((__malloc__)) magick_alloc_size(2),
*ResizeQuantumMemory(void *,const size_t,const size_t)
magick_attribute((__malloc__)) magick_alloc_sizes(2,3),
SetMagickAlignedMemoryMethods(AcquireAlignedMemoryHandler,
RelinquishAlignedMemoryHandler),
SetMagickMemoryMethods(AcquireMemoryHandler,ResizeMemoryHandler,
DestroyMemoryHandler);
static inline MagickBooleanType HeapOverflowSanityCheck(
const size_t count,const size_t quantum)
{
if ((count == 0) || (quantum == 0))
return(MagickTrue);
if (quantum != ((count*quantum)/count))
{
errno=ENOMEM;
return(MagickTrue);
}
return(MagickFalse);
}
static inline MagickBooleanType HeapOverflowSanityCheckGetSize(
const size_t count,const size_t quantum,size_t *const extent)
{
size_t
length;
if ((count == 0) || (quantum == 0))
return(MagickTrue);
length=count*quantum;
if (quantum != (length/count))
{
errno=ENOMEM;
return(MagickTrue);
}
if (extent != (size_t *) NULL)
*extent=length;
return(MagickFalse);
}
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/cipher.h 0000644 00000002150 15051111170 0007410 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore cipher methods.
*/
#ifndef MAGICKCORE_CIPHER_H
#define MAGICKCORE_CIPHER_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
DecipherImage(Image *,const char *,ExceptionInfo *),
EncipherImage(Image *,const char *,ExceptionInfo *),
PasskeyDecipherImage(Image *,const StringInfo *,ExceptionInfo *),
PasskeyEncipherImage(Image *,const StringInfo *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/policy.h 0000644 00000003562 15051111170 0007445 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore security policy methods.
*/
#ifndef MAGICKCORE_POLICY_H
#define MAGICKCORE_POLICY_H
#include "magick/pixel.h"
#include "magick/exception.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedPolicyDomain,
CoderPolicyDomain,
DelegatePolicyDomain,
FilterPolicyDomain,
PathPolicyDomain,
ResourcePolicyDomain,
SystemPolicyDomain,
CachePolicyDomain,
ModulePolicyDomain
} PolicyDomain;
typedef enum
{
UndefinedPolicyRights = 0x00,
NoPolicyRights = 0x00,
ReadPolicyRights = 0x01,
WritePolicyRights = 0x02,
ExecutePolicyRights = 0x04,
AllPolicyRights = 0xff
} PolicyRights;
typedef struct _PolicyInfo
PolicyInfo;
extern MagickExport char
*GetPolicyValue(const char *name),
**GetPolicyList(const char *,size_t *,ExceptionInfo *);
extern MagickExport const PolicyInfo
**GetPolicyInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport MagickBooleanType
IsRightsAuthorized(const PolicyDomain,const PolicyRights,const char *),
ListPolicyInfo(FILE *,ExceptionInfo *),
PolicyComponentGenesis(void),
SetMagickSecurityPolicy(const char *,ExceptionInfo *);
extern MagickExport void
PolicyComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/splay-tree.h 0000644 00000003743 15051111170 0010234 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore splay-tree methods.
*/
#ifndef MAGICKCORE_SPLAY_H
#define MAGICKCORE_SPLAY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _SplayTreeInfo
SplayTreeInfo;
extern MagickExport MagickBooleanType
AddValueToSplayTree(SplayTreeInfo *,const void *,const void *),
DeleteNodeByValueFromSplayTree(SplayTreeInfo *,const void *),
DeleteNodeFromSplayTree(SplayTreeInfo *,const void *);
extern MagickExport const void
*GetNextKeyInSplayTree(SplayTreeInfo *),
*GetNextValueInSplayTree(SplayTreeInfo *),
*GetRootValueFromSplayTree(SplayTreeInfo *),
*GetValueFromSplayTree(SplayTreeInfo *,const void *);
extern MagickExport int
CompareSplayTreeString(const void *,const void *),
CompareSplayTreeStringInfo(const void *,const void *);
extern MagickExport SplayTreeInfo
*CloneSplayTree(SplayTreeInfo *,void *(*)(void *),void *(*)(void *)),
*DestroySplayTree(SplayTreeInfo *),
*NewSplayTree(int (*)(const void *,const void *),void *(*)(void *),
void *(*)(void *));
extern MagickExport size_t
GetNumberOfNodesInSplayTree(const SplayTreeInfo *);
extern MagickExport void
*RemoveNodeByValueFromSplayTree(SplayTreeInfo *,const void *),
*RemoveNodeFromSplayTree(SplayTreeInfo *,const void *),
ResetSplayTree(SplayTreeInfo *),
ResetSplayTreeIterator(SplayTreeInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/stream.h 0000644 00000002130 15051111170 0007427 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image stream methods.
*/
#ifndef MAGICKCORE_STREAM_H
#define MAGICKCORE_STREAM_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef size_t
(*StreamHandler)(const Image *,const void *,const size_t);
extern MagickExport Image
*ReadStream(const ImageInfo *,StreamHandler,ExceptionInfo *);
extern MagickExport MagickBooleanType
WriteStream(const ImageInfo *,Image *,StreamHandler);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/semaphore.h 0000644 00000002503 15051111170 0010123 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore methods to lock and unlock semaphores.
*/
#ifndef MAGICKCORE_SEMAPHORE_H
#define MAGICKCORE_SEMAPHORE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct SemaphoreInfo
SemaphoreInfo;
extern MagickExport void
SemaphoreComponentTerminus(void);
extern MagickExport MagickBooleanType
SemaphoreComponentGenesis(void);
extern MagickExport SemaphoreInfo
*AllocateSemaphoreInfo(void);
extern MagickExport void
ActivateSemaphoreInfo(SemaphoreInfo **),
DestroySemaphoreInfo(SemaphoreInfo **),
LockSemaphoreInfo(SemaphoreInfo *),
SemaphoreComponentTerminus(void),
UnlockSemaphoreInfo(SemaphoreInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/monitor.h 0000644 00000003120 15051111170 0007623 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore progress monitor methods.
*/
#ifndef MAGICKCORE_MONITOR_H
#define MAGICKCORE_MONITOR_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef MagickBooleanType
(*MagickProgressMonitor)(const char *,const MagickOffsetType,
const MagickSizeType,void *);
MagickExport MagickBooleanType
SetImageProgress(const Image *,const char *,const MagickOffsetType,
const MagickSizeType);
MagickExport MagickProgressMonitor
SetImageProgressMonitor(Image *,const MagickProgressMonitor,void *),
SetImageInfoProgressMonitor(ImageInfo *,const MagickProgressMonitor,void *);
static inline MagickBooleanType QuantumTick(const MagickOffsetType offset,
const MagickSizeType span)
{
if (span <= 100)
return(MagickTrue);
if (offset == (MagickOffsetType) (span-1))
return(MagickTrue);
if ((offset % (MagickOffsetType) (span/100)) == 0)
return(MagickTrue);
return(MagickFalse);
}
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/fx.h 0000644 00000002004 15051111170 0006551 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image f/x methods.
*/
#ifndef MAGICKCORE_FX_H
#define MAGICKCORE_FX_H
#include "magick/draw.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport Image
*FxImage(const Image *,const char *,ExceptionInfo *),
*FxImageChannel(const Image *,const ChannelType,const char *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/magick-type.h 0000644 00000015631 15051111170 0010360 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore types.
*/
#ifndef MAGICKCORE_MAGICK_TYPE_H
#define MAGICKCORE_MAGICK_TYPE_H
#include "magick/magick-config.h"
#if defined(MAGICKCORE_HAVE_UINTPTR_T)
# include <stdint.h>
#endif
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if !defined(MAGICKCORE_QUANTUM_DEPTH)
#define MAGICKCORE_QUANTUM_DEPTH 16
#endif
#if !defined(MagickPathExtent)
#define MagickPathExtent MaxTextExtent
#endif
#if defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(__MINGW32__)
# define MagickLLConstant(c) ((MagickOffsetType) (c ## i64))
# define MagickULLConstant(c) ((MagickSizeType) (c ## ui64))
#else
# define MagickLLConstant(c) ((MagickOffsetType) (c ## LL))
# define MagickULLConstant(c) ((MagickSizeType) (c ## ULL))
#endif
#if MAGICKCORE_SIZEOF_FLOAT_T == 0
typedef float MagickFloatType;
#elif (MAGICKCORE_SIZEOF_FLOAT_T == MAGICKCORE_SIZEOF_FLOAT)
typedef float MagickFloatType;
#elif (MAGICKCORE_SIZEOF_FLOAT_T == MAGICKCORE_SIZEOF_DOUBLE)
typedef double MagickFloatType;
#elif (MAGICKCORE_SIZEOF_FLOAT_T == MAGICKCORE_SIZEOF_LONG_DOUBLE)
typedef double MagickFloatType;
#else
#error Your MagickFloatType type is neither a float, nor a double, nor a long double
#endif
#if MAGICKCORE_SIZEOF_DOUBLE_T == 0
typedef double MagickDoubleType;
#elif (MAGICKCORE_SIZEOF_DOUBLE_T == MAGICKCORE_SIZEOF_DOUBLE)
typedef double MagickDoubleType;
#elif (MAGICKCORE_SIZEOF_DOUBLE_T == MAGICKCORE_SIZEOF_LONG_DOUBLE)
typedef long double MagickDoubleType;
#else
#error Your MagickDoubleType type is neither a float, nor a double, nor a long double
#endif
#if (MAGICKCORE_QUANTUM_DEPTH == 8)
#define MaxColormapSize 256UL
#define MaxMap 255UL
typedef ssize_t SignedQuantum;
#if defined(MAGICKCORE_HDRI_SUPPORT)
typedef MagickFloatType Quantum;
#define QuantumRange ((Quantum) 255.0)
#define QuantumFormat "%g"
#else
typedef unsigned char Quantum;
#define QuantumRange ((Quantum) 255)
#define QuantumFormat "%u"
#endif
#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
#define MaxColormapSize 65536UL
#define MaxMap 65535UL
typedef ssize_t SignedQuantum;
#if defined(MAGICKCORE_HDRI_SUPPORT)
typedef MagickFloatType Quantum;
#define QuantumRange ((Quantum) 65535.0)
#define QuantumFormat "%g"
#else
typedef unsigned short Quantum;
#define QuantumRange ((Quantum) 65535)
#define QuantumFormat "%u"
#endif
#elif (MAGICKCORE_QUANTUM_DEPTH == 32)
#define MaxColormapSize 65536UL
#define MaxMap 65535UL
typedef MagickDoubleType SignedQuantum;
#if defined(MAGICKCORE_HDRI_SUPPORT)
typedef MagickDoubleType Quantum;
#define QuantumRange ((Quantum) 4294967295.0)
#define QuantumFormat "%g"
#else
typedef unsigned int Quantum;
#define QuantumRange ((Quantum) 4294967295)
#define QuantumFormat "%u"
#endif
#elif (MAGICKCORE_QUANTUM_DEPTH == 64)
#define MAGICKCORE_HDRI_SUPPORT 1
#define MaxColormapSize 65536UL
#define MaxMap 65535UL
typedef MagickDoubleType SignedQuantum;
typedef MagickDoubleType Quantum;
#define QuantumRange ((Quantum) 18446744073709551615.0)
#define QuantumFormat "%g"
#else
#if !defined(_CH_)
# error "MAGICKCORE_QUANTUM_DEPTH must be one of 8, 16, 32, or 64"
#endif
#endif
#define MagickEpsilon (1.0e-12)
#define MagickMaximumValue 1.79769313486231570E+308
#define MagickMinimumValue 2.22507385850720140E-308
#define MagickStringify(macro_or_string) MagickStringifyArg(macro_or_string)
#define MagickStringifyArg(contents) #contents
#define QuantumScale ((double) 1.0/(double) QuantumRange)
/*
Typedef declarations.
*/
typedef MagickDoubleType MagickRealType;
typedef unsigned int MagickStatusType;
#if !defined(MAGICKCORE_WINDOWS_SUPPORT)
#if (MAGICKCORE_SIZEOF_UNSIGNED_LONG_LONG == 8)
typedef long long MagickOffsetType;
typedef unsigned long long MagickSizeType;
#define MagickOffsetFormat "lld"
#define MagickSizeFormat "llu"
#else
typedef ssize_t MagickOffsetType;
typedef size_t MagickSizeType;
#define MagickOffsetFormat "ld"
#define MagickSizeFormat "lu"
#endif
#else
typedef __int64 MagickOffsetType;
typedef unsigned __int64 MagickSizeType;
#define MagickOffsetFormat "I64i"
#define MagickSizeFormat "I64u"
#endif
#if defined(MAGICKCORE_HAVE_UINTPTR_T) || defined(uintptr_t)
typedef uintptr_t MagickAddressType;
#else
/* Hope for the best, I guess. */
typedef size_t MagickAddressType;
#endif
#if defined(_MSC_VER) && (_MSC_VER == 1200)
typedef MagickOffsetType QuantumAny;
#else
typedef MagickSizeType QuantumAny;
#endif
#if defined(macintosh)
#define ExceptionInfo MagickExceptionInfo
#endif
typedef enum
{
UndefinedChannel,
RedChannel = 0x0001,
GrayChannel = 0x0001,
CyanChannel = 0x0001,
GreenChannel = 0x0002,
MagentaChannel = 0x0002,
BlueChannel = 0x0004,
YellowChannel = 0x0004,
AlphaChannel = 0x0008,
OpacityChannel = 0x0008,
MatteChannel = 0x0008, /* deprecated */
BlackChannel = 0x0020,
IndexChannel = 0x0020,
CompositeChannels = 0x002F,
AllChannels = 0x7ffffff,
/*
Special purpose channel types.
*/
TrueAlphaChannel = 0x0040, /* extract actual alpha channel from opacity */
RGBChannels = 0x0080, /* set alpha from grayscale mask in RGB */
GrayChannels = 0x0080,
SyncChannels = 0x0100, /* channels should be modified equally */
DefaultChannels = ((AllChannels | SyncChannels) &~ OpacityChannel)
} ChannelType;
typedef enum
{
UndefinedClass,
DirectClass,
PseudoClass
} ClassType;
typedef enum
{
MagickFalse = 0,
MagickTrue = 1
} MagickBooleanType;
/*
The IsNaN test is for special floating point numbers of value Nan (not a
number). NaN's are defined as part of the IEEE standard for floating point
number representation, and need to be watched out for. Morphology Kernels
often use these special numbers as neighbourhood masks.
The special property that two NaN's are never equal, even if they are from
the same variable allows you to test if a value is special NaN value.
The macros are thus is only true if the value given is NaN.
*/
#if defined(MAGICKCORE_HAVE_ISNAN) && !defined(__cplusplus) && !defined(c_plusplus)
# define IsNaN(a) isnan(a)
#elif defined(_MSC_VER) && (_MSC_VER >= 1310)
# include <float.h>
# define IsNaN(a) _isnan(a)
#else
# define IsNaN(a) ((a) != (a))
#endif
#if !defined(INFINITY)
# define INFINITY ((double) -logf(0f))
#endif
typedef struct _BlobInfo BlobInfo;
typedef struct _ExceptionInfo ExceptionInfo;
typedef struct _Image Image;
typedef struct _ImageInfo ImageInfo;
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/mime.h 0000644 00000002643 15051111170 0007074 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
The ImageMagick mime methods.
*/
#ifndef MAGICKCORE_MIME_H
#define MAGICKCORE_MIME_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _MimeInfo
MimeInfo;
extern MagickExport char
**GetMimeList(const char *,size_t *,ExceptionInfo *),
*MagickToMime(const char *);
extern MagickExport const char
*GetMimeDescription(const MimeInfo *),
*GetMimeType(const MimeInfo *);
extern MagickExport MagickBooleanType
ListMimeInfo(FILE *,ExceptionInfo *),
MimeComponentGenesis(void);
extern MagickExport const MimeInfo
*GetMimeInfo(const char *,const unsigned char *,const size_t,ExceptionInfo *),
**GetMimeInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport void
MimeComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/layer.h 0000644 00000004035 15051111170 0007256 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image layer methods.
*/
#ifndef MAGICKCORE_LAYER_H
#define MAGICKCORE_LAYER_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UnrecognizedDispose,
UndefinedDispose = 0,
NoneDispose = 1,
BackgroundDispose = 2,
PreviousDispose = 3
} DisposeType;
typedef enum
{
UndefinedLayer,
CoalesceLayer,
CompareAnyLayer,
CompareClearLayer,
CompareOverlayLayer,
DisposeLayer,
OptimizeLayer,
OptimizeImageLayer,
OptimizePlusLayer,
OptimizeTransLayer,
RemoveDupsLayer,
RemoveZeroLayer,
CompositeLayer,
MergeLayer,
FlattenLayer,
MosaicLayer,
TrimBoundsLayer
} ImageLayerMethod;
extern MagickExport Image
*CoalesceImages(const Image *,ExceptionInfo *),
*DisposeImages(const Image *,ExceptionInfo *),
*CompareImageLayers(const Image *,const ImageLayerMethod,ExceptionInfo *),
*DeconstructImages(const Image *,ExceptionInfo *),
*MergeImageLayers(Image *,const ImageLayerMethod,ExceptionInfo *),
*OptimizeImageLayers(const Image *,ExceptionInfo *),
*OptimizePlusImageLayers(const Image *,ExceptionInfo *);
extern MagickExport void
CompositeLayers(Image *,const CompositeOperator,Image *,const ssize_t,
const ssize_t,ExceptionInfo *),
OptimizeImageTransparency(const Image *,ExceptionInfo *),
RemoveDuplicateLayers(Image **,ExceptionInfo *),
RemoveZeroDelayLayers(Image **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/signature.h 0000644 00000001636 15051111170 0010147 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore digital signature methods.
*/
#ifndef MAGICKCORE_SIGNATURE_H
#define MAGICKCORE_SIGNATURE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
SignatureImage(Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/prepress.h 0000644 00000001626 15051111170 0010010 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore prepress methods.
*/
#ifndef MAGICKCORE_PREPRESS_H
#define MAGICKCORE_PREPRESS_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport double
GetImageTotalInkDensity(Image *image);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/geometry.h 0000644 00000010004 15051111170 0007766 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image geometry methods.
*/
#ifndef MAGICKCORE_GEOMETRY_H
#define MAGICKCORE_GEOMETRY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
#undef NoValue
NoValue = 0x0000,
#undef XValue
XValue = 0x0001,
XiValue = 0x0001,
#undef YValue
YValue = 0x0002,
PsiValue = 0x0002,
#undef WidthValue
WidthValue = 0x0004,
RhoValue = 0x0004,
#undef HeightValue
HeightValue = 0x0008,
SigmaValue = 0x0008,
ChiValue = 0x0010,
XiNegative = 0x0020,
#undef XNegative
XNegative = 0x0020,
PsiNegative = 0x0040,
#undef YNegative
YNegative = 0x0040,
ChiNegative = 0x0080,
PercentValue = 0x1000, /* '%' percentage of something */
AspectValue = 0x2000, /* '!' resize no-aspect - special use flag */
NormalizeValue = 0x2000, /* '!' ScaleKernelValue() in morphology.c */
LessValue = 0x4000, /* '<' resize smaller - special use flag */
GreaterValue = 0x8000, /* '>' resize larger - spacial use flag */
MinimumValue = 0x10000, /* '^' special handling needed */
CorrelateNormalizeValue = 0x10000, /* '^' see ScaleKernelValue() */
AreaValue = 0x20000, /* '@' resize to area - special use flag */
DecimalValue = 0x40000, /* '.' floating point numbers found */
SeparatorValue = 0x80000, /* 'x' separator found */
AspectRatioValue = 0x100000, /* '~' special handling needed */
AlphaValue = 0x200000, /* '/' alpha */
#undef AllValues
AllValues = 0x7fffffff
} GeometryFlags;
#if defined(ForgetGravity)
#undef ForgetGravity
#undef NorthWestGravity
#undef NorthGravity
#undef NorthEastGravity
#undef WestGravity
#undef CenterGravity
#undef EastGravity
#undef SouthWestGravity
#undef SouthGravity
#undef SouthEastGravity
#undef StaticGravity
#endif
typedef enum
{
UndefinedGravity,
ForgetGravity = 0,
NorthWestGravity = 1,
NorthGravity = 2,
NorthEastGravity = 3,
WestGravity = 4,
CenterGravity = 5,
EastGravity = 6,
SouthWestGravity = 7,
SouthGravity = 8,
SouthEastGravity = 9,
StaticGravity = 10
} GravityType;
typedef struct _AffineMatrix
{
double
sx,
rx,
ry,
sy,
tx,
ty;
} AffineMatrix;
typedef struct _GeometryInfo
{
double
rho,
sigma,
xi,
psi,
chi;
} GeometryInfo;
typedef struct _OffsetInfo
{
ssize_t
x,
y;
} OffsetInfo;
typedef struct _RectangleInfo
{
size_t
width,
height;
ssize_t
x,
y;
} RectangleInfo;
extern MagickExport char
*GetPageGeometry(const char *);
extern MagickExport MagickBooleanType
IsGeometry(const char *),
IsSceneGeometry(const char *,const MagickBooleanType);
extern MagickExport MagickStatusType
GetGeometry(const char *,ssize_t *,ssize_t *,size_t *,size_t *),
ParseAbsoluteGeometry(const char *,RectangleInfo *),
ParseAffineGeometry(const char *,AffineMatrix *,ExceptionInfo *),
ParseGeometry(const char *,GeometryInfo *),
ParseGravityGeometry(const Image *,const char *,RectangleInfo *,
ExceptionInfo *),
ParseMetaGeometry(const char *,ssize_t *,ssize_t *,size_t *,size_t *),
ParsePageGeometry(const Image *,const char *,RectangleInfo *,ExceptionInfo *),
ParseRegionGeometry(const Image *,const char *,RectangleInfo *,
ExceptionInfo *);
extern MagickExport void
GravityAdjustGeometry(const size_t,const size_t,const GravityType,
RectangleInfo *),
SetGeometry(const Image *,RectangleInfo *),
SetGeometryInfo(GeometryInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/channel.h 0000644 00000003267 15051111170 0007560 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image channel methods.
*/
#ifndef MAGICKCORE_CHANNEL_H
#define MAGICKCORE_CHANNEL_H
#include "magick/image.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedAlphaChannel,
ActivateAlphaChannel,
BackgroundAlphaChannel,
CopyAlphaChannel,
DeactivateAlphaChannel,
ExtractAlphaChannel,
OpaqueAlphaChannel,
ResetAlphaChannel, /* deprecated */
SetAlphaChannel,
ShapeAlphaChannel,
TransparentAlphaChannel,
FlattenAlphaChannel,
RemoveAlphaChannel,
AssociateAlphaChannel,
DisassociateAlphaChannel,
OffIfOpaqueAlphaChannel
} AlphaChannelType;
extern MagickExport Image
*CombineImages(const Image *,const ChannelType,ExceptionInfo *),
*SeparateImage(const Image *,const ChannelType,ExceptionInfo *),
*SeparateImages(const Image *,const ChannelType,ExceptionInfo *);
extern MagickExport MagickBooleanType
GetImageAlphaChannel(const Image *),
SeparateImageChannel(Image *,const ChannelType),
SetImageAlphaChannel(Image *,const AlphaChannelType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/image.h 0000644 00000025766 15051111170 0007242 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image methods.
*/
#ifndef MAGICKCORE_IMAGE_H
#define MAGICKCORE_IMAGE_H
#include "magick/color.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#define OpaqueOpacity ((Quantum) 0UL)
#define TransparentOpacity (QuantumRange)
typedef enum
{
UndefinedType,
BilevelType,
GrayscaleType,
GrayscaleMatteType,
PaletteType,
PaletteMatteType,
TrueColorType,
TrueColorMatteType,
ColorSeparationType,
ColorSeparationMatteType,
OptimizeType,
PaletteBilevelMatteType
} ImageType;
typedef enum
{
UndefinedInterlace,
NoInterlace,
LineInterlace,
PlaneInterlace,
PartitionInterlace,
GIFInterlace,
JPEGInterlace,
PNGInterlace
} InterlaceType;
typedef enum
{
UndefinedOrientation,
TopLeftOrientation,
TopRightOrientation,
BottomRightOrientation,
BottomLeftOrientation,
LeftTopOrientation,
RightTopOrientation,
RightBottomOrientation,
LeftBottomOrientation
} OrientationType;
typedef enum
{
UndefinedResolution,
PixelsPerInchResolution,
PixelsPerCentimeterResolution
} ResolutionType;
typedef struct _PrimaryInfo
{
double
x,
y,
z;
} PrimaryInfo;
typedef struct _SegmentInfo
{
double
x1,
y1,
x2,
y2;
} SegmentInfo;
typedef enum
{
UndefinedTransmitType,
FileTransmitType,
BlobTransmitType,
StreamTransmitType,
ImageTransmitType
} TransmitType;
typedef struct _ChromaticityInfo
{
PrimaryInfo
red_primary,
green_primary,
blue_primary,
white_point;
} ChromaticityInfo;
#include "magick/blob.h"
#include "magick/colorspace.h"
#include "magick/cache-view.h"
#include "magick/color.h"
#include "magick/composite.h"
#include "magick/compress.h"
#include "magick/effect.h"
#include "magick/geometry.h"
#include "magick/layer.h"
#include "magick/locale_.h"
#include "magick/monitor.h"
#include "magick/pixel.h"
#include "magick/profile.h"
#include "magick/quantum.h"
#include "magick/resample.h"
#include "magick/resize.h"
#include "magick/semaphore.h"
#include "magick/stream.h"
#include "magick/timer.h"
struct _Image
{
ClassType
storage_class;
ColorspaceType
colorspace; /* colorspace of image data */
CompressionType
compression; /* compression of image when read/write */
size_t
quality; /* compression quality setting, meaning varies */
OrientationType
orientation; /* photo orientation of image */
MagickBooleanType
taint, /* has image been modified since reading */
matte; /* is transparency channel defined and active */
size_t
columns, /* physical size of image */
rows,
depth, /* depth of image on read/write */
colors; /* size of color table on read */
PixelPacket
*colormap,
background_color, /* current background color attribute */
border_color, /* current bordercolor attribute */
matte_color; /* current mattecolor attribute */
double
gamma;
ChromaticityInfo
chromaticity;
RenderingIntent
rendering_intent;
void
*profiles;
ResolutionType
units; /* resolution/density ppi or ppc */
char
*montage,
*directory,
*geometry;
ssize_t
offset;
double
x_resolution, /* image resolution/density */
y_resolution;
RectangleInfo
page, /* virtual canvas size and offset of image */
extract_info,
tile_info; /* deprecated */
double
bias,
blur, /* deprecated */
fuzz; /* current color fuzz attribute */
FilterTypes
filter; /* resize/distort filter to apply */
InterlaceType
interlace;
EndianType
endian; /* raw data integer ordering on read/write */
GravityType
gravity; /* Gravity attribute for positioning in image */
CompositeOperator
compose; /* alpha composition method for layered images */
DisposeType
dispose; /* GIF animation disposal method */
struct _Image
*clip_mask;
size_t
scene, /* index of image in multi-image file */
delay; /* Animation delay time */
ssize_t
ticks_per_second; /* units for delay time, default 100 for GIF */
size_t
iterations,
total_colors;
ssize_t
start_loop;
ErrorInfo
error;
TimerInfo
timer;
MagickProgressMonitor
progress_monitor;
void
*client_data,
*cache,
*attributes; /* deprecated */
Ascii85Info
*ascii85;
BlobInfo
*blob;
char
filename[MaxTextExtent], /* images input filename */
magick_filename[MaxTextExtent], /* ditto with coders, and read_mods */
magick[MaxTextExtent]; /* Coder used to decode image */
size_t
magick_columns,
magick_rows;
ExceptionInfo
exception; /* Error handling report */
MagickBooleanType
debug; /* debug output attribute */
ssize_t
reference_count;
SemaphoreInfo
*semaphore;
ProfileInfo
color_profile,
iptc_profile,
*generic_profile;
size_t
generic_profiles; /* this & ProfileInfo is deprecated */
size_t
signature;
struct _Image
*previous, /* Image list links */
*list, /* Undo/Redo image processing list (for display) */
*next; /* Image list links */
InterpolatePixelMethod
interpolate; /* Interpolation of color for between pixel lookups */
MagickBooleanType
black_point_compensation;
PixelPacket
transparent_color; /* color for 'transparent' color index in GIF */
struct _Image
*mask;
RectangleInfo
tile_offset;
void
*properties, /* per image properities */
*artifacts; /* per image sequence image artifacts */
ImageType
type;
MagickBooleanType
dither; /* dithering method during color reduction */
MagickSizeType
extent;
MagickBooleanType
ping;
size_t
channels;
time_t
timestamp;
PixelIntensityMethod
intensity; /* method to generate an intensity value from a pixel */
size_t
duration; /* Total animation duration sum(delay*iterations) */
long
tietz_offset;
time_t
ttl;
};
struct _ImageInfo
{
CompressionType
compression;
OrientationType
orientation;
MagickBooleanType
temporary,
adjoin,
affirm,
antialias;
char
*size,
*extract,
*page,
*scenes;
size_t
scene,
number_scenes,
depth;
InterlaceType
interlace;
EndianType
endian;
ResolutionType
units;
size_t
quality;
char
*sampling_factor, /* Chroma subsampling ratio string */
*server_name,
*font,
*texture,
*density;
double
pointsize,
fuzz;
PixelPacket
background_color,
border_color,
matte_color;
MagickBooleanType
dither,
monochrome;
size_t
colors;
ColorspaceType
colorspace;
ImageType
type;
PreviewType
preview_type;
ssize_t
group;
MagickBooleanType
ping,
verbose;
char
*view,
*authenticate;
ChannelType
channel;
Image
*attributes; /* deprecated */
void
*options;
MagickProgressMonitor
progress_monitor;
void
*client_data,
*cache;
StreamHandler
stream;
FILE
*file;
void
*blob;
size_t
length;
char
magick[MaxTextExtent],
unique[MaxTextExtent],
zero[MaxTextExtent],
filename[MaxTextExtent];
MagickBooleanType
debug;
char
*tile; /* deprecated */
size_t
subimage, /* deprecated */
subrange; /* deprecated */
PixelPacket
pen; /* deprecated */
size_t
signature;
VirtualPixelMethod
virtual_pixel_method;
PixelPacket
transparent_color;
void
*profile;
MagickBooleanType
synchronize;
};
extern MagickExport ExceptionType
CatchImageException(Image *);
extern MagickExport FILE
*GetImageInfoFile(const ImageInfo *);
extern MagickExport Image
*AcquireImage(const ImageInfo *),
*AppendImages(const Image *,const MagickBooleanType,ExceptionInfo *),
*CloneImage(const Image *,const size_t,const size_t,const MagickBooleanType,
ExceptionInfo *),
*DestroyImage(Image *),
*GetImageClipMask(const Image *,ExceptionInfo *) magick_attribute((__pure__)),
*GetImageMask(const Image *,ExceptionInfo *) magick_attribute((__pure__)),
*NewMagickImage(const ImageInfo *,const size_t,const size_t,
const MagickPixelPacket *),
*ReferenceImage(Image *),
*SmushImages(const Image *,const MagickBooleanType,const ssize_t,
ExceptionInfo *);
extern MagickExport ImageInfo
*AcquireImageInfo(void),
*CloneImageInfo(const ImageInfo *),
*DestroyImageInfo(ImageInfo *);
extern MagickExport MagickBooleanType
ClipImage(Image *),
ClipImagePath(Image *,const char *,const MagickBooleanType),
CopyImagePixels(Image *,const Image *,const RectangleInfo *,
const OffsetInfo *,ExceptionInfo *),
IsTaintImage(const Image *),
IsMagickConflict(const char *) magick_attribute((__pure__)),
IsHighDynamicRangeImage(const Image *,ExceptionInfo *),
IsImageObject(const Image *),
ListMagickInfo(FILE *,ExceptionInfo *),
ModifyImage(Image **,ExceptionInfo *),
ResetImagePage(Image *,const char *),
ResetImagePixels(Image *,ExceptionInfo *),
SetImageBackgroundColor(Image *),
SetImageClipMask(Image *,const Image *),
SetImageColor(Image *,const MagickPixelPacket *),
SetImageExtent(Image *,const size_t,const size_t),
SetImageInfo(ImageInfo *,const unsigned int,ExceptionInfo *),
SetImageMask(Image *,const Image *),
SetImageOpacity(Image *,const Quantum),
SetImageChannels(Image *,const size_t),
SetImageStorageClass(Image *,const ClassType),
StripImage(Image *),
SyncImage(Image *),
SyncImageSettings(const ImageInfo *,Image *),
SyncImagesSettings(ImageInfo *,Image *);
extern MagickExport size_t
InterpretImageFilename(const ImageInfo *,Image *,const char *,int,char *);
extern MagickExport ssize_t
GetImageReferenceCount(Image *);
extern MagickExport size_t
GetImageChannels(Image *);
extern MagickExport VirtualPixelMethod
GetImageVirtualPixelMethod(const Image *),
SetImageVirtualPixelMethod(const Image *,const VirtualPixelMethod);
extern MagickExport void
AcquireNextImage(const ImageInfo *,Image *),
DestroyImagePixels(Image *),
DisassociateImageStream(Image *),
GetImageException(Image *,ExceptionInfo *),
GetImageInfo(ImageInfo *),
SetImageInfoBlob(ImageInfo *,const void *,const size_t),
SetImageInfoFile(ImageInfo *,FILE *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/magick-config.h 0000644 00000000303 15051111170 0010632 0 ustar 00 #include <bits/wordsize.h>
#if __WORDSIZE == 32
# include "magick-config-32.h"
#elif __WORDSIZE == 64
# include "magick-config-64.h"
#else
# error "unexpected value for __WORDSIZE macro"
#endif
magick/statistic.h 0000644 00000011563 15051111170 0010155 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore statistical methods.
*/
#ifndef MAGICKCORE_STATISTIC_H
#define MAGICKCORE_STATISTIC_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#include "magick/draw.h"
#define MaximumNumberOfImageMoments 8
#define MaximumNumberOfPerceptualHashes 7
typedef struct _ChannelStatistics
{
size_t
depth;
double
minima,
maxima,
sum,
sum_squared,
sum_cubed,
sum_fourth_power,
mean,
variance,
standard_deviation,
kurtosis,
skewness,
entropy;
} ChannelStatistics;
#undef I
typedef struct _ChannelMoments
{
double
I[32];
PointInfo
centroid,
ellipse_axis;
double
ellipse_angle,
ellipse_eccentricity,
ellipse_intensity;
} ChannelMoments;
typedef struct _ChannelPerceptualHash
{
double
P[32],
Q[32];
} ChannelPerceptualHash;
typedef enum
{
UndefinedEvaluateOperator,
AddEvaluateOperator,
AndEvaluateOperator,
DivideEvaluateOperator,
LeftShiftEvaluateOperator,
MaxEvaluateOperator,
MinEvaluateOperator,
MultiplyEvaluateOperator,
OrEvaluateOperator,
RightShiftEvaluateOperator,
SetEvaluateOperator,
SubtractEvaluateOperator,
XorEvaluateOperator,
PowEvaluateOperator,
LogEvaluateOperator,
ThresholdEvaluateOperator,
ThresholdBlackEvaluateOperator,
ThresholdWhiteEvaluateOperator,
GaussianNoiseEvaluateOperator,
ImpulseNoiseEvaluateOperator,
LaplacianNoiseEvaluateOperator,
MultiplicativeNoiseEvaluateOperator,
PoissonNoiseEvaluateOperator,
UniformNoiseEvaluateOperator,
CosineEvaluateOperator,
SineEvaluateOperator,
AddModulusEvaluateOperator,
MeanEvaluateOperator,
AbsEvaluateOperator,
ExponentialEvaluateOperator,
MedianEvaluateOperator,
SumEvaluateOperator,
RootMeanSquareEvaluateOperator,
InverseLogEvaluateOperator
} MagickEvaluateOperator;
typedef enum
{
UndefinedFunction,
PolynomialFunction,
SinusoidFunction,
ArcsinFunction,
ArctanFunction
} MagickFunction;
typedef enum
{
UndefinedStatistic,
GradientStatistic,
MaximumStatistic,
MeanStatistic,
MedianStatistic,
MinimumStatistic,
ModeStatistic,
NonpeakStatistic,
StandardDeviationStatistic,
RootMeanSquareStatistic
} StatisticType;
extern MagickExport ChannelStatistics
*GetImageChannelStatistics(const Image *,ExceptionInfo *);
extern MagickExport ChannelMoments
*GetImageChannelMoments(const Image *,ExceptionInfo *);
extern MagickExport ChannelPerceptualHash
*GetImageChannelPerceptualHash(const Image *,ExceptionInfo *);
extern MagickExport Image
*EvaluateImages(const Image *,const MagickEvaluateOperator,ExceptionInfo *),
*PolynomialImage(const Image *,const size_t,const double *,ExceptionInfo *),
*PolynomialImageChannel(const Image *,const ChannelType,const size_t,
const double *,ExceptionInfo *),
*StatisticImage(const Image *,const StatisticType,const size_t,const size_t,
ExceptionInfo *),
*StatisticImageChannel(const Image *,const ChannelType,const StatisticType,
const size_t,const size_t,ExceptionInfo *);
extern MagickExport MagickBooleanType
EvaluateImage(Image *,const MagickEvaluateOperator,const double,
ExceptionInfo *),
EvaluateImageChannel(Image *,const ChannelType,const MagickEvaluateOperator,
const double,ExceptionInfo *),
FunctionImage(Image *,const MagickFunction,const size_t,const double *,
ExceptionInfo *),
FunctionImageChannel(Image *,const ChannelType,const MagickFunction,
const size_t,const double *,ExceptionInfo *),
GetImageChannelEntropy(const Image *,const ChannelType,double *,
ExceptionInfo *),
GetImageChannelExtrema(const Image *,const ChannelType,size_t *,size_t *,
ExceptionInfo *),
GetImageChannelMean(const Image *,const ChannelType,double *,double *,
ExceptionInfo *),
GetImageChannelKurtosis(const Image *,const ChannelType,double *,double *,
ExceptionInfo *),
GetImageChannelRange(const Image *,const ChannelType,double *,double *,
ExceptionInfo *),
GetImageEntropy(const Image *,double *,ExceptionInfo *),
GetImageExtrema(const Image *,size_t *,size_t *,ExceptionInfo *),
GetImageMean(const Image *,double *,double *,ExceptionInfo *),
GetImageKurtosis(const Image *,double *,double *,ExceptionInfo *),
GetImageRange(const Image *,double *,double *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/utility.h 0000644 00000003642 15051111170 0007650 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore utility methods.
*/
#ifndef MAGICKCORE_UTILITY_H
#define MAGICKCORE_UTILITY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedPath,
MagickPath,
RootPath,
HeadPath,
TailPath,
BasePath,
ExtensionPath,
SubimagePath,
CanonicalPath,
SubcanonicalPath,
BasePathSansCompressExtension
} PathType;
extern MagickExport char
*Base64Encode(const unsigned char *,const size_t,size_t *),
**GetPathComponents(const char *,size_t *),
**ListFiles(const char *,const char *,size_t *);
extern MagickExport MagickBooleanType
AcquireUniqueFilename(char *),
AcquireUniqueSymbolicLink(const char *,char *),
ExpandFilenames(int *,char ***),
GetPathAttributes(const char *,void *),
GetExecutionPath(char *,const size_t),
IsPathAccessible(const char *);
extern MagickExport size_t
MultilineCensus(const char *) magick_attribute((__pure__));
extern MagickExport ssize_t
GetMagickPageSize(void);
extern MagickExport unsigned char
*Base64Decode(const char *, size_t *);
extern MagickExport void
AppendImageFormat(const char *,char *),
ChopPathComponents(char *,const size_t),
ExpandFilename(char *),
GetPathComponent(const char *,PathType,char *),
MagickDelay(const MagickSizeType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/shear.h 0000644 00000002155 15051111170 0007245 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image stream methods.
*/
#ifndef MAGICKCORE_SHEAR_H
#define MAGICKCORE_SHEAR_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport Image
*DeskewImage(const Image *,const double,ExceptionInfo *),
*IntegralRotateImage(const Image *,size_t,ExceptionInfo *),
*ShearImage(const Image *,const double,const double,ExceptionInfo *),
*ShearRotateImage(const Image *,const double,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/log.h 0000644 00000005303 15051111170 0006722 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore log methods.
*/
#ifndef MAGICKCORE_LOG_H
#define MAGICKCORE_LOG_H
#include <stdarg.h>
#include "magick/exception.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if !defined(GetMagickModule)
# define GetMagickModule() __FILE__,__func__,(unsigned long) __LINE__
#endif
#define MagickLogFilename "log.xml"
typedef enum
{
UndefinedEvents,
NoEvents = 0x00000,
TraceEvent = 0x00001,
AnnotateEvent = 0x00002,
BlobEvent = 0x00004,
CacheEvent = 0x00008,
CoderEvent = 0x00010,
ConfigureEvent = 0x00020,
DeprecateEvent = 0x00040,
DrawEvent = 0x00080,
ExceptionEvent = 0x00100,
ImageEvent = 0x00200,
LocaleEvent = 0x00400,
ModuleEvent = 0x00800,
PolicyEvent = 0x01000,
ResourceEvent = 0x02000,
TransformEvent = 0x04000,
UserEvent = 0x09000,
WandEvent = 0x10000,
X11Event = 0x20000,
AccelerateEvent = 0x40000,
AllEvents = 0x7fffffff
} LogEventType;
typedef struct _LogInfo
LogInfo;
typedef void
(*MagickLogMethod)(const LogEventType,const char *);
extern const MagickExport LogInfo
**GetLogInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport char
**GetLogList(const char *,size_t *,ExceptionInfo *);
extern MagickExport char
*GetLogName(void) magick_attribute((__pure__)),
*SetLogName(const char *);
extern MagickExport LogEventType
GetLogEventMask(void) magick_attribute((__pure__));
extern MagickExport LogEventType
SetLogEventMask(const char *);
extern MagickExport MagickBooleanType
IsEventLogging(void) magick_attribute((__pure__)),
ListLogInfo(FILE *,ExceptionInfo *),
LogComponentGenesis(void),
LogMagickEvent(const LogEventType,const char *,const char *,const size_t,
const char *,...) magick_attribute((__format__ (__printf__,5,6))),
LogMagickEventList(const LogEventType,const char *,const char *,const size_t,
const char *,va_list) magick_attribute((__format__ (__printf__,5,0)));
extern MagickExport void
CloseMagickLog(void),
LogComponentTerminus(void),
SetLogFormat(const char *),
SetLogMethod(MagickLogMethod);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/widget.h 0000644 00000005103 15051111170 0007422 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore X11 widget methods.
*/
#ifndef MAGICKCORE_WIDGET_H
#define MAGICKCORE_WIDGET_H
#if defined(MAGICKCORE_X11_DELEGATE)
#include "magick/xwindow-private.h"
#endif
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if defined(MAGICKCORE_X11_DELEGATE)
extern MagickExport int
XCommandWidget(Display *,XWindows *,const char *const *,XEvent *),
XConfirmWidget(Display *,XWindows *,const char *,const char *),
XDialogWidget(Display *,XWindows *,const char *,const char *,char *),
XMenuWidget(Display *,XWindows *,const char *,const char *const *,char *);
extern MagickExport MagickBooleanType
XPreferencesWidget(Display *,XResourceInfo *,XWindows *);
extern MagickExport void
DestroyXWidget(void),
XColorBrowserWidget(Display *,XWindows *,const char *,char *),
XFileBrowserWidget(Display *,XWindows *,const char *,char *),
XFontBrowserWidget(Display *,XWindows *,const char *,char *),
XInfoWidget(Display *,XWindows *,const char *),
XListBrowserWidget(Display *,XWindows *,XWindowInfo *,const char *const *,
const char *,const char *,char *),
XNoticeWidget(Display *,XWindows *,const char *,const char *),
XProgressMonitorWidget(Display *,XWindows *,const char *,
const MagickOffsetType,const MagickSizeType),
XTextViewWidget(Display *,const XResourceInfo *,XWindows *,
const MagickBooleanType,const char *,const char **);
static inline void XTextViewHelp(Display *display,
const XResourceInfo *resource_info,XWindows *windows,
const MagickBooleanType mono,const char *title,const char *help)
{
char
**help_list;
ssize_t
i;
help_list=StringToList(help);
if (help_list == (char **) NULL)
return;
XTextViewWidget(display,resource_info,windows,mono,title,(const char **)
help_list);
for (i=0; help_list[i] != (char *) NULL; i++)
help_list[i]=DestroyString(help_list[i]);
help_list=(char **) RelinquishMagickMemory(help_list);
}
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/xml-tree.h 0000644 00000004126 15051111170 0007700 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Magick's toolkit xml-tree methods.
*/
#ifndef MAGICKCORE_XML_TREE_H
#define MAGICKCORE_XML_TREE_H
#include "magick/exception.h"
#include "magick/splay-tree.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _XMLTreeInfo
XMLTreeInfo;
extern MagickExport char
*CanonicalXMLContent(const char *,const MagickBooleanType),
*XMLTreeInfoToXML(XMLTreeInfo *);
extern MagickExport const char
*GetXMLTreeAttribute(XMLTreeInfo *,const char *),
*GetXMLTreeContent(XMLTreeInfo *),
**GetXMLTreeProcessingInstructions(XMLTreeInfo *,const char *),
*GetXMLTreeTag(XMLTreeInfo *);
extern MagickExport MagickBooleanType
GetXMLTreeAttributes(const XMLTreeInfo *,SplayTreeInfo *);
extern MagickExport XMLTreeInfo
*AddChildToXMLTree(XMLTreeInfo *,const char *,const size_t),
*AddPathToXMLTree(XMLTreeInfo *,const char *,const size_t),
*DestroyXMLTree(XMLTreeInfo *),
*GetNextXMLTreeTag(XMLTreeInfo *),
*GetXMLTreeChild(XMLTreeInfo *,const char *),
*GetXMLTreeOrdered(XMLTreeInfo *),
*GetXMLTreePath(XMLTreeInfo *,const char *),
*GetXMLTreeSibling(XMLTreeInfo *),
*InsertTagIntoXMLTree(XMLTreeInfo *,XMLTreeInfo *,const size_t),
*NewXMLTree(const char *,ExceptionInfo *),
*NewXMLTreeTag(const char *),
*ParseTagFromXMLTree(XMLTreeInfo *),
*PruneTagFromXMLTree(XMLTreeInfo *),
*SetXMLTreeAttribute(XMLTreeInfo *,const char *,const char *),
*SetXMLTreeContent(XMLTreeInfo *,const char *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/distribute-cache.h 0000644 00000001734 15051111170 0011364 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore distributed cache methods.
*/
#ifndef MAGICKCORE_DISTRIBUTE_CACHE_H
#define MAGICKCORE_DISTRIBUTE_CACHE_H
#include "magick/exception.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport void
DistributePixelCacheServer(const int,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/registry.h 0000644 00000002740 15051111170 0010013 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore registry methods.
*/
#ifndef MAGICKCORE_REGISTRY_H
#define MAGICKCORE_REGISTRY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedRegistryType,
ImageRegistryType,
ImageInfoRegistryType,
StringRegistryType
} RegistryType;
extern MagickExport char
*GetNextImageRegistry(void);
extern MagickExport MagickBooleanType
DefineImageRegistry(const RegistryType,const char *,ExceptionInfo *),
DeleteImageRegistry(const char *),
RegistryComponentGenesis(void),
SetImageRegistry(const RegistryType,const char *,const void *,
ExceptionInfo *);
extern MagickExport void
*GetImageRegistry(const RegistryType,const char *,ExceptionInfo *),
RegistryComponentTerminus(void),
*RemoveImageRegistry(const char *),
ResetImageRegistryIterator(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/methods.h 0000644 00000330005 15051111170 0007604 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore API methods prefix.
nm -p magick/.libs/libMagickCore-6.Q16.a | grep ' T ' | \
egrep -v '(MagickError)|(MagickFatalError)|(MagickWarning)|(ThrowException)' | \
awk '{ printf("#define %s PrependMagickMethod(%s)\n", $3, $3); }' | sort
*/
#ifndef MAGICKCORE_METHOD_H
#define MAGICKCORE_METHOD_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if defined(MAGICKCORE_NAMESPACE_PREFIX)
#if defined(__STDC__)
#define PrescanMagickPrefix(prefix,method) prefix ## method
#else
#define PrescanMagickPrefix(prefix,method) prefix(method)
#endif
#define EvaluateMagickPrefix(prefix,method) PrescanMagickPrefix(prefix,method)
#define PrependMagickMethod(method) \
EvaluateMagickPrefix(MAGICKCORE_NAMESPACE_PREFIX,method)
#define AcquireAlignedMemory PrependMagickMethod(AcquireAlignedMemory)
#define AcquireAuthenticCacheView PrependMagickMethod(AcquireAuthenticCacheView)
#define AcquireCacheViewIndexes PrependMagickMethod(AcquireCacheViewIndexes)
#define AcquireCacheViewPixels PrependMagickMethod(AcquireCacheViewPixels)
#define AcquireCacheView PrependMagickMethod(AcquireCacheView)
#define AcquireCriticalMemory PrependMagickMethod(AcquireCriticalMemory)
#define AcquireDistributeCacheInfo PrependMagickMethod(AcquireDistributeCacheInfo)
#define AcquireDrawInfo PrependMagickMethod(AcquireDrawInfo)
#define AcquireExceptionInfo PrependMagickMethod(AcquireExceptionInfo)
#define AcquireFxInfo PrependMagickMethod(AcquireFxInfo)
#define AcquireImageColormap PrependMagickMethod(AcquireImageColormap)
#define AcquireImageInfo PrependMagickMethod(AcquireImageInfo)
#define AcquireImagePixels PrependMagickMethod(AcquireImagePixels)
#define AcquireImage PrependMagickMethod(AcquireImage)
#define AcquireIndexes PrependMagickMethod(AcquireIndexes)
#define AcquireKernelBuiltIn PrependMagickMethod(AcquireKernelBuiltIn)
#define AcquireKernelInfo PrependMagickMethod(AcquireKernelInfo)
#define AcquireMagickMatrix PrependMagickMethod(AcquireMagickMatrix)
#define AcquireMagickMemory PrependMagickMethod(AcquireMagickMemory)
#define AcquireMagickResource PrependMagickMethod(AcquireMagickResource)
#define AcquireMatrixInfo PrependMagickMethod(AcquireMatrixInfo)
#define AcquireMemory PrependMagickMethod(AcquireMemory)
#define AcquireNextImage PrependMagickMethod(AcquireNextImage)
#define AcquireOneCacheViewPixel PrependMagickMethod(AcquireOneCacheViewPixel)
#define AcquireOneCacheViewVirtualPixel PrependMagickMethod(AcquireOneCacheViewVirtualPixel)
#define AcquireOneMagickPixel PrependMagickMethod(AcquireOneMagickPixel)
#define AcquireOnePixel PrependMagickMethod(AcquireOnePixel)
#define AcquireOneVirtualPixel PrependMagickMethod(AcquireOneVirtualPixel)
#define AcquirePixelCacheNexus PrependMagickMethod(AcquirePixelCacheNexus)
#define AcquirePixelCachePixels PrependMagickMethod(AcquirePixelCachePixels)
#define AcquirePixelCache PrependMagickMethod(AcquirePixelCache)
#define AcquirePixels PrependMagickMethod(AcquirePixels)
#define AcquireQuantizeInfo PrependMagickMethod(AcquireQuantizeInfo)
#define AcquireQuantumInfo PrependMagickMethod(AcquireQuantumInfo)
#define AcquireQuantumMemory PrependMagickMethod(AcquireQuantumMemory)
#define AcquireRandomInfo PrependMagickMethod(AcquireRandomInfo)
#define AcquireResampleFilter PrependMagickMethod(AcquireResampleFilter)
#define AcquireResizeFilter PrependMagickMethod(AcquireResizeFilter)
#define AcquireSemaphoreInfo PrependMagickMethod(AcquireSemaphoreInfo)
#define AcquireSignatureInfo PrependMagickMethod(AcquireSignatureInfo)
#define AcquireStreamInfo PrependMagickMethod(AcquireStreamInfo)
#define AcquireStringInfo PrependMagickMethod(AcquireStringInfo)
#define AcquireString PrependMagickMethod(AcquireString)
#define AcquireTimerInfo PrependMagickMethod(AcquireTimerInfo)
#define AcquireTokenInfo PrependMagickMethod(AcquireTokenInfo)
#define AcquireUniqueFilename PrependMagickMethod(AcquireUniqueFilename)
#define AcquireUniqueFileResource PrependMagickMethod(AcquireUniqueFileResource)
#define AcquireUniqueSymbolicLink PrependMagickMethod(AcquireUniqueSymbolicLink)
#define AcquireVirtualCacheView PrependMagickMethod(AcquireVirtualCacheView)
#define AcquireVirtualMemory PrependMagickMethod(AcquireVirtualMemory)
#define ActivateSemaphoreInfo PrependMagickMethod(ActivateSemaphoreInfo)
#define AdaptiveBlurImageChannel PrependMagickMethod(AdaptiveBlurImageChannel)
#define AdaptiveBlurImage PrependMagickMethod(AdaptiveBlurImage)
#define AdaptiveResizeImage PrependMagickMethod(AdaptiveResizeImage)
#define AdaptiveSharpenImageChannel PrependMagickMethod(AdaptiveSharpenImageChannel)
#define AdaptiveSharpenImage PrependMagickMethod(AdaptiveSharpenImage)
#define AdaptiveThresholdImage PrependMagickMethod(AdaptiveThresholdImage)
#define AddChildToXMLTree PrependMagickMethod(AddChildToXMLTree)
#define AddNoiseImageChannel PrependMagickMethod(AddNoiseImageChannel)
#define AddNoiseImage PrependMagickMethod(AddNoiseImage)
#define AddPathToXMLTree PrependMagickMethod(AddPathToXMLTree)
#define AddValueToSplayTree PrependMagickMethod(AddValueToSplayTree)
#define AffineTransformImage PrependMagickMethod(AffineTransformImage)
#define AffinityImage PrependMagickMethod(AffinityImage)
#define AffinityImages PrependMagickMethod(AffinityImages)
#define AllocateImageColormap PrependMagickMethod(AllocateImageColormap)
#define AllocateImage PrependMagickMethod(AllocateImage)
#define AllocateNextImage PrependMagickMethod(AllocateNextImage)
#define AllocateSemaphoreInfo PrependMagickMethod(AllocateSemaphoreInfo)
#define AllocateString PrependMagickMethod(AllocateString)
#define analyzeImage PrependMagickMethod(analyzeImage)
#define AnimateImages PrependMagickMethod(AnimateImages)
#define AnnotateComponentGenesis PrependMagickMethod(AnnotateComponentGenesis)
#define AnnotateComponentTerminus PrependMagickMethod(AnnotateComponentTerminus)
#define AnnotateImage PrependMagickMethod(AnnotateImage)
#define AppendImageFormat PrependMagickMethod(AppendImageFormat)
#define AppendImages PrependMagickMethod(AppendImages)
#define AppendImageToList PrependMagickMethod(AppendImageToList)
#define AppendValueToLinkedList PrependMagickMethod(AppendValueToLinkedList)
#define Ascii85Encode PrependMagickMethod(Ascii85Encode)
#define Ascii85Flush PrependMagickMethod(Ascii85Flush)
#define Ascii85Initialize PrependMagickMethod(Ascii85Initialize)
#define AsynchronousResourceComponentTerminus PrependMagickMethod(AsynchronousResourceComponentTerminus)
#define AttachBlob PrependMagickMethod(AttachBlob)
#define AutoGammaImageChannel PrependMagickMethod(AutoGammaImageChannel)
#define AutoGammaImage PrependMagickMethod(AutoGammaImage)
#define AutoLevelImageChannel PrependMagickMethod(AutoLevelImageChannel)
#define AutoLevelImage PrependMagickMethod(AutoLevelImage)
#define AutoOrientImage PrependMagickMethod(AutoOrientImage)
#define AutoThresholdImage PrependMagickMethod(AutoThresholdImage)
#define AverageImages PrependMagickMethod(AverageImages)
#define Base64Decode PrependMagickMethod(Base64Decode)
#define Base64Encode PrependMagickMethod(Base64Encode)
#define BilevelImageChannel PrependMagickMethod(BilevelImageChannel)
#define BilevelImage PrependMagickMethod(BilevelImage)
#define BlackThresholdImageChannel PrependMagickMethod(BlackThresholdImageChannel)
#define BlackThresholdImage PrependMagickMethod(BlackThresholdImage)
#define BlobToFile PrependMagickMethod(BlobToFile)
#define BlobToImage PrependMagickMethod(BlobToImage)
#define BlobToStringInfo PrependMagickMethod(BlobToStringInfo)
#define BlueShiftImage PrependMagickMethod(BlueShiftImage)
#define BlurImageChannel PrependMagickMethod(BlurImageChannel)
#define BlurImage PrependMagickMethod(BlurImage)
#define BorderImage PrependMagickMethod(BorderImage)
#define BrightnessContrastImageChannel PrependMagickMethod(BrightnessContrastImageChannel)
#define BrightnessContrastImage PrependMagickMethod(BrightnessContrastImage)
#define CacheComponentGenesis PrependMagickMethod(CacheComponentGenesis)
#define CacheComponentTerminus PrependMagickMethod(CacheComponentTerminus)
#define CannyEdgeImage PrependMagickMethod(CannyEdgeImage)
#define CanonicalXMLContent PrependMagickMethod(CanonicalXMLContent)
#define CatchException PrependMagickMethod(CatchException)
#define CatchImageException PrependMagickMethod(CatchImageException)
#define ChannelImage PrependMagickMethod(ChannelImage)
#define ChannelThresholdImage PrependMagickMethod(ChannelThresholdImage)
#define CharcoalImage PrependMagickMethod(CharcoalImage)
#define ChopImage PrependMagickMethod(ChopImage)
#define ChopPathComponents PrependMagickMethod(ChopPathComponents)
#define ClampImageChannel PrependMagickMethod(ClampImageChannel)
#define ClampImage PrependMagickMethod(ClampImage)
#define ClearExceptionInfo PrependMagickMethod(ClearExceptionInfo)
#define ClearLinkedList PrependMagickMethod(ClearLinkedList)
#define ClearMagickException PrependMagickMethod(ClearMagickException)
#define ClipImagePath PrependMagickMethod(ClipImagePath)
#define ClipImage PrependMagickMethod(ClipImage)
#define ClipPathImage PrependMagickMethod(ClipPathImage)
#define CloneBlobInfo PrependMagickMethod(CloneBlobInfo)
#define CloneCacheView PrependMagickMethod(CloneCacheView)
#define CloneDrawInfo PrependMagickMethod(CloneDrawInfo)
#define CloneExceptionInfo PrependMagickMethod(CloneExceptionInfo)
#define CloneImageArtifacts PrependMagickMethod(CloneImageArtifacts)
#define CloneImageAttributes PrependMagickMethod(CloneImageAttributes)
#define CloneImageInfo PrependMagickMethod(CloneImageInfo)
#define CloneImageList PrependMagickMethod(CloneImageList)
#define CloneImageOptions PrependMagickMethod(CloneImageOptions)
#define CloneImage PrependMagickMethod(CloneImage)
#define CloneImageProfiles PrependMagickMethod(CloneImageProfiles)
#define CloneImageProperties PrependMagickMethod(CloneImageProperties)
#define CloneImages PrependMagickMethod(CloneImages)
#define CloneImageView PrependMagickMethod(CloneImageView)
#define CloneKernelInfo PrependMagickMethod(CloneKernelInfo)
#define CloneMagickPixelPacket PrependMagickMethod(CloneMagickPixelPacket)
#define CloneMemory PrependMagickMethod(CloneMemory)
#define CloneMontageInfo PrependMagickMethod(CloneMontageInfo)
#define ClonePixelCacheMethods PrependMagickMethod(ClonePixelCacheMethods)
#define ClonePixelCache PrependMagickMethod(ClonePixelCache)
#define CloneQuantizeInfo PrependMagickMethod(CloneQuantizeInfo)
#define CloneSplayTree PrependMagickMethod(CloneSplayTree)
#define CloneStringInfo PrependMagickMethod(CloneStringInfo)
#define CloneString PrependMagickMethod(CloneString)
#define CloseBlob PrependMagickMethod(CloseBlob)
#define CloseCacheView PrependMagickMethod(CloseCacheView)
#define CloseMagickLog PrependMagickMethod(CloseMagickLog)
#define ClutImageChannel PrependMagickMethod(ClutImageChannel)
#define ClutImage PrependMagickMethod(ClutImage)
#define CoalesceImages PrependMagickMethod(CoalesceImages)
#define CoderComponentGenesis PrependMagickMethod(CoderComponentGenesis)
#define CoderComponentTerminus PrependMagickMethod(CoderComponentTerminus)
#define ColorComponentGenesis PrependMagickMethod(ColorComponentGenesis)
#define ColorComponentTerminus PrependMagickMethod(ColorComponentTerminus)
#define ColorDecisionListImage PrependMagickMethod(ColorDecisionListImage)
#define ColorFloodfillImage PrependMagickMethod(ColorFloodfillImage)
#define ColorizeImage PrependMagickMethod(ColorizeImage)
#define ColorMatrixImage PrependMagickMethod(ColorMatrixImage)
#define CombineImages PrependMagickMethod(CombineImages)
#define CommandOptionToMnemonic PrependMagickMethod(CommandOptionToMnemonic)
#define CompareHashmapStringInfo PrependMagickMethod(CompareHashmapStringInfo)
#define CompareHashmapString PrependMagickMethod(CompareHashmapString)
#define CompareImageChannels PrependMagickMethod(CompareImageChannels)
#define CompareImageLayers PrependMagickMethod(CompareImageLayers)
#define CompareImages PrependMagickMethod(CompareImages)
#define CompareSplayTreeStringInfo PrependMagickMethod(CompareSplayTreeStringInfo)
#define CompareSplayTreeString PrependMagickMethod(CompareSplayTreeString)
#define CompareStringInfo PrependMagickMethod(CompareStringInfo)
#define ComplexImages PrependMagickMethod(ComplexImages)
#define CompositeImageChannel PrependMagickMethod(CompositeImageChannel)
#define CompositeImage PrependMagickMethod(CompositeImage)
#define CompositeLayers PrependMagickMethod(CompositeLayers)
#define CompressImageColormap PrependMagickMethod(CompressImageColormap)
#define ConcatenateColorComponent PrependMagickMethod(ConcatenateColorComponent)
#define ConcatenateMagickString PrependMagickMethod(ConcatenateMagickString)
#define ConcatenateStringInfo PrependMagickMethod(ConcatenateStringInfo)
#define ConcatenateString PrependMagickMethod(ConcatenateString)
#define ConfigureComponentGenesis PrependMagickMethod(ConfigureComponentGenesis)
#define ConfigureComponentTerminus PrependMagickMethod(ConfigureComponentTerminus)
#define ConfigureFileToStringInfo PrependMagickMethod(ConfigureFileToStringInfo)
#define ConformMagickPixelPacket PrependMagickMethod(ConformMagickPixelPacket)
#define ConnectedComponentsImage PrependMagickMethod(ConnectedComponentsImage)
#define ConsolidateCMYKImages PrependMagickMethod(ConsolidateCMYKImages)
#define ConstantString PrependMagickMethod(ConstantString)
#define ConstituteComponentGenesis PrependMagickMethod(ConstituteComponentGenesis)
#define ConstituteComponentTerminus PrependMagickMethod(ConstituteComponentTerminus)
#define ConstituteImage PrependMagickMethod(ConstituteImage)
#define ContinueTimer PrependMagickMethod(ContinueTimer)
#define ContrastImage PrependMagickMethod(ContrastImage)
#define ContrastStretchImageChannel PrependMagickMethod(ContrastStretchImageChannel)
#define ContrastStretchImage PrependMagickMethod(ContrastStretchImage)
#define ConvertHCLpToRGB PrependMagickMethod(ConvertHCLpToRGB)
#define ConvertHCLToRGB PrependMagickMethod(ConvertHCLToRGB)
#define ConvertHSBToRGB PrependMagickMethod(ConvertHSBToRGB)
#define ConvertHSIToRGB PrependMagickMethod(ConvertHSIToRGB)
#define ConvertHSLToRGB PrependMagickMethod(ConvertHSLToRGB)
#define ConvertHSVToRGB PrependMagickMethod(ConvertHSVToRGB)
#define ConvertHWBToRGB PrependMagickMethod(ConvertHWBToRGB)
#define ConvertLCHabToRGB PrependMagickMethod(ConvertLCHabToRGB)
#define ConvertLCHuvToRGB PrependMagickMethod(ConvertLCHuvToRGB)
#define ConvertRGBToHCLp PrependMagickMethod(ConvertRGBToHCLp)
#define ConvertRGBToHCL PrependMagickMethod(ConvertRGBToHCL)
#define ConvertRGBToHSB PrependMagickMethod(ConvertRGBToHSB)
#define ConvertRGBToHSI PrependMagickMethod(ConvertRGBToHSI)
#define ConvertRGBToHSL PrependMagickMethod(ConvertRGBToHSL)
#define ConvertRGBToHSV PrependMagickMethod(ConvertRGBToHSV)
#define ConvertRGBToHWB PrependMagickMethod(ConvertRGBToHWB)
#define ConvertRGBToLCHab PrependMagickMethod(ConvertRGBToLCHab)
#define ConvertRGBToLCHuv PrependMagickMethod(ConvertRGBToLCHuv)
#define ConvolveImageChannel PrependMagickMethod(ConvolveImageChannel)
#define ConvolveImage PrependMagickMethod(ConvolveImage)
#define CopyImagePixels PrependMagickMethod(CopyImagePixels)
#define CopyMagickMemory PrependMagickMethod(CopyMagickMemory)
#define CopyMagickString PrependMagickMethod(CopyMagickString)
#define CreateMagickThreadKey PrependMagickMethod(CreateMagickThreadKey)
#define CropImage PrependMagickMethod(CropImage)
#define CropImageToTiles PrependMagickMethod(CropImageToTiles)
#define CycleColormapImage PrependMagickMethod(CycleColormapImage)
#define DecipherImage PrependMagickMethod(DecipherImage)
#define DecodePixelGamma PrependMagickMethod(DecodePixelGamma)
#define DeconstructImages PrependMagickMethod(DeconstructImages)
#define DefineImageArtifact PrependMagickMethod(DefineImageArtifact)
#define DefineImageOption PrependMagickMethod(DefineImageOption)
#define DefineImageProperty PrependMagickMethod(DefineImageProperty)
#define DefineImageRegistry PrependMagickMethod(DefineImageRegistry)
#define DelegateComponentGenesis PrependMagickMethod(DelegateComponentGenesis)
#define DelegateComponentTerminus PrependMagickMethod(DelegateComponentTerminus)
#define DeleteImageArtifact PrependMagickMethod(DeleteImageArtifact)
#define DeleteImageAttribute PrependMagickMethod(DeleteImageAttribute)
#define DeleteImageFromList PrependMagickMethod(DeleteImageFromList)
#define DeleteImageList PrependMagickMethod(DeleteImageList)
#define DeleteImageOption PrependMagickMethod(DeleteImageOption)
#define DeleteImageProfile PrependMagickMethod(DeleteImageProfile)
#define DeleteImageProperty PrependMagickMethod(DeleteImageProperty)
#define DeleteImageRegistry PrependMagickMethod(DeleteImageRegistry)
#define DeleteImages PrependMagickMethod(DeleteImages)
#define DeleteMagickRegistry PrependMagickMethod(DeleteMagickRegistry)
#define DeleteMagickThreadKey PrependMagickMethod(DeleteMagickThreadKey)
#define DeleteNodeByValueFromSplayTree PrependMagickMethod(DeleteNodeByValueFromSplayTree)
#define DeleteNodeFromSplayTree PrependMagickMethod(DeleteNodeFromSplayTree)
#define DescribeImage PrependMagickMethod(DescribeImage)
#define DeskewImage PrependMagickMethod(DeskewImage)
#define DespeckleImage PrependMagickMethod(DespeckleImage)
#define DestroyBlob PrependMagickMethod(DestroyBlob)
#define DestroyCacheView PrependMagickMethod(DestroyCacheView)
#define DestroyConfigureOptions PrependMagickMethod(DestroyConfigureOptions)
#define DestroyConstitute PrependMagickMethod(DestroyConstitute)
#define DestroyDistributeCacheInfo PrependMagickMethod(DestroyDistributeCacheInfo)
#define DestroyDrawInfo PrependMagickMethod(DestroyDrawInfo)
#define DestroyExceptionInfo PrependMagickMethod(DestroyExceptionInfo)
#define DestroyFxInfo PrependMagickMethod(DestroyFxInfo)
#define DestroyHashmap PrependMagickMethod(DestroyHashmap)
#define DestroyImageArtifacts PrependMagickMethod(DestroyImageArtifacts)
#define DestroyImageAttributes PrependMagickMethod(DestroyImageAttributes)
#define DestroyImageInfo PrependMagickMethod(DestroyImageInfo)
#define DestroyImageList PrependMagickMethod(DestroyImageList)
#define DestroyImageOptions PrependMagickMethod(DestroyImageOptions)
#define DestroyImagePixels PrependMagickMethod(DestroyImagePixels)
#define DestroyImage PrependMagickMethod(DestroyImage)
#define DestroyImageProfiles PrependMagickMethod(DestroyImageProfiles)
#define DestroyImageProperties PrependMagickMethod(DestroyImageProperties)
#define DestroyImages PrependMagickMethod(DestroyImages)
#define DestroyImageView PrependMagickMethod(DestroyImageView)
#define DestroyKernelInfo PrependMagickMethod(DestroyKernelInfo)
#define DestroyLinkedList PrependMagickMethod(DestroyLinkedList)
#define DestroyLocaleOptions PrependMagickMethod(DestroyLocaleOptions)
#define DestroyMagickMemory PrependMagickMethod(DestroyMagickMemory)
#define DestroyMagick PrependMagickMethod(DestroyMagick)
#define DestroyMagickRegistry PrependMagickMethod(DestroyMagickRegistry)
#define DestroyMatrixInfo PrependMagickMethod(DestroyMatrixInfo)
#define DestroyMontageInfo PrependMagickMethod(DestroyMontageInfo)
#define DestroyPixelCacheNexus PrependMagickMethod(DestroyPixelCacheNexus)
#define DestroyPixelCache PrependMagickMethod(DestroyPixelCache)
#define DestroyQuantizeInfo PrependMagickMethod(DestroyQuantizeInfo)
#define DestroyQuantumInfo PrependMagickMethod(DestroyQuantumInfo)
#define DestroyRandomInfo PrependMagickMethod(DestroyRandomInfo)
#define DestroyResampleFilter PrependMagickMethod(DestroyResampleFilter)
#define DestroyResizeFilter PrependMagickMethod(DestroyResizeFilter)
#define DestroySemaphoreInfo PrependMagickMethod(DestroySemaphoreInfo)
#define DestroySignatureInfo PrependMagickMethod(DestroySignatureInfo)
#define DestroySplayTree PrependMagickMethod(DestroySplayTree)
#define DestroyStreamInfo PrependMagickMethod(DestroyStreamInfo)
#define DestroyStringInfo PrependMagickMethod(DestroyStringInfo)
#define DestroyStringList PrependMagickMethod(DestroyStringList)
#define DestroyString PrependMagickMethod(DestroyString)
#define DestroyThresholdMap PrependMagickMethod(DestroyThresholdMap)
#define DestroyTimerInfo PrependMagickMethod(DestroyTimerInfo)
#define DestroyTokenInfo PrependMagickMethod(DestroyTokenInfo)
#define DestroyXMLTree PrependMagickMethod(DestroyXMLTree)
#define DestroyXResources PrependMagickMethod(DestroyXResources)
#define DestroyXWidget PrependMagickMethod(DestroyXWidget)
#define DetachBlob PrependMagickMethod(DetachBlob)
#define DisassociateBlob PrependMagickMethod(DisassociateBlob)
#define DisassociateImageStream PrependMagickMethod(DisassociateImageStream)
#define DiscardBlobBytes PrependMagickMethod(DiscardBlobBytes)
#define DispatchImage PrependMagickMethod(DispatchImage)
#define DisplayImages PrependMagickMethod(DisplayImages)
#define DisposeImages PrependMagickMethod(DisposeImages)
#define DistortImage PrependMagickMethod(DistortImage)
#define DistortResizeImage PrependMagickMethod(DistortResizeImage)
#define DistributePixelCacheServer PrependMagickMethod(DistributePixelCacheServer)
#define DrawAffineImage PrependMagickMethod(DrawAffineImage)
#define DrawClipPath PrependMagickMethod(DrawClipPath)
#define DrawGradientImage PrependMagickMethod(DrawGradientImage)
#define DrawImage PrependMagickMethod(DrawImage)
#define DrawPatternPath PrependMagickMethod(DrawPatternPath)
#define DrawPrimitive PrependMagickMethod(DrawPrimitive)
#define DuplexTransferImageViewIterator PrependMagickMethod(DuplexTransferImageViewIterator)
#define DuplicateBlob PrependMagickMethod(DuplicateBlob)
#define DuplicateImages PrependMagickMethod(DuplicateImages)
#define EdgeImage PrependMagickMethod(EdgeImage)
#define EmbossImage PrependMagickMethod(EmbossImage)
#define EncipherImage PrependMagickMethod(EncipherImage)
#define EncodePixelGamma PrependMagickMethod(EncodePixelGamma)
#define EnhanceImage PrependMagickMethod(EnhanceImage)
#define EOFBlob PrependMagickMethod(EOFBlob)
#define EqualizeImageChannel PrependMagickMethod(EqualizeImageChannel)
#define EqualizeImage PrependMagickMethod(EqualizeImage)
#define ErrorBlob PrependMagickMethod(ErrorBlob)
#define EscapeString PrependMagickMethod(EscapeString)
#define EvaluateImageChannel PrependMagickMethod(EvaluateImageChannel)
#define EvaluateImage PrependMagickMethod(EvaluateImage)
#define EvaluateImages PrependMagickMethod(EvaluateImages)
#define ExceptionComponentGenesis PrependMagickMethod(ExceptionComponentGenesis)
#define ExceptionComponentTerminus PrependMagickMethod(ExceptionComponentTerminus)
#define ExcerptImage PrependMagickMethod(ExcerptImage)
#define ExpandAffine PrependMagickMethod(ExpandAffine)
#define ExpandFilename PrependMagickMethod(ExpandFilename)
#define ExpandFilenames PrependMagickMethod(ExpandFilenames)
#define ExportImagePixels PrependMagickMethod(ExportImagePixels)
#define ExportQuantumPixels PrependMagickMethod(ExportQuantumPixels)
#define ExtentImage PrependMagickMethod(ExtentImage)
#define ExternalDelegateCommand PrependMagickMethod(ExternalDelegateCommand)
#define ExtractSubimageFromImage PrependMagickMethod(ExtractSubimageFromImage)
#define FileToBlob PrependMagickMethod(FileToBlob)
#define FileToImage PrependMagickMethod(FileToImage)
#define FileToStringInfo PrependMagickMethod(FileToStringInfo)
#define FileToString PrependMagickMethod(FileToString)
#define FileToXML PrependMagickMethod(FileToXML)
#define FilterImageChannel PrependMagickMethod(FilterImageChannel)
#define FilterImage PrependMagickMethod(FilterImage)
#define FinalizeSignature PrependMagickMethod(FinalizeSignature)
#define FlattenImages PrependMagickMethod(FlattenImages)
#define FlipImage PrependMagickMethod(FlipImage)
#define FloodfillPaintImage PrependMagickMethod(FloodfillPaintImage)
#define FlopImage PrependMagickMethod(FlopImage)
#define FormatImageAttributeList PrependMagickMethod(FormatImageAttributeList)
#define FormatImageAttribute PrependMagickMethod(FormatImageAttribute)
#define FormatImagePropertyList PrependMagickMethod(FormatImagePropertyList)
#define FormatImageProperty PrependMagickMethod(FormatImageProperty)
#define FormatLocaleFileList PrependMagickMethod(FormatLocaleFileList)
#define FormatLocaleFile PrependMagickMethod(FormatLocaleFile)
#define FormatLocaleStringList PrependMagickMethod(FormatLocaleStringList)
#define FormatLocaleString PrependMagickMethod(FormatLocaleString)
#define FormatMagickCaption PrependMagickMethod(FormatMagickCaption)
#define FormatMagickSize PrependMagickMethod(FormatMagickSize)
#define FormatMagickStringList PrependMagickMethod(FormatMagickStringList)
#define FormatMagickString PrependMagickMethod(FormatMagickString)
#define FormatMagickTime PrependMagickMethod(FormatMagickTime)
#define FormatStringList PrependMagickMethod(FormatStringList)
#define FormatString PrependMagickMethod(FormatString)
#define ForwardFourierTransformImage PrependMagickMethod(ForwardFourierTransformImage)
#define FrameImage PrependMagickMethod(FrameImage)
#define FunctionImageChannel PrependMagickMethod(FunctionImageChannel)
#define FunctionImage PrependMagickMethod(FunctionImage)
#define FuzzyColorCompare PrependMagickMethod(FuzzyColorCompare)
#define FuzzyColorMatch PrependMagickMethod(FuzzyColorMatch)
#define FuzzyOpacityCompare PrependMagickMethod(FuzzyOpacityCompare)
#define FxEvaluateChannelExpression PrependMagickMethod(FxEvaluateChannelExpression)
#define FxEvaluateExpression PrependMagickMethod(FxEvaluateExpression)
#define FxImageChannel PrependMagickMethod(FxImageChannel)
#define FxImage PrependMagickMethod(FxImage)
#define FxPreprocessExpression PrependMagickMethod(FxPreprocessExpression)
#define GammaImageChannel PrependMagickMethod(GammaImageChannel)
#define GammaImage PrependMagickMethod(GammaImage)
#define GaussianBlurImageChannel PrependMagickMethod(GaussianBlurImageChannel)
#define GaussianBlurImage PrependMagickMethod(GaussianBlurImage)
#define GaussJordanElimination PrependMagickMethod(GaussJordanElimination)
#define GenerateDifferentialNoise PrependMagickMethod(GenerateDifferentialNoise)
#define GetAffineMatrix PrependMagickMethod(GetAffineMatrix)
#define GetAuthenticIndexQueue PrependMagickMethod(GetAuthenticIndexQueue)
#define GetAuthenticPixelCacheNexus PrependMagickMethod(GetAuthenticPixelCacheNexus)
#define GetAuthenticPixelQueue PrependMagickMethod(GetAuthenticPixelQueue)
#define GetAuthenticPixels PrependMagickMethod(GetAuthenticPixels)
#define GetBlobError PrependMagickMethod(GetBlobError)
#define GetBlobFileHandle PrependMagickMethod(GetBlobFileHandle)
#define GetBlobInfo PrependMagickMethod(GetBlobInfo)
#define GetBlobProperties PrependMagickMethod(GetBlobProperties)
#define GetBlobSize PrependMagickMethod(GetBlobSize)
#define GetBlobStreamData PrependMagickMethod(GetBlobStreamData)
#define GetBlobStreamHandler PrependMagickMethod(GetBlobStreamHandler)
#define GetCacheViewAuthenticIndexQueue PrependMagickMethod(GetCacheViewAuthenticIndexQueue)
#define GetCacheViewAuthenticPixelQueue PrependMagickMethod(GetCacheViewAuthenticPixelQueue)
#define GetCacheViewAuthenticPixels PrependMagickMethod(GetCacheViewAuthenticPixels)
#define GetCacheViewChannels PrependMagickMethod(GetCacheViewChannels)
#define GetCacheViewColorspace PrependMagickMethod(GetCacheViewColorspace)
#define GetCacheViewException PrependMagickMethod(GetCacheViewException)
#define GetCacheViewExtent PrependMagickMethod(GetCacheViewExtent)
#define GetCacheViewIndexes PrependMagickMethod(GetCacheViewIndexes)
#define GetCacheViewPixels PrependMagickMethod(GetCacheViewPixels)
#define GetCacheView PrependMagickMethod(GetCacheView)
#define GetCacheViewStorageClass PrependMagickMethod(GetCacheViewStorageClass)
#define GetCacheViewVirtualIndexQueue PrependMagickMethod(GetCacheViewVirtualIndexQueue)
#define GetCacheViewVirtualPixelQueue PrependMagickMethod(GetCacheViewVirtualPixelQueue)
#define GetCacheViewVirtualPixels PrependMagickMethod(GetCacheViewVirtualPixels)
#define GetClientName PrependMagickMethod(GetClientName)
#define GetClientPath PrependMagickMethod(GetClientPath)
#define GetCoderInfoList PrependMagickMethod(GetCoderInfoList)
#define GetCoderInfo PrependMagickMethod(GetCoderInfo)
#define GetCoderList PrependMagickMethod(GetCoderList)
#define GetColorCompliance PrependMagickMethod(GetColorCompliance)
#define GetColorInfoList PrependMagickMethod(GetColorInfoList)
#define GetColorInfo PrependMagickMethod(GetColorInfo)
#define GetColorList PrependMagickMethod(GetColorList)
#define GetColorTuple PrependMagickMethod(GetColorTuple)
#define GetCommandOptionFlags PrependMagickMethod(GetCommandOptionFlags)
#define GetCommandOptions PrependMagickMethod(GetCommandOptions)
#define GetConfigureBlob PrependMagickMethod(GetConfigureBlob)
#define GetConfigureInfoList PrependMagickMethod(GetConfigureInfoList)
#define GetConfigureInfo PrependMagickMethod(GetConfigureInfo)
#define GetConfigureList PrependMagickMethod(GetConfigureList)
#define GetConfigureOption PrependMagickMethod(GetConfigureOption)
#define GetConfigureOptions PrependMagickMethod(GetConfigureOptions)
#define GetConfigurePaths PrependMagickMethod(GetConfigurePaths)
#define GetConfigureValue PrependMagickMethod(GetConfigureValue)
#define GetDefaultOpenCLEnv PrependMagickMethod(GetDefaultOpenCLEnv)
#define GetDelegateCommand PrependMagickMethod(GetDelegateCommand)
#define GetDelegateCommands PrependMagickMethod(GetDelegateCommands)
#define GetDelegateInfoList PrependMagickMethod(GetDelegateInfoList)
#define GetDelegateInfo PrependMagickMethod(GetDelegateInfo)
#define GetDelegateList PrependMagickMethod(GetDelegateList)
#define GetDelegateMode PrependMagickMethod(GetDelegateMode)
#define GetDelegateThreadSupport PrependMagickMethod(GetDelegateThreadSupport)
#define GetDistributeCacheFile PrependMagickMethod(GetDistributeCacheFile)
#define GetDistributeCacheHostname PrependMagickMethod(GetDistributeCacheHostname)
#define GetDistributeCachePort PrependMagickMethod(GetDistributeCachePort)
#define GetDrawInfo PrependMagickMethod(GetDrawInfo)
#define GetElapsedTime PrependMagickMethod(GetElapsedTime)
#define GetEnvironmentValue PrependMagickMethod(GetEnvironmentValue)
#define GetExceptionInfo PrependMagickMethod(GetExceptionInfo)
#define GetExceptionMessage PrependMagickMethod(GetExceptionMessage)
#define GetExecutionPath PrependMagickMethod(GetExecutionPath)
#define GetFirstImageInList PrependMagickMethod(GetFirstImageInList)
#define GetGeometry PrependMagickMethod(GetGeometry)
#define GetHeadElementInLinkedList PrependMagickMethod(GetHeadElementInLinkedList)
#define GetImageAlphaChannel PrependMagickMethod(GetImageAlphaChannel)
#define GetImageArtifact PrependMagickMethod(GetImageArtifact)
#define GetImageAttribute PrependMagickMethod(GetImageAttribute)
#define GetImageBoundingBox PrependMagickMethod(GetImageBoundingBox)
#define GetImageChannelDepth PrependMagickMethod(GetImageChannelDepth)
#define GetImageChannelDistortion PrependMagickMethod(GetImageChannelDistortion)
#define GetImageChannelDistortions PrependMagickMethod(GetImageChannelDistortions)
#define GetImageChannelEntropy PrependMagickMethod(GetImageChannelEntropy)
#define GetImageChannelExtrema PrependMagickMethod(GetImageChannelExtrema)
#define GetImageChannelFeatures PrependMagickMethod(GetImageChannelFeatures)
#define GetImageChannelKurtosis PrependMagickMethod(GetImageChannelKurtosis)
#define GetImageChannelMean PrependMagickMethod(GetImageChannelMean)
#define GetImageChannelMoments PrependMagickMethod(GetImageChannelMoments)
#define GetImageChannelPerceptualHash PrependMagickMethod(GetImageChannelPerceptualHash)
#define GetImageChannelRange PrependMagickMethod(GetImageChannelRange)
#define GetImageChannels PrependMagickMethod(GetImageChannels)
#define GetImageChannelStatistics PrependMagickMethod(GetImageChannelStatistics)
#define GetImageClipMask PrependMagickMethod(GetImageClipMask)
#define GetImageClippingPathAttribute PrependMagickMethod(GetImageClippingPathAttribute)
#define GetImageColorspaceType PrependMagickMethod(GetImageColorspaceType)
#define GetImageDecoder PrependMagickMethod(GetImageDecoder)
#define GetImageDepth PrependMagickMethod(GetImageDepth)
#define GetImageDistortion PrependMagickMethod(GetImageDistortion)
#define GetImageDynamicThreshold PrependMagickMethod(GetImageDynamicThreshold)
#define GetImageEncoder PrependMagickMethod(GetImageEncoder)
#define GetImageEntropy PrependMagickMethod(GetImageEntropy)
#define GetImageException PrependMagickMethod(GetImageException)
#define GetImageExtent PrependMagickMethod(GetImageExtent)
#define GetImageExtrema PrependMagickMethod(GetImageExtrema)
#define GetImageFromList PrependMagickMethod(GetImageFromList)
#define GetImageFromMagickRegistry PrependMagickMethod(GetImageFromMagickRegistry)
#define GetImageGeometry PrependMagickMethod(GetImageGeometry)
#define GetImageHistogram PrependMagickMethod(GetImageHistogram)
#define GetImageIndexInList PrependMagickMethod(GetImageIndexInList)
#define GetImageInfoFile PrependMagickMethod(GetImageInfoFile)
#define GetImageInfo PrependMagickMethod(GetImageInfo)
#define GetImageKurtosis PrependMagickMethod(GetImageKurtosis)
#define GetImageListIndex PrependMagickMethod(GetImageListIndex)
#define GetImageListLength PrependMagickMethod(GetImageListLength)
#define GetImageList PrependMagickMethod(GetImageList)
#define GetImageListSize PrependMagickMethod(GetImageListSize)
#define GetImageMagick PrependMagickMethod(GetImageMagick)
#define GetImageMask PrependMagickMethod(GetImageMask)
#define GetImageMean PrependMagickMethod(GetImageMean)
#define GetImageOption PrependMagickMethod(GetImageOption)
#define GetImagePixelCacheType PrependMagickMethod(GetImagePixelCacheType)
#define GetImagePixels PrependMagickMethod(GetImagePixels)
#define GetImageProfile PrependMagickMethod(GetImageProfile)
#define GetImageProperty PrependMagickMethod(GetImageProperty)
#define GetImageQuantizeError PrependMagickMethod(GetImageQuantizeError)
#define GetImageQuantumDepth PrependMagickMethod(GetImageQuantumDepth)
#define GetImageRange PrependMagickMethod(GetImageRange)
#define GetImageReferenceCount PrependMagickMethod(GetImageReferenceCount)
#define GetImageRegistry PrependMagickMethod(GetImageRegistry)
#define GetImageTotalInkDensity PrependMagickMethod(GetImageTotalInkDensity)
#define GetImageType PrependMagickMethod(GetImageType)
#define GetImageViewAuthenticIndexes PrependMagickMethod(GetImageViewAuthenticIndexes)
#define GetImageViewAuthenticPixels PrependMagickMethod(GetImageViewAuthenticPixels)
#define GetImageViewException PrependMagickMethod(GetImageViewException)
#define GetImageViewExtent PrependMagickMethod(GetImageViewExtent)
#define GetImageViewImage PrependMagickMethod(GetImageViewImage)
#define GetImageViewIterator PrependMagickMethod(GetImageViewIterator)
#define GetImageViewVirtualIndexes PrependMagickMethod(GetImageViewVirtualIndexes)
#define GetImageViewVirtualPixels PrependMagickMethod(GetImageViewVirtualPixels)
#define GetImageVirtualPixelMethod PrependMagickMethod(GetImageVirtualPixelMethod)
#define GetIndexes PrependMagickMethod(GetIndexes)
#define GetLastImageInList PrependMagickMethod(GetLastImageInList)
#define GetLastValueInLinkedList PrependMagickMethod(GetLastValueInLinkedList)
#define GetLocaleExceptionMessage PrependMagickMethod(GetLocaleExceptionMessage)
#define GetLocaleInfoList PrependMagickMethod(GetLocaleInfoList)
#define GetLocaleInfo_ PrependMagickMethod(GetLocaleInfo_)
#define GetLocaleList PrependMagickMethod(GetLocaleList)
#define GetLocaleMessage PrependMagickMethod(GetLocaleMessage)
#define GetLocaleOptions PrependMagickMethod(GetLocaleOptions)
#define GetLocaleValue PrependMagickMethod(GetLocaleValue)
#define GetLogEventMask PrependMagickMethod(GetLogEventMask)
#define GetLogInfoList PrependMagickMethod(GetLogInfoList)
#define GetLogList PrependMagickMethod(GetLogList)
#define GetLogName PrependMagickMethod(GetLogName)
#define GetMagicInfoList PrependMagickMethod(GetMagicInfoList)
#define GetMagicInfo PrependMagickMethod(GetMagicInfo)
#define GetMagickAdjoin PrependMagickMethod(GetMagickAdjoin)
#define GetMagickBlobSupport PrependMagickMethod(GetMagickBlobSupport)
#define GetMagickCopyright PrependMagickMethod(GetMagickCopyright)
#define GetMagickCoreSignature PrependMagickMethod(GetMagickCoreSignature)
#define GetMagickDelegates PrependMagickMethod(GetMagickDelegates)
#define GetMagickDescription PrependMagickMethod(GetMagickDescription)
#define GetMagickEndianSupport PrependMagickMethod(GetMagickEndianSupport)
#define GetMagickFeatures PrependMagickMethod(GetMagickFeatures)
#define GetMagickGeometry PrependMagickMethod(GetMagickGeometry)
#define GetMagickHomeURL PrependMagickMethod(GetMagickHomeURL)
#define GetMagickInfoList PrependMagickMethod(GetMagickInfoList)
#define GetMagickInfo PrependMagickMethod(GetMagickInfo)
#define GetMagickLicense PrependMagickMethod(GetMagickLicense)
#define GetMagickList PrependMagickMethod(GetMagickList)
#define GetMagickMemoryMethods PrependMagickMethod(GetMagickMemoryMethods)
#define GetMagickMimeType PrependMagickMethod(GetMagickMimeType)
#define GetMagickOpenCLEnvParam PrependMagickMethod(GetMagickOpenCLEnvParam)
#define GetMagickPackageName PrependMagickMethod(GetMagickPackageName)
#define GetMagickPageSize PrependMagickMethod(GetMagickPageSize)
#define GetMagickPixelIntensity PrependMagickMethod(GetMagickPixelIntensity)
#define GetMagickPixelPacket PrependMagickMethod(GetMagickPixelPacket)
#define GetMagickPrecision PrependMagickMethod(GetMagickPrecision)
#define GetMagickProperty PrependMagickMethod(GetMagickProperty)
#define GetMagickQuantumDepth PrependMagickMethod(GetMagickQuantumDepth)
#define GetMagickQuantumRange PrependMagickMethod(GetMagickQuantumRange)
#define GetMagickRawSupport PrependMagickMethod(GetMagickRawSupport)
#define GetMagickRegistry PrependMagickMethod(GetMagickRegistry)
#define GetMagickReleaseDate PrependMagickMethod(GetMagickReleaseDate)
#define GetMagickResourceLimit PrependMagickMethod(GetMagickResourceLimit)
#define GetMagickResource PrependMagickMethod(GetMagickResource)
#define GetMagickSeekableStream PrependMagickMethod(GetMagickSeekableStream)
#define GetMagickThreadSupport PrependMagickMethod(GetMagickThreadSupport)
#define GetMagickThreadValue PrependMagickMethod(GetMagickThreadValue)
#define GetMagickTime PrependMagickMethod(GetMagickTime)
#define GetMagickToken PrependMagickMethod(GetMagickToken)
#define GetMagickVersion PrependMagickMethod(GetMagickVersion)
#define GetMagicList PrependMagickMethod(GetMagicList)
#define GetMagicName PrependMagickMethod(GetMagicName)
#define GetMatrixColumns PrependMagickMethod(GetMatrixColumns)
#define GetMatrixElement PrependMagickMethod(GetMatrixElement)
#define GetMatrixRows PrependMagickMethod(GetMatrixRows)
#define GetMaxMemoryRequest PrependMagickMethod(GetMaxMemoryRequest)
#define GetMimeDescription PrependMagickMethod(GetMimeDescription)
#define GetMimeInfoList PrependMagickMethod(GetMimeInfoList)
#define GetMimeInfo PrependMagickMethod(GetMimeInfo)
#define GetMimeList PrependMagickMethod(GetMimeList)
#define GetMimeType PrependMagickMethod(GetMimeType)
#define GetMonitorHandler PrependMagickMethod(GetMonitorHandler)
#define GetMontageInfo PrependMagickMethod(GetMontageInfo)
#define GetMultilineTypeMetrics PrependMagickMethod(GetMultilineTypeMetrics)
#define GetNextImageArtifact PrependMagickMethod(GetNextImageArtifact)
#define GetNextImageAttribute PrependMagickMethod(GetNextImageAttribute)
#define GetNextImageInList PrependMagickMethod(GetNextImageInList)
#define GetNextImageOption PrependMagickMethod(GetNextImageOption)
#define GetNextImage PrependMagickMethod(GetNextImage)
#define GetNextImageProfile PrependMagickMethod(GetNextImageProfile)
#define GetNextImageProperty PrependMagickMethod(GetNextImageProperty)
#define GetNextImageRegistry PrependMagickMethod(GetNextImageRegistry)
#define GetNextKeyInHashmap PrependMagickMethod(GetNextKeyInHashmap)
#define GetNextKeyInSplayTree PrependMagickMethod(GetNextKeyInSplayTree)
#define GetNextToken PrependMagickMethod(GetNextToken)
#define GetNextValueInHashmap PrependMagickMethod(GetNextValueInHashmap)
#define GetNextValueInLinkedList PrependMagickMethod(GetNextValueInLinkedList)
#define GetNextValueInSplayTree PrependMagickMethod(GetNextValueInSplayTree)
#define GetNextXMLTreeTag PrependMagickMethod(GetNextXMLTreeTag)
#define GetNumberColors PrependMagickMethod(GetNumberColors)
#define GetNumberOfElementsInLinkedList PrependMagickMethod(GetNumberOfElementsInLinkedList)
#define GetNumberOfEntriesInHashmap PrependMagickMethod(GetNumberOfEntriesInHashmap)
#define GetNumberOfNodesInSplayTree PrependMagickMethod(GetNumberOfNodesInSplayTree)
#define GetNumberScenes PrependMagickMethod(GetNumberScenes)
#define GetOneAuthenticPixel PrependMagickMethod(GetOneAuthenticPixel)
#define GetOneCacheViewAuthenticPixel PrependMagickMethod(GetOneCacheViewAuthenticPixel)
#define GetOneCacheViewVirtualMethodPixel PrependMagickMethod(GetOneCacheViewVirtualMethodPixel)
#define GetOneCacheViewVirtualPixel PrependMagickMethod(GetOneCacheViewVirtualPixel)
#define GetOnePixel PrependMagickMethod(GetOnePixel)
#define GetOneVirtualMagickPixel PrependMagickMethod(GetOneVirtualMagickPixel)
#define GetOneVirtualMethodPixel PrependMagickMethod(GetOneVirtualMethodPixel)
#define GetOneVirtualPixel PrependMagickMethod(GetOneVirtualPixel)
#define GetOptimalKernelWidth1D PrependMagickMethod(GetOptimalKernelWidth1D)
#define GetOptimalKernelWidth2D PrependMagickMethod(GetOptimalKernelWidth2D)
#define GetOptimalKernelWidth PrependMagickMethod(GetOptimalKernelWidth)
#define GetPageGeometry PrependMagickMethod(GetPageGeometry)
#define GetPathAttributes PrependMagickMethod(GetPathAttributes)
#define GetPathComponent PrependMagickMethod(GetPathComponent)
#define GetPathComponents PrependMagickMethod(GetPathComponents)
#define GetPathTemplate PrependMagickMethod(GetPathTemplate)
#define GetPixelCacheChannels PrependMagickMethod(GetPixelCacheChannels)
#define GetPixelCacheColorspace PrependMagickMethod(GetPixelCacheColorspace)
#define GetPixelCacheFilename PrependMagickMethod(GetPixelCacheFilename)
#define GetPixelCacheMethods PrependMagickMethod(GetPixelCacheMethods)
#define GetPixelCacheNexusExtent PrependMagickMethod(GetPixelCacheNexusExtent)
#define GetPixelCachePixels PrependMagickMethod(GetPixelCachePixels)
#define GetPixelCacheStorageClass PrependMagickMethod(GetPixelCacheStorageClass)
#define GetPixelCacheTileSize PrependMagickMethod(GetPixelCacheTileSize)
#define GetPixelCacheType PrependMagickMethod(GetPixelCacheType)
#define GetPixelCacheVirtualMethod PrependMagickMethod(GetPixelCacheVirtualMethod)
#define GetPixelIntensity PrependMagickMethod(GetPixelIntensity)
#define GetPixels PrependMagickMethod(GetPixels)
#define GetPolicyInfoList PrependMagickMethod(GetPolicyInfoList)
#define GetPolicyList PrependMagickMethod(GetPolicyList)
#define GetPolicyValue PrependMagickMethod(GetPolicyValue)
#define GetPreviousImageInList PrependMagickMethod(GetPreviousImageInList)
#define GetPreviousImage PrependMagickMethod(GetPreviousImage)
#define GetPseudoRandomValue PrependMagickMethod(GetPseudoRandomValue)
#define GetQuantizeInfo PrependMagickMethod(GetQuantizeInfo)
#define GetQuantumEndian PrependMagickMethod(GetQuantumEndian)
#define GetQuantumExtent PrependMagickMethod(GetQuantumExtent)
#define GetQuantumFormat PrependMagickMethod(GetQuantumFormat)
#define GetQuantumInfo PrependMagickMethod(GetQuantumInfo)
#define GetQuantumPixels PrependMagickMethod(GetQuantumPixels)
#define GetQuantumType PrependMagickMethod(GetQuantumType)
#define GetRandomInfoNormalize PrependMagickMethod(GetRandomInfoNormalize)
#define GetRandomInfoSeed PrependMagickMethod(GetRandomInfoSeed)
#define GetRandomKey PrependMagickMethod(GetRandomKey)
#define GetRandomSecretKey PrependMagickMethod(GetRandomSecretKey)
#define GetRandomValue PrependMagickMethod(GetRandomValue)
#define GetResizeFilterBlur PrependMagickMethod(GetResizeFilterBlur)
#define GetResizeFilterCoefficient PrependMagickMethod(GetResizeFilterCoefficient)
#define GetResizeFilterScale PrependMagickMethod(GetResizeFilterScale)
#define GetResizeFilterSupport PrependMagickMethod(GetResizeFilterSupport)
#define GetResizeFilterWeightingType PrependMagickMethod(GetResizeFilterWeightingType)
#define GetResizeFilterWeight PrependMagickMethod(GetResizeFilterWeight)
#define GetResizeFilterWindowSupport PrependMagickMethod(GetResizeFilterWindowSupport)
#define GetResizeFilterWindowWeightingType PrependMagickMethod(GetResizeFilterWindowWeightingType)
#define GetRootValueFromSplayTree PrependMagickMethod(GetRootValueFromSplayTree)
#define GetSignatureBlocksize PrependMagickMethod(GetSignatureBlocksize)
#define GetSignatureDigest PrependMagickMethod(GetSignatureDigest)
#define GetSignatureDigestsize PrependMagickMethod(GetSignatureDigestsize)
#define GetStreamInfoClientData PrependMagickMethod(GetStreamInfoClientData)
#define GetStringInfoDatum PrependMagickMethod(GetStringInfoDatum)
#define GetStringInfoLength PrependMagickMethod(GetStringInfoLength)
#define GetStringInfoName PrependMagickMethod(GetStringInfoName)
#define GetStringInfoPath PrependMagickMethod(GetStringInfoPath)
#define GetThresholdMapFile PrependMagickMethod(GetThresholdMapFile)
#define GetThresholdMap PrependMagickMethod(GetThresholdMap)
#define GetTimerInfo PrependMagickMethod(GetTimerInfo)
#define GetTypeInfoByFamily PrependMagickMethod(GetTypeInfoByFamily)
#define GetTypeInfoList PrependMagickMethod(GetTypeInfoList)
#define GetTypeInfo PrependMagickMethod(GetTypeInfo)
#define GetTypeList PrependMagickMethod(GetTypeList)
#define GetTypeMetrics PrependMagickMethod(GetTypeMetrics)
#define GetUserTime PrependMagickMethod(GetUserTime)
#define GetValueFromHashmap PrependMagickMethod(GetValueFromHashmap)
#define GetValueFromLinkedList PrependMagickMethod(GetValueFromLinkedList)
#define GetValueFromSplayTree PrependMagickMethod(GetValueFromSplayTree)
#define GetVirtualIndexesFromNexus PrependMagickMethod(GetVirtualIndexesFromNexus)
#define GetVirtualIndexQueue PrependMagickMethod(GetVirtualIndexQueue)
#define GetVirtualMemoryBlob PrependMagickMethod(GetVirtualMemoryBlob)
#define GetVirtualPixelCacheNexus PrependMagickMethod(GetVirtualPixelCacheNexus)
#define GetVirtualPixelQueue PrependMagickMethod(GetVirtualPixelQueue)
#define GetVirtualPixelsNexus PrependMagickMethod(GetVirtualPixelsNexus)
#define GetVirtualPixels PrependMagickMethod(GetVirtualPixels)
#define GetXMLTreeAttribute PrependMagickMethod(GetXMLTreeAttribute)
#define GetXMLTreeAttributes PrependMagickMethod(GetXMLTreeAttributes)
#define GetXMLTreeChild PrependMagickMethod(GetXMLTreeChild)
#define GetXMLTreeContent PrependMagickMethod(GetXMLTreeContent)
#define GetXMLTreeOrdered PrependMagickMethod(GetXMLTreeOrdered)
#define GetXMLTreePath PrependMagickMethod(GetXMLTreePath)
#define GetXMLTreeProcessingInstructions PrependMagickMethod(GetXMLTreeProcessingInstructions)
#define GetXMLTreeSibling PrependMagickMethod(GetXMLTreeSibling)
#define GetXMLTreeTag PrependMagickMethod(GetXMLTreeTag)
#define GlobExpression PrependMagickMethod(GlobExpression)
#define GradientImage PrependMagickMethod(GradientImage)
#define GravityAdjustGeometry PrependMagickMethod(GravityAdjustGeometry)
#define GrayscaleImage PrependMagickMethod(GrayscaleImage)
#define HaldClutImageChannel PrependMagickMethod(HaldClutImageChannel)
#define HaldClutImage PrependMagickMethod(HaldClutImage)
#define HashPointerType PrependMagickMethod(HashPointerType)
#define HashStringInfoType PrependMagickMethod(HashStringInfoType)
#define HashStringType PrependMagickMethod(HashStringType)
#define HoughLineImage PrependMagickMethod(HoughLineImage)
#define HSLTransform PrependMagickMethod(HSLTransform)
#define HuffmanDecodeImage PrependMagickMethod(HuffmanDecodeImage)
#define HuffmanEncodeImage PrependMagickMethod(HuffmanEncodeImage)
#define IdentifyImageGray PrependMagickMethod(IdentifyImageGray)
#define IdentifyImageMonochrome PrependMagickMethod(IdentifyImageMonochrome)
#define IdentifyImage PrependMagickMethod(IdentifyImage)
#define IdentifyImageType PrependMagickMethod(IdentifyImageType)
#define IdentifyPaletteImage PrependMagickMethod(IdentifyPaletteImage)
#define IdentityAffine PrependMagickMethod(IdentityAffine)
#define ImageListToArray PrependMagickMethod(ImageListToArray)
#define ImagesToBlob PrependMagickMethod(ImagesToBlob)
#define ImageToBlob PrependMagickMethod(ImageToBlob)
#define ImageToFile PrependMagickMethod(ImageToFile)
#define ImplodeImage PrependMagickMethod(ImplodeImage)
#define ImportImagePixels PrependMagickMethod(ImportImagePixels)
#define ImportQuantumPixels PrependMagickMethod(ImportQuantumPixels)
#define InheritException PrependMagickMethod(InheritException)
#define InitializeExceptionInfo PrependMagickMethod(InitializeExceptionInfo)
#define InitializeMagick PrependMagickMethod(InitializeMagick)
#define InitializeSignature PrependMagickMethod(InitializeSignature)
#define InitImageMagickOpenCL PrependMagickMethod(InitImageMagickOpenCL)
#define InitOpenCLEnv PrependMagickMethod(InitOpenCLEnv)
#define InjectImageBlob PrependMagickMethod(InjectImageBlob)
#define InsertImageInList PrependMagickMethod(InsertImageInList)
#define InsertTagIntoXMLTree PrependMagickMethod(InsertTagIntoXMLTree)
#define InsertValueInLinkedList PrependMagickMethod(InsertValueInLinkedList)
#define InsertValueInSortedLinkedList PrependMagickMethod(InsertValueInSortedLinkedList)
#define IntegralRotateImage PrependMagickMethod(IntegralRotateImage)
#define InterpolateMagickPixelPacket PrependMagickMethod(InterpolateMagickPixelPacket)
#define InterpolatePixelColor PrependMagickMethod(InterpolatePixelColor)
#define InterpolativeResizeImage PrependMagickMethod(InterpolativeResizeImage)
#define InterpretImageAttributes PrependMagickMethod(InterpretImageAttributes)
#define InterpretImageFilename PrependMagickMethod(InterpretImageFilename)
#define InterpretImageProperties PrependMagickMethod(InterpretImageProperties)
#define InterpretLocaleValue PrependMagickMethod(InterpretLocaleValue)
#define InterpretSiPrefixValue PrependMagickMethod(InterpretSiPrefixValue)
#define InverseFourierTransformImage PrependMagickMethod(InverseFourierTransformImage)
#define InversesRGBCompandor PrependMagickMethod(InversesRGBCompandor)
#define InvokeDelegate PrependMagickMethod(InvokeDelegate)
#define InvokeDynamicImageFilter PrependMagickMethod(InvokeDynamicImageFilter)
#define IsBlobExempt PrependMagickMethod(IsBlobExempt)
#define IsBlobSeekable PrependMagickMethod(IsBlobSeekable)
#define IsBlobTemporary PrependMagickMethod(IsBlobTemporary)
#define IsColorSimilar PrependMagickMethod(IsColorSimilar)
#define IsCommandOption PrependMagickMethod(IsCommandOption)
#define IsEventLogging PrependMagickMethod(IsEventLogging)
#define IsGeometry PrependMagickMethod(IsGeometry)
#define IsGlob PrependMagickMethod(IsGlob)
#define IsGrayImage PrependMagickMethod(IsGrayImage)
#define IsHashmapEmpty PrependMagickMethod(IsHashmapEmpty)
#define IsHighDynamicRangeImage PrependMagickMethod(IsHighDynamicRangeImage)
#define IsHistogramImage PrependMagickMethod(IsHistogramImage)
#define IsImageObject PrependMagickMethod(IsImageObject)
#define IsImagesEqual PrependMagickMethod(IsImagesEqual)
#define IsImageSimilar PrependMagickMethod(IsImageSimilar)
#define IsImageView PrependMagickMethod(IsImageView)
#define IsIntensitySimilar PrependMagickMethod(IsIntensitySimilar)
#define IsLinkedListEmpty PrependMagickMethod(IsLinkedListEmpty)
#define IsMagickColorSimilar PrependMagickMethod(IsMagickColorSimilar)
#define IsMagickConflict PrependMagickMethod(IsMagickConflict)
#define IsMagickCoreInstantiated PrependMagickMethod(IsMagickCoreInstantiated)
#define IsMagickInstantiated PrependMagickMethod(IsMagickInstantiated)
#define IsMagickTrue PrependMagickMethod(IsMagickTrue)
#define IsMonochromeImage PrependMagickMethod(IsMonochromeImage)
#define IsOpacitySimilar PrependMagickMethod(IsOpacitySimilar)
#define IsOpaqueImage PrependMagickMethod(IsOpaqueImage)
#define IsOptionMember PrependMagickMethod(IsOptionMember)
#define IsPaletteImage PrependMagickMethod(IsPaletteImage)
#define IsPathAccessible PrependMagickMethod(IsPathAccessible)
#define IsRightsAuthorized PrependMagickMethod(IsRightsAuthorized)
#define IsSceneGeometry PrependMagickMethod(IsSceneGeometry)
#define IsStringNotFalse PrependMagickMethod(IsStringNotFalse)
#define IsStringTrue PrependMagickMethod(IsStringTrue)
#define IsSubimage PrependMagickMethod(IsSubimage)
#define IsTaintImage PrependMagickMethod(IsTaintImage)
#define KuwaharaImageChannel PrependMagickMethod(KuwaharaImageChannel)
#define KuwaharaImage PrependMagickMethod(KuwaharaImage)
#define LeastSquaresAddTerms PrependMagickMethod(LeastSquaresAddTerms)
#define LevelColorsImageChannel PrependMagickMethod(LevelColorsImageChannel)
#define LevelColorsImage PrependMagickMethod(LevelColorsImage)
#define LevelImageChannel PrependMagickMethod(LevelImageChannel)
#define LevelImageColors PrependMagickMethod(LevelImageColors)
#define LevelImage PrependMagickMethod(LevelImage)
#define LevelizeImageChannel PrependMagickMethod(LevelizeImageChannel)
#define LevelizeImage PrependMagickMethod(LevelizeImage)
#define LiberateMemory PrependMagickMethod(LiberateMemory)
#define LiberateSemaphoreInfo PrependMagickMethod(LiberateSemaphoreInfo)
#define LinearStretchImage PrependMagickMethod(LinearStretchImage)
#define LinkedListToArray PrependMagickMethod(LinkedListToArray)
#define LiquidRescaleImage PrependMagickMethod(LiquidRescaleImage)
#define ListCoderInfo PrependMagickMethod(ListCoderInfo)
#define ListColorInfo PrependMagickMethod(ListColorInfo)
#define ListCommandOptions PrependMagickMethod(ListCommandOptions)
#define ListConfigureInfo PrependMagickMethod(ListConfigureInfo)
#define ListDelegateInfo PrependMagickMethod(ListDelegateInfo)
#define ListFiles PrependMagickMethod(ListFiles)
#define ListLocaleInfo PrependMagickMethod(ListLocaleInfo)
#define ListLogInfo PrependMagickMethod(ListLogInfo)
#define ListMagicInfo PrependMagickMethod(ListMagicInfo)
#define ListMagickInfo PrependMagickMethod(ListMagickInfo)
#define ListMagickResourceInfo PrependMagickMethod(ListMagickResourceInfo)
#define ListMagickVersion PrependMagickMethod(ListMagickVersion)
#define ListMimeInfo PrependMagickMethod(ListMimeInfo)
#define ListModuleInfo PrependMagickMethod(ListModuleInfo)
#define ListPolicyInfo PrependMagickMethod(ListPolicyInfo)
#define ListThresholdMapFile PrependMagickMethod(ListThresholdMapFile)
#define ListThresholdMaps PrependMagickMethod(ListThresholdMaps)
#define ListTypeInfo PrependMagickMethod(ListTypeInfo)
#define LoadFontConfigFonts PrependMagickMethod(LoadFontConfigFonts)
#define LoadMimeLists PrependMagickMethod(LoadMimeLists)
#define LocalContrastImage PrependMagickMethod(LocalContrastImage)
#define LocaleCompare PrependMagickMethod(LocaleCompare)
#define LocaleComponentGenesis PrependMagickMethod(LocaleComponentGenesis)
#define LocaleComponentTerminus PrependMagickMethod(LocaleComponentTerminus)
#define LocaleLowercase PrependMagickMethod(LocaleLowercase)
#define LocaleLower PrependMagickMethod(LocaleLower)
#define LocaleNCompare PrependMagickMethod(LocaleNCompare)
#define LocaleUppercase PrependMagickMethod(LocaleUppercase)
#define LocaleUpper PrependMagickMethod(LocaleUpper)
#define LockSemaphoreInfo PrependMagickMethod(LockSemaphoreInfo)
#define LogComponentGenesis PrependMagickMethod(LogComponentGenesis)
#define LogComponentTerminus PrependMagickMethod(LogComponentTerminus)
#define LogMagickEventList PrependMagickMethod(LogMagickEventList)
#define LogMagickEvent PrependMagickMethod(LogMagickEvent)
#define LZWEncodeImage PrependMagickMethod(LZWEncodeImage)
#define MagicComponentGenesis PrependMagickMethod(MagicComponentGenesis)
#define MagicComponentTerminus PrependMagickMethod(MagicComponentTerminus)
#define MagickComponentGenesis PrependMagickMethod(MagickComponentGenesis)
#define MagickComponentTerminus PrependMagickMethod(MagickComponentTerminus)
#define MagickCoreGenesis PrependMagickMethod(MagickCoreGenesis)
#define MagickCoreTerminus PrependMagickMethod(MagickCoreTerminus)
#define MagickCreateThreadKey PrependMagickMethod(MagickCreateThreadKey)
#define MagickDelay PrependMagickMethod(MagickDelay)
#define MagickDeleteThreadKey PrependMagickMethod(MagickDeleteThreadKey)
#define MagickGetThreadValue PrependMagickMethod(MagickGetThreadValue)
#define MagickIncarnate PrependMagickMethod(MagickIncarnate)
#define MagickMonitor PrependMagickMethod(MagickMonitor)
#define MagickSetThreadValue PrependMagickMethod(MagickSetThreadValue)
#define MagickToMime PrependMagickMethod(MagickToMime)
#define MagnifyImage PrependMagickMethod(MagnifyImage)
#define MapBlob PrependMagickMethod(MapBlob)
#define MapImage PrependMagickMethod(MapImage)
#define MapImages PrependMagickMethod(MapImages)
#define MatrixToImage PrependMagickMethod(MatrixToImage)
#define MatteFloodfillImage PrependMagickMethod(MatteFloodfillImage)
#define MaximumImages PrependMagickMethod(MaximumImages)
#define MeanShiftImage PrependMagickMethod(MeanShiftImage)
#define MedianFilterImage PrependMagickMethod(MedianFilterImage)
#define MergeImageLayers PrependMagickMethod(MergeImageLayers)
#define MimeComponentGenesis PrependMagickMethod(MimeComponentGenesis)
#define MimeComponentTerminus PrependMagickMethod(MimeComponentTerminus)
#define MinifyImage PrependMagickMethod(MinifyImage)
#define MinimumImages PrependMagickMethod(MinimumImages)
#define MinMaxStretchImage PrependMagickMethod(MinMaxStretchImage)
#define ModeImage PrependMagickMethod(ModeImage)
#define ModifyImage PrependMagickMethod(ModifyImage)
#define ModulateImage PrependMagickMethod(ModulateImage)
#define MonitorComponentGenesis PrependMagickMethod(MonitorComponentGenesis)
#define MonitorComponentTerminus PrependMagickMethod(MonitorComponentTerminus)
#define MontageImageList PrependMagickMethod(MontageImageList)
#define MontageImages PrependMagickMethod(MontageImages)
#define MorphImages PrependMagickMethod(MorphImages)
#define MorphologyApply PrependMagickMethod(MorphologyApply)
#define MorphologyImageChannel PrependMagickMethod(MorphologyImageChannel)
#define MorphologyImage PrependMagickMethod(MorphologyImage)
#define MosaicImages PrependMagickMethod(MosaicImages)
#define MotionBlurImageChannel PrependMagickMethod(MotionBlurImageChannel)
#define MotionBlurImage PrependMagickMethod(MotionBlurImage)
#define MSBOrderLong PrependMagickMethod(MSBOrderLong)
#define MSBOrderShort PrependMagickMethod(MSBOrderShort)
#define MultilineCensus PrependMagickMethod(MultilineCensus)
#define NegateImageChannel PrependMagickMethod(NegateImageChannel)
#define NegateImage PrependMagickMethod(NegateImage)
#define NewHashmap PrependMagickMethod(NewHashmap)
#define NewImageList PrependMagickMethod(NewImageList)
#define NewImageView PrependMagickMethod(NewImageView)
#define NewImageViewRegion PrependMagickMethod(NewImageViewRegion)
#define NewLinkedList PrependMagickMethod(NewLinkedList)
#define NewMagickImage PrependMagickMethod(NewMagickImage)
#define NewSplayTree PrependMagickMethod(NewSplayTree)
#define NewXMLTree PrependMagickMethod(NewXMLTree)
#define NewXMLTreeTag PrependMagickMethod(NewXMLTreeTag)
#define NormalizeImageChannel PrependMagickMethod(NormalizeImageChannel)
#define NormalizeImage PrependMagickMethod(NormalizeImage)
#define NullMatrix PrependMagickMethod(NullMatrix)
#define OilPaintImage PrependMagickMethod(OilPaintImage)
#define OpaqueImage PrependMagickMethod(OpaqueImage)
#define OpaquePaintImageChannel PrependMagickMethod(OpaquePaintImageChannel)
#define OpaquePaintImage PrependMagickMethod(OpaquePaintImage)
#define OpenBlob PrependMagickMethod(OpenBlob)
#define OpenCacheView PrependMagickMethod(OpenCacheView)
#define OpenDistributePixelCache PrependMagickMethod(OpenDistributePixelCache)
#define OpenMagickStream PrependMagickMethod(OpenMagickStream)
#define OpenStream PrependMagickMethod(OpenStream)
#define OptimizeImageLayers PrependMagickMethod(OptimizeImageLayers)
#define OptimizeImageTransparency PrependMagickMethod(OptimizeImageTransparency)
#define OptimizePlusImageLayers PrependMagickMethod(OptimizePlusImageLayers)
#define OrderedDitherImageChannel PrependMagickMethod(OrderedDitherImageChannel)
#define OrderedDitherImage PrependMagickMethod(OrderedDitherImage)
#define OrderedPosterizeImageChannel PrependMagickMethod(OrderedPosterizeImageChannel)
#define OrderedPosterizeImage PrependMagickMethod(OrderedPosterizeImage)
#define PackbitsEncodeImage PrependMagickMethod(PackbitsEncodeImage)
#define PaintFloodfillImage PrependMagickMethod(PaintFloodfillImage)
#define PaintOpaqueImageChannel PrependMagickMethod(PaintOpaqueImageChannel)
#define PaintOpaqueImage PrependMagickMethod(PaintOpaqueImage)
#define PaintTransparentImage PrependMagickMethod(PaintTransparentImage)
#define ParseAbsoluteGeometry PrependMagickMethod(ParseAbsoluteGeometry)
#define ParseAffineGeometry PrependMagickMethod(ParseAffineGeometry)
#define ParseChannelOption PrependMagickMethod(ParseChannelOption)
#define ParseCommandOption PrependMagickMethod(ParseCommandOption)
#define ParseGeometry PrependMagickMethod(ParseGeometry)
#define ParseGravityGeometry PrependMagickMethod(ParseGravityGeometry)
#define ParseImageGeometry PrependMagickMethod(ParseImageGeometry)
#define ParseMetaGeometry PrependMagickMethod(ParseMetaGeometry)
#define ParsePageGeometry PrependMagickMethod(ParsePageGeometry)
#define ParseRegionGeometry PrependMagickMethod(ParseRegionGeometry)
#define ParseSizeGeometry PrependMagickMethod(ParseSizeGeometry)
#define PasskeyDecipherImage PrependMagickMethod(PasskeyDecipherImage)
#define PasskeyEncipherImage PrependMagickMethod(PasskeyEncipherImage)
#define PerceptibleImageChannel PrependMagickMethod(PerceptibleImageChannel)
#define PerceptibleImage PrependMagickMethod(PerceptibleImage)
#define PersistPixelCache PrependMagickMethod(PersistPixelCache)
#define PingBlob PrependMagickMethod(PingBlob)
#define PingImage PrependMagickMethod(PingImage)
#define PingImages PrependMagickMethod(PingImages)
#define PlasmaImage PrependMagickMethod(PlasmaImage)
#define PlasmaImageProxy PrependMagickMethod(PlasmaImageProxy)
#define PolaroidImage PrependMagickMethod(PolaroidImage)
#define PolicyComponentGenesis PrependMagickMethod(PolicyComponentGenesis)
#define PolicyComponentTerminus PrependMagickMethod(PolicyComponentTerminus)
#define PolynomialImageChannel PrependMagickMethod(PolynomialImageChannel)
#define PolynomialImage PrependMagickMethod(PolynomialImage)
#define PopImageList PrependMagickMethod(PopImageList)
#define PopImagePixels PrependMagickMethod(PopImagePixels)
#define PosterizeImageChannel PrependMagickMethod(PosterizeImageChannel)
#define PosterizeImage PrependMagickMethod(PosterizeImage)
#define PostscriptGeometry PrependMagickMethod(PostscriptGeometry)
#define PrependImageToList PrependMagickMethod(PrependImageToList)
#define PreviewImage PrependMagickMethod(PreviewImage)
#define PrintStringInfo PrependMagickMethod(PrintStringInfo)
#define process_message PrependMagickMethod(process_message)
#define ProfileImage PrependMagickMethod(ProfileImage)
#define PruneTagFromXMLTree PrependMagickMethod(PruneTagFromXMLTree)
#define PushImageList PrependMagickMethod(PushImageList)
#define PushImagePixels PrependMagickMethod(PushImagePixels)
#define PutEntryInHashmap PrependMagickMethod(PutEntryInHashmap)
#define QuantizationError PrependMagickMethod(QuantizationError)
#define QuantizeImage PrependMagickMethod(QuantizeImage)
#define QuantizeImages PrependMagickMethod(QuantizeImages)
#define QueryColorCompliance PrependMagickMethod(QueryColorCompliance)
#define QueryColorDatabase PrependMagickMethod(QueryColorDatabase)
#define QueryColorname PrependMagickMethod(QueryColorname)
#define QueryMagickColorCompliance PrependMagickMethod(QueryMagickColorCompliance)
#define QueryMagickColorname PrependMagickMethod(QueryMagickColorname)
#define QueryMagickColor PrependMagickMethod(QueryMagickColor)
#define QueueAuthenticPixelCacheNexus PrependMagickMethod(QueueAuthenticPixelCacheNexus)
#define QueueAuthenticPixel PrependMagickMethod(QueueAuthenticPixel)
#define QueueAuthenticPixels PrependMagickMethod(QueueAuthenticPixels)
#define QueueCacheViewAuthenticPixels PrependMagickMethod(QueueCacheViewAuthenticPixels)
#define RadialBlurImageChannel PrependMagickMethod(RadialBlurImageChannel)
#define RadialBlurImage PrependMagickMethod(RadialBlurImage)
#define RaiseImage PrependMagickMethod(RaiseImage)
#define RandomChannelThresholdImage PrependMagickMethod(RandomChannelThresholdImage)
#define RandomComponentGenesis PrependMagickMethod(RandomComponentGenesis)
#define RandomComponentTerminus PrependMagickMethod(RandomComponentTerminus)
#define RandomThresholdImageChannel PrependMagickMethod(RandomThresholdImageChannel)
#define RandomThresholdImage PrependMagickMethod(RandomThresholdImage)
#define ReacquireMemory PrependMagickMethod(ReacquireMemory)
#define ReadBlobByte PrependMagickMethod(ReadBlobByte)
#define ReadBlobDouble PrependMagickMethod(ReadBlobDouble)
#define ReadBlobFloat PrependMagickMethod(ReadBlobFloat)
#define ReadBlobLongLong PrependMagickMethod(ReadBlobLongLong)
#define ReadBlobLong PrependMagickMethod(ReadBlobLong)
#define ReadBlobLSBLong PrependMagickMethod(ReadBlobLSBLong)
#define ReadBlobLSBShort PrependMagickMethod(ReadBlobLSBShort)
#define ReadBlobLSBSignedLong PrependMagickMethod(ReadBlobLSBSignedLong)
#define ReadBlobLSBSignedShort PrependMagickMethod(ReadBlobLSBSignedShort)
#define ReadBlobMSBLongLong PrependMagickMethod(ReadBlobMSBLongLong)
#define ReadBlobMSBLong PrependMagickMethod(ReadBlobMSBLong)
#define ReadBlobMSBShort PrependMagickMethod(ReadBlobMSBShort)
#define ReadBlobMSBSignedLong PrependMagickMethod(ReadBlobMSBSignedLong)
#define ReadBlobMSBSignedShort PrependMagickMethod(ReadBlobMSBSignedShort)
#define ReadBlob PrependMagickMethod(ReadBlob)
#define ReadBlobShort PrependMagickMethod(ReadBlobShort)
#define ReadBlobSignedLong PrependMagickMethod(ReadBlobSignedLong)
#define ReadBlobSignedShort PrependMagickMethod(ReadBlobSignedShort)
#define ReadBlobStream PrependMagickMethod(ReadBlobStream)
#define ReadBlobString PrependMagickMethod(ReadBlobString)
#define ReadDistributePixelCacheIndexes PrependMagickMethod(ReadDistributePixelCacheIndexes)
#define ReadDistributePixelCachePixels PrependMagickMethod(ReadDistributePixelCachePixels)
#define ReadImage PrependMagickMethod(ReadImage)
#define ReadImages PrependMagickMethod(ReadImages)
#define ReadInlineImage PrependMagickMethod(ReadInlineImage)
#define ReadPSDLayers PrependMagickMethod(ReadPSDLayers)
#define ReadStream PrependMagickMethod(ReadStream)
#define RecolorImage PrependMagickMethod(RecolorImage)
#define ReduceNoiseImage PrependMagickMethod(ReduceNoiseImage)
#define ReferenceBlob PrependMagickMethod(ReferenceBlob)
#define ReferenceImage PrependMagickMethod(ReferenceImage)
#define ReferencePixelCache PrependMagickMethod(ReferencePixelCache)
#define RegisterAAIImage PrependMagickMethod(RegisterAAIImage)
#define RegisterARTImage PrependMagickMethod(RegisterARTImage)
#define RegisterAVSImage PrependMagickMethod(RegisterAVSImage)
#define RegisterBGRImage PrependMagickMethod(RegisterBGRImage)
#define RegisterBMPImage PrependMagickMethod(RegisterBMPImage)
#define RegisterBRAILLEImage PrependMagickMethod(RegisterBRAILLEImage)
#define RegisterCALSImage PrependMagickMethod(RegisterCALSImage)
#define RegisterCAPTIONImage PrependMagickMethod(RegisterCAPTIONImage)
#define RegisterCINImage PrependMagickMethod(RegisterCINImage)
#define RegisterCIPImage PrependMagickMethod(RegisterCIPImage)
#define RegisterCLIPImage PrependMagickMethod(RegisterCLIPImage)
#define RegisterCMYKImage PrependMagickMethod(RegisterCMYKImage)
#define RegisterCUTImage PrependMagickMethod(RegisterCUTImage)
#define RegisterDCMImage PrependMagickMethod(RegisterDCMImage)
#define RegisterDDSImage PrependMagickMethod(RegisterDDSImage)
#define RegisterDEBUGImage PrependMagickMethod(RegisterDEBUGImage)
#define RegisterDIBImage PrependMagickMethod(RegisterDIBImage)
#define RegisterDJVUImage PrependMagickMethod(RegisterDJVUImage)
#define RegisterDNGImage PrependMagickMethod(RegisterDNGImage)
#define RegisterDOTImage PrependMagickMethod(RegisterDOTImage)
#define RegisterDPXImage PrependMagickMethod(RegisterDPXImage)
#define RegisterEPTImage PrependMagickMethod(RegisterEPTImage)
#define RegisterEXRImage PrependMagickMethod(RegisterEXRImage)
#define RegisterFAXImage PrependMagickMethod(RegisterFAXImage)
#define RegisterFITSImage PrependMagickMethod(RegisterFITSImage)
#define RegisterGIFImage PrependMagickMethod(RegisterGIFImage)
#define RegisterGRADIENTImage PrependMagickMethod(RegisterGRADIENTImage)
#define RegisterGRAYImage PrependMagickMethod(RegisterGRAYImage)
#define RegisterHALDImage PrependMagickMethod(RegisterHALDImage)
#define RegisterHDRImage PrependMagickMethod(RegisterHDRImage)
#define RegisterHEICImage PrependMagickMethod(RegisterHEICImage)
#define RegisterHISTOGRAMImage PrependMagickMethod(RegisterHISTOGRAMImage)
#define RegisterHRZImage PrependMagickMethod(RegisterHRZImage)
#define RegisterHTMLImage PrependMagickMethod(RegisterHTMLImage)
#define RegisterICONImage PrependMagickMethod(RegisterICONImage)
#define RegisterINFOImage PrependMagickMethod(RegisterINFOImage)
#define RegisterINLINEImage PrependMagickMethod(RegisterINLINEImage)
#define RegisterIPLImage PrependMagickMethod(RegisterIPLImage)
#define RegisterJBIGImage PrependMagickMethod(RegisterJBIGImage)
#define RegisterJNXImage PrependMagickMethod(RegisterJNXImage)
#define RegisterJP2Image PrependMagickMethod(RegisterJP2Image)
#define RegisterJPEGImage PrependMagickMethod(RegisterJPEGImage)
#define RegisterJSONImage PrependMagickMethod(RegisterJSONImage)
#define RegisterLABELImage PrependMagickMethod(RegisterLABELImage)
#define RegisterMACImage PrependMagickMethod(RegisterMACImage)
#define RegisterMAGICKImage PrependMagickMethod(RegisterMAGICKImage)
#define RegisterMagickInfo PrependMagickMethod(RegisterMagickInfo)
#define RegisterMAPImage PrependMagickMethod(RegisterMAPImage)
#define RegisterMASKImage PrependMagickMethod(RegisterMASKImage)
#define RegisterMATImage PrependMagickMethod(RegisterMATImage)
#define RegisterMATTEImage PrependMagickMethod(RegisterMATTEImage)
#define RegisterMETAImage PrependMagickMethod(RegisterMETAImage)
#define RegisterMIFFImage PrependMagickMethod(RegisterMIFFImage)
#define RegisterMONOImage PrependMagickMethod(RegisterMONOImage)
#define RegisterMPCImage PrependMagickMethod(RegisterMPCImage)
#define RegisterMPRImage PrependMagickMethod(RegisterMPRImage)
#define RegisterMSLImage PrependMagickMethod(RegisterMSLImage)
#define RegisterMTVImage PrependMagickMethod(RegisterMTVImage)
#define RegisterMVGImage PrependMagickMethod(RegisterMVGImage)
#define RegisterNULLImage PrependMagickMethod(RegisterNULLImage)
#define RegisterOTBImage PrependMagickMethod(RegisterOTBImage)
#define RegisterPALMImage PrependMagickMethod(RegisterPALMImage)
#define RegisterPANGOImage PrependMagickMethod(RegisterPANGOImage)
#define RegisterPATTERNImage PrependMagickMethod(RegisterPATTERNImage)
#define RegisterPCDImage PrependMagickMethod(RegisterPCDImage)
#define RegisterPCLImage PrependMagickMethod(RegisterPCLImage)
#define RegisterPCXImage PrependMagickMethod(RegisterPCXImage)
#define RegisterPDBImage PrependMagickMethod(RegisterPDBImage)
#define RegisterPDFImage PrependMagickMethod(RegisterPDFImage)
#define RegisterPESImage PrependMagickMethod(RegisterPESImage)
#define RegisterPGXImage PrependMagickMethod(RegisterPGXImage)
#define RegisterPICTImage PrependMagickMethod(RegisterPICTImage)
#define RegisterPIXImage PrependMagickMethod(RegisterPIXImage)
#define RegisterPLASMAImage PrependMagickMethod(RegisterPLASMAImage)
#define RegisterPNGImage PrependMagickMethod(RegisterPNGImage)
#define RegisterPNMImage PrependMagickMethod(RegisterPNMImage)
#define RegisterPREVIEWImage PrependMagickMethod(RegisterPREVIEWImage)
#define RegisterPS2Image PrependMagickMethod(RegisterPS2Image)
#define RegisterPS3Image PrependMagickMethod(RegisterPS3Image)
#define RegisterPSDImage PrependMagickMethod(RegisterPSDImage)
#define RegisterPSImage PrependMagickMethod(RegisterPSImage)
#define RegisterPWPImage PrependMagickMethod(RegisterPWPImage)
#define RegisterRAWImage PrependMagickMethod(RegisterRAWImage)
#define RegisterRGBImage PrependMagickMethod(RegisterRGBImage)
#define RegisterRGFImage PrependMagickMethod(RegisterRGFImage)
#define RegisterRLAImage PrependMagickMethod(RegisterRLAImage)
#define RegisterRLEImage PrependMagickMethod(RegisterRLEImage)
#define RegisterSCREENSHOTImage PrependMagickMethod(RegisterSCREENSHOTImage)
#define RegisterSCRImage PrependMagickMethod(RegisterSCRImage)
#define RegisterSCTImage PrependMagickMethod(RegisterSCTImage)
#define RegisterSFWImage PrependMagickMethod(RegisterSFWImage)
#define RegisterSGIImage PrependMagickMethod(RegisterSGIImage)
#define RegisterSIXELImage PrependMagickMethod(RegisterSIXELImage)
#define RegisterStaticModule PrependMagickMethod(RegisterStaticModule)
#define RegisterStaticModules PrependMagickMethod(RegisterStaticModules)
#define RegisterSTEGANOImage PrependMagickMethod(RegisterSTEGANOImage)
#define RegisterSUNImage PrependMagickMethod(RegisterSUNImage)
#define RegisterSVGImage PrependMagickMethod(RegisterSVGImage)
#define RegisterTGAImage PrependMagickMethod(RegisterTGAImage)
#define RegisterTHUMBNAILImage PrependMagickMethod(RegisterTHUMBNAILImage)
#define RegisterTIFFImage PrependMagickMethod(RegisterTIFFImage)
#define RegisterTILEImage PrependMagickMethod(RegisterTILEImage)
#define RegisterTIMImage PrependMagickMethod(RegisterTIMImage)
#define RegisterTTFImage PrependMagickMethod(RegisterTTFImage)
#define RegisterTXTImage PrependMagickMethod(RegisterTXTImage)
#define RegisterUILImage PrependMagickMethod(RegisterUILImage)
#define RegisterUndefinedImage PrependMagickMethod(RegisterUndefinedImage)
#define RegisterURLImage PrependMagickMethod(RegisterURLImage)
#define RegisterUYVYImage PrependMagickMethod(RegisterUYVYImage)
#define RegisterVICARImage PrependMagickMethod(RegisterVICARImage)
#define RegisterVIDEOImage PrependMagickMethod(RegisterVIDEOImage)
#define RegisterVIDImage PrependMagickMethod(RegisterVIDImage)
#define RegisterVIFFImage PrependMagickMethod(RegisterVIFFImage)
#define RegisterVIPSImage PrependMagickMethod(RegisterVIPSImage)
#define RegisterWBMPImage PrependMagickMethod(RegisterWBMPImage)
#define RegisterWEBPImage PrependMagickMethod(RegisterWEBPImage)
#define RegisterWPGImage PrependMagickMethod(RegisterWPGImage)
#define RegisterXBMImage PrependMagickMethod(RegisterXBMImage)
#define RegisterXCFImage PrependMagickMethod(RegisterXCFImage)
#define RegisterXCImage PrependMagickMethod(RegisterXCImage)
#define RegisterXImage PrependMagickMethod(RegisterXImage)
#define RegisterXPMImage PrependMagickMethod(RegisterXPMImage)
#define RegisterXPSImage PrependMagickMethod(RegisterXPSImage)
#define RegisterXWDImage PrependMagickMethod(RegisterXWDImage)
#define RegisterYCBCRImage PrependMagickMethod(RegisterYCBCRImage)
#define RegisterYUVImage PrependMagickMethod(RegisterYUVImage)
#define RegistryComponentGenesis PrependMagickMethod(RegistryComponentGenesis)
#define RegistryComponentTerminus PrependMagickMethod(RegistryComponentTerminus)
#define RelinquishAlignedMemory PrependMagickMethod(RelinquishAlignedMemory)
#define RelinquishDistributePixelCache PrependMagickMethod(RelinquishDistributePixelCache)
#define RelinquishMagickMatrix PrependMagickMethod(RelinquishMagickMatrix)
#define RelinquishMagickMemory PrependMagickMethod(RelinquishMagickMemory)
#define RelinquishMagickResource PrependMagickMethod(RelinquishMagickResource)
#define RelinquishSemaphoreInfo PrependMagickMethod(RelinquishSemaphoreInfo)
#define RelinquishUniqueFileResource PrependMagickMethod(RelinquishUniqueFileResource)
#define RelinquishVirtualMemory PrependMagickMethod(RelinquishVirtualMemory)
#define RemapImage PrependMagickMethod(RemapImage)
#define RemapImages PrependMagickMethod(RemapImages)
#define RemoteDisplayCommand PrependMagickMethod(RemoteDisplayCommand)
#define RemoveDuplicateLayers PrependMagickMethod(RemoveDuplicateLayers)
#define RemoveElementByValueFromLinkedList PrependMagickMethod(RemoveElementByValueFromLinkedList)
#define RemoveElementFromLinkedList PrependMagickMethod(RemoveElementFromLinkedList)
#define RemoveEntryFromHashmap PrependMagickMethod(RemoveEntryFromHashmap)
#define RemoveFirstImageFromList PrependMagickMethod(RemoveFirstImageFromList)
#define RemoveImageArtifact PrependMagickMethod(RemoveImageArtifact)
#define RemoveImageFromList PrependMagickMethod(RemoveImageFromList)
#define RemoveImageOption PrependMagickMethod(RemoveImageOption)
#define RemoveImageProfile PrependMagickMethod(RemoveImageProfile)
#define RemoveImageProperty PrependMagickMethod(RemoveImageProperty)
#define RemoveImageRegistry PrependMagickMethod(RemoveImageRegistry)
#define RemoveLastElementFromLinkedList PrependMagickMethod(RemoveLastElementFromLinkedList)
#define RemoveLastImageFromList PrependMagickMethod(RemoveLastImageFromList)
#define RemoveNodeByValueFromSplayTree PrependMagickMethod(RemoveNodeByValueFromSplayTree)
#define RemoveNodeFromSplayTree PrependMagickMethod(RemoveNodeFromSplayTree)
#define RemoveZeroDelayLayers PrependMagickMethod(RemoveZeroDelayLayers)
#define ReplaceImageInList PrependMagickMethod(ReplaceImageInList)
#define ReplaceImageInListReturnLast PrependMagickMethod(ReplaceImageInListReturnLast)
#define ResampleImage PrependMagickMethod(ResampleImage)
#define ResamplePixelColor PrependMagickMethod(ResamplePixelColor)
#define ResetHashmapIterator PrependMagickMethod(ResetHashmapIterator)
#define ResetImageArtifactIterator PrependMagickMethod(ResetImageArtifactIterator)
#define ResetImageAttributeIterator PrependMagickMethod(ResetImageAttributeIterator)
#define ResetImageOptionIterator PrependMagickMethod(ResetImageOptionIterator)
#define ResetImageOptions PrependMagickMethod(ResetImageOptions)
#define ResetImagePage PrependMagickMethod(ResetImagePage)
#define ResetImagePixels PrependMagickMethod(ResetImagePixels)
#define ResetImageProfileIterator PrependMagickMethod(ResetImageProfileIterator)
#define ResetImagePropertyIterator PrependMagickMethod(ResetImagePropertyIterator)
#define ResetImageRegistryIterator PrependMagickMethod(ResetImageRegistryIterator)
#define ResetLinkedListIterator PrependMagickMethod(ResetLinkedListIterator)
#define ResetMagickMemory PrependMagickMethod(ResetMagickMemory)
#define ResetMaxMemoryRequest PrependMagickMethod(ResetMaxMemoryRequest)
#define ResetPixelCacheEpoch PrependMagickMethod(ResetPixelCacheEpoch)
#define ResetQuantumState PrependMagickMethod(ResetQuantumState)
#define ResetSplayTreeIterator PrependMagickMethod(ResetSplayTreeIterator)
#define ResetSplayTree PrependMagickMethod(ResetSplayTree)
#define ResetStringInfo PrependMagickMethod(ResetStringInfo)
#define ResetTimer PrependMagickMethod(ResetTimer)
#define ResetVirtualAnonymousMemory PrependMagickMethod(ResetVirtualAnonymousMemory)
#define ResizeImage PrependMagickMethod(ResizeImage)
#define ResizeMagickMemory PrependMagickMethod(ResizeMagickMemory)
#define ResizeQuantumMemory PrependMagickMethod(ResizeQuantumMemory)
#define ResourceComponentGenesis PrependMagickMethod(ResourceComponentGenesis)
#define ResourceComponentTerminus PrependMagickMethod(ResourceComponentTerminus)
#define ReverseImageList PrependMagickMethod(ReverseImageList)
#define RGBTransformImage PrependMagickMethod(RGBTransformImage)
#define RollImage PrependMagickMethod(RollImage)
#define RotateImage PrependMagickMethod(RotateImage)
#define RotationalBlurImageChannel PrependMagickMethod(RotationalBlurImageChannel)
#define RotationalBlurImage PrependMagickMethod(RotationalBlurImage)
#define SampleImage PrependMagickMethod(SampleImage)
#define SanitizeString PrependMagickMethod(SanitizeString)
#define ScaleGeometryKernelInfo PrependMagickMethod(ScaleGeometryKernelInfo)
#define ScaleImage PrependMagickMethod(ScaleImage)
#define ScaleKernelInfo PrependMagickMethod(ScaleKernelInfo)
#define ScaleResampleFilter PrependMagickMethod(ScaleResampleFilter)
#define SeedPseudoRandomGenerator PrependMagickMethod(SeedPseudoRandomGenerator)
#define SeekBlob PrependMagickMethod(SeekBlob)
#define SegmentImage PrependMagickMethod(SegmentImage)
#define SelectiveBlurImageChannel PrependMagickMethod(SelectiveBlurImageChannel)
#define SelectiveBlurImage PrependMagickMethod(SelectiveBlurImage)
#define SemaphoreComponentGenesis PrependMagickMethod(SemaphoreComponentGenesis)
#define SemaphoreComponentTerminus PrependMagickMethod(SemaphoreComponentTerminus)
#define SeparateImageChannel PrependMagickMethod(SeparateImageChannel)
#define SeparateImage PrependMagickMethod(SeparateImage)
#define SeparateImages PrependMagickMethod(SeparateImages)
#define SepiaToneImage PrependMagickMethod(SepiaToneImage)
#define SetBlobExempt PrependMagickMethod(SetBlobExempt)
#define SetBlobExtent PrependMagickMethod(SetBlobExtent)
#define SetCacheThreshold PrependMagickMethod(SetCacheThreshold)
#define SetCacheViewPixels PrependMagickMethod(SetCacheViewPixels)
#define SetCacheViewStorageClass PrependMagickMethod(SetCacheViewStorageClass)
#define SetCacheViewVirtualPixelMethod PrependMagickMethod(SetCacheViewVirtualPixelMethod)
#define SetClientName PrependMagickMethod(SetClientName)
#define SetClientPath PrependMagickMethod(SetClientPath)
#define SetErrorHandler PrependMagickMethod(SetErrorHandler)
#define SetExceptionInfo PrependMagickMethod(SetExceptionInfo)
#define SetFatalErrorHandler PrependMagickMethod(SetFatalErrorHandler)
#define SetGeometryInfo PrependMagickMethod(SetGeometryInfo)
#define SetGeometry PrependMagickMethod(SetGeometry)
#define SetHeadElementInLinkedList PrependMagickMethod(SetHeadElementInLinkedList)
#define SetImageAlphaChannel PrependMagickMethod(SetImageAlphaChannel)
#define SetImageArtifact PrependMagickMethod(SetImageArtifact)
#define SetImageAttribute PrependMagickMethod(SetImageAttribute)
#define SetImageBackgroundColor PrependMagickMethod(SetImageBackgroundColor)
#define SetImageChannelDepth PrependMagickMethod(SetImageChannelDepth)
#define SetImageChannels PrependMagickMethod(SetImageChannels)
#define SetImageClipMask PrependMagickMethod(SetImageClipMask)
#define SetImageColor PrependMagickMethod(SetImageColor)
#define SetImageColorspace PrependMagickMethod(SetImageColorspace)
#define SetImageDepth PrependMagickMethod(SetImageDepth)
#define SetImageExtent PrependMagickMethod(SetImageExtent)
#define SetImageGray PrependMagickMethod(SetImageGray)
#define SetImageInfoBlob PrependMagickMethod(SetImageInfoBlob)
#define SetImageInfoFile PrependMagickMethod(SetImageInfoFile)
#define SetImageInfo PrependMagickMethod(SetImageInfo)
#define SetImageInfoProgressMonitor PrependMagickMethod(SetImageInfoProgressMonitor)
#define SetImageList PrependMagickMethod(SetImageList)
#define SetImageMask PrependMagickMethod(SetImageMask)
#define SetImageMonochrome PrependMagickMethod(SetImageMonochrome)
#define SetImageOpacity PrependMagickMethod(SetImageOpacity)
#define SetImageOption PrependMagickMethod(SetImageOption)
#define SetImagePixels PrependMagickMethod(SetImagePixels)
#define SetImage PrependMagickMethod(SetImage)
#define SetImageProfile PrependMagickMethod(SetImageProfile)
#define SetImageProgressMonitor PrependMagickMethod(SetImageProgressMonitor)
#define SetImageProgress PrependMagickMethod(SetImageProgress)
#define SetImageProperty PrependMagickMethod(SetImageProperty)
#define SetImageRegistry PrependMagickMethod(SetImageRegistry)
#define SetImageStorageClass PrependMagickMethod(SetImageStorageClass)
#define SetImageType PrependMagickMethod(SetImageType)
#define SetImageViewDescription PrependMagickMethod(SetImageViewDescription)
#define SetImageViewIterator PrependMagickMethod(SetImageViewIterator)
#define SetImageViewThreads PrependMagickMethod(SetImageViewThreads)
#define SetImageVirtualPixelMethod PrependMagickMethod(SetImageVirtualPixelMethod)
#define SetLogEventMask PrependMagickMethod(SetLogEventMask)
#define SetLogFormat PrependMagickMethod(SetLogFormat)
#define SetLogMethod PrependMagickMethod(SetLogMethod)
#define SetLogName PrependMagickMethod(SetLogName)
#define SetMagickAlignedMemoryMethods PrependMagickMethod(SetMagickAlignedMemoryMethods)
#define SetMagickInfo PrependMagickMethod(SetMagickInfo)
#define SetMagickMemoryMethods PrependMagickMethod(SetMagickMemoryMethods)
#define SetMagickOpenCLEnvParam PrependMagickMethod(SetMagickOpenCLEnvParam)
#define SetMagickPrecision PrependMagickMethod(SetMagickPrecision)
#define SetMagickRegistry PrependMagickMethod(SetMagickRegistry)
#define SetMagickResourceLimit PrependMagickMethod(SetMagickResourceLimit)
#define SetMagickSecurityPolicy PrependMagickMethod(SetMagickSecurityPolicy)
#define SetMagickThreadValue PrependMagickMethod(SetMagickThreadValue)
#define SetMatrixElement PrependMagickMethod(SetMatrixElement)
#define SetMonitorHandler PrependMagickMethod(SetMonitorHandler)
#define SetPixelCacheMethods PrependMagickMethod(SetPixelCacheMethods)
#define SetPixelCacheVirtualMethod PrependMagickMethod(SetPixelCacheVirtualMethod)
#define SetQuantumAlphaType PrependMagickMethod(SetQuantumAlphaType)
#define SetQuantumDepth PrependMagickMethod(SetQuantumDepth)
#define SetQuantumEndian PrependMagickMethod(SetQuantumEndian)
#define SetQuantumFormat PrependMagickMethod(SetQuantumFormat)
#define SetQuantumImageType PrependMagickMethod(SetQuantumImageType)
#define SetQuantumMinIsWhite PrependMagickMethod(SetQuantumMinIsWhite)
#define SetQuantumPack PrependMagickMethod(SetQuantumPack)
#define SetQuantumPad PrependMagickMethod(SetQuantumPad)
#define SetQuantumQuantum PrependMagickMethod(SetQuantumQuantum)
#define SetQuantumScale PrependMagickMethod(SetQuantumScale)
#define SetRandomKey PrependMagickMethod(SetRandomKey)
#define SetRandomSecretKey PrependMagickMethod(SetRandomSecretKey)
#define SetRandomTrueRandom PrependMagickMethod(SetRandomTrueRandom)
#define SetResampleFilterInterpolateMethod PrependMagickMethod(SetResampleFilterInterpolateMethod)
#define SetResampleFilter PrependMagickMethod(SetResampleFilter)
#define SetResampleFilterVirtualPixelMethod PrependMagickMethod(SetResampleFilterVirtualPixelMethod)
#define SetSignatureDigest PrependMagickMethod(SetSignatureDigest)
#define SetStreamInfoClientData PrependMagickMethod(SetStreamInfoClientData)
#define SetStreamInfoMap PrependMagickMethod(SetStreamInfoMap)
#define SetStreamInfoStorageType PrependMagickMethod(SetStreamInfoStorageType)
#define SetStringInfoDatum PrependMagickMethod(SetStringInfoDatum)
#define SetStringInfoLength PrependMagickMethod(SetStringInfoLength)
#define SetStringInfoName PrependMagickMethod(SetStringInfoName)
#define SetStringInfoPath PrependMagickMethod(SetStringInfoPath)
#define SetStringInfo PrependMagickMethod(SetStringInfo)
#define SetWarningHandler PrependMagickMethod(SetWarningHandler)
#define SetXMLTreeAttribute PrependMagickMethod(SetXMLTreeAttribute)
#define SetXMLTreeContent PrependMagickMethod(SetXMLTreeContent)
#define ShadeImage PrependMagickMethod(ShadeImage)
#define ShadowImage PrependMagickMethod(ShadowImage)
#define SharpenImageChannel PrependMagickMethod(SharpenImageChannel)
#define SharpenImage PrependMagickMethod(SharpenImage)
#define ShaveImage PrependMagickMethod(ShaveImage)
#define ShearImage PrependMagickMethod(ShearImage)
#define ShearRotateImage PrependMagickMethod(ShearRotateImage)
#define ShiftImageList PrependMagickMethod(ShiftImageList)
#define ShowKernelInfo PrependMagickMethod(ShowKernelInfo)
#define ShredFile PrependMagickMethod(ShredFile)
#define ShredMagickMemory PrependMagickMethod(ShredMagickMemory)
#define SigmoidalContrastImageChannel PrependMagickMethod(SigmoidalContrastImageChannel)
#define SigmoidalContrastImage PrependMagickMethod(SigmoidalContrastImage)
#define SignatureImage PrependMagickMethod(SignatureImage)
#define SimilarityImage PrependMagickMethod(SimilarityImage)
#define SimilarityMetricImage PrependMagickMethod(SimilarityMetricImage)
#define sixel_decode PrependMagickMethod(sixel_decode)
#define sixel_output_create PrependMagickMethod(sixel_output_create)
#define SizeBlob PrependMagickMethod(SizeBlob)
#define SketchImage PrependMagickMethod(SketchImage)
#define SmushImages PrependMagickMethod(SmushImages)
#define SolarizeImageChannel PrependMagickMethod(SolarizeImageChannel)
#define SolarizeImage PrependMagickMethod(SolarizeImage)
#define SortColormapByIntensity PrependMagickMethod(SortColormapByIntensity)
#define SparseColorImage PrependMagickMethod(SparseColorImage)
#define SpliceImageIntoList PrependMagickMethod(SpliceImageIntoList)
#define SpliceImageList PrependMagickMethod(SpliceImageList)
#define SpliceImage PrependMagickMethod(SpliceImage)
#define SplitImageList PrependMagickMethod(SplitImageList)
#define SplitStringInfo PrependMagickMethod(SplitStringInfo)
#define SpreadImage PrependMagickMethod(SpreadImage)
#define sRGBCompandor PrependMagickMethod(sRGBCompandor)
#define StartTimer PrependMagickMethod(StartTimer)
#define StatisticImageChannel PrependMagickMethod(StatisticImageChannel)
#define StatisticImage PrependMagickMethod(StatisticImage)
#define SteganoImage PrependMagickMethod(SteganoImage)
#define StereoAnaglyphImage PrependMagickMethod(StereoAnaglyphImage)
#define StereoImage PrependMagickMethod(StereoImage)
#define StreamImage PrependMagickMethod(StreamImage)
#define StringInfoToHexString PrependMagickMethod(StringInfoToHexString)
#define StringInfoToString PrependMagickMethod(StringInfoToString)
#define StringToArgv PrependMagickMethod(StringToArgv)
#define StringToArrayOfDoubles PrependMagickMethod(StringToArrayOfDoubles)
#define StringToken PrependMagickMethod(StringToken)
#define StringToList PrependMagickMethod(StringToList)
#define StringToStringInfo PrependMagickMethod(StringToStringInfo)
#define StringToStrings PrependMagickMethod(StringToStrings)
#define StripImage PrependMagickMethod(StripImage)
#define Strip PrependMagickMethod(Strip)
#define StripString PrependMagickMethod(StripString)
#define SubstituteString PrependMagickMethod(SubstituteString)
#define SwirlImage PrependMagickMethod(SwirlImage)
#define SyncAuthenticPixelCacheNexus PrependMagickMethod(SyncAuthenticPixelCacheNexus)
#define SyncAuthenticPixels PrependMagickMethod(SyncAuthenticPixels)
#define SyncCacheViewAuthenticPixels PrependMagickMethod(SyncCacheViewAuthenticPixels)
#define SyncCacheViewPixels PrependMagickMethod(SyncCacheViewPixels)
#define SyncCacheView PrependMagickMethod(SyncCacheView)
#define SyncImageList PrependMagickMethod(SyncImageList)
#define SyncImagePixelCache PrependMagickMethod(SyncImagePixelCache)
#define SyncImagePixels PrependMagickMethod(SyncImagePixels)
#define SyncImage PrependMagickMethod(SyncImage)
#define SyncImageProfiles PrependMagickMethod(SyncImageProfiles)
#define SyncImageSettings PrependMagickMethod(SyncImageSettings)
#define SyncImagesSettings PrependMagickMethod(SyncImagesSettings)
#define SyncNextImageInList PrependMagickMethod(SyncNextImageInList)
#define SystemCommand PrependMagickMethod(SystemCommand)
#define TellBlob PrependMagickMethod(TellBlob)
#define TemporaryFilename PrependMagickMethod(TemporaryFilename)
#define TextureImage PrependMagickMethod(TextureImage)
#define ThresholdImageChannel PrependMagickMethod(ThresholdImageChannel)
#define ThresholdImage PrependMagickMethod(ThresholdImage)
#define ThrowMagickExceptionList PrependMagickMethod(ThrowMagickExceptionList)
#define ThrowMagickException PrependMagickMethod(ThrowMagickException)
#define ThumbnailImage PrependMagickMethod(ThumbnailImage)
#define TintImage PrependMagickMethod(TintImage)
#define Tokenizer PrependMagickMethod(Tokenizer)
#define TransferImageViewIterator PrependMagickMethod(TransferImageViewIterator)
#define TransformColorspace PrependMagickMethod(TransformColorspace)
#define TransformHSL PrependMagickMethod(TransformHSL)
#define TransformImageColorspace PrependMagickMethod(TransformImageColorspace)
#define TransformImage PrependMagickMethod(TransformImage)
#define TransformImages PrependMagickMethod(TransformImages)
#define TransformRGBImage PrependMagickMethod(TransformRGBImage)
#define TranslateText PrependMagickMethod(TranslateText)
#define TransparentImage PrependMagickMethod(TransparentImage)
#define TransparentPaintImageChroma PrependMagickMethod(TransparentPaintImageChroma)
#define TransparentPaintImage PrependMagickMethod(TransparentPaintImage)
#define TransposeImage PrependMagickMethod(TransposeImage)
#define TransverseImage PrependMagickMethod(TransverseImage)
#define TrimImage PrependMagickMethod(TrimImage)
#define TypeComponentGenesis PrependMagickMethod(TypeComponentGenesis)
#define TypeComponentTerminus PrependMagickMethod(TypeComponentTerminus)
#define UniqueImageColors PrependMagickMethod(UniqueImageColors)
#define UnityAddKernelInfo PrependMagickMethod(UnityAddKernelInfo)
#define UnlockSemaphoreInfo PrependMagickMethod(UnlockSemaphoreInfo)
#define UnmapBlob PrependMagickMethod(UnmapBlob)
#define UnregisterAAIImage PrependMagickMethod(UnregisterAAIImage)
#define UnregisterARTImage PrependMagickMethod(UnregisterARTImage)
#define UnregisterAVSImage PrependMagickMethod(UnregisterAVSImage)
#define UnregisterBGRImage PrependMagickMethod(UnregisterBGRImage)
#define UnregisterBMPImage PrependMagickMethod(UnregisterBMPImage)
#define UnregisterBRAILLEImage PrependMagickMethod(UnregisterBRAILLEImage)
#define UnregisterCALSImage PrependMagickMethod(UnregisterCALSImage)
#define UnregisterCAPTIONImage PrependMagickMethod(UnregisterCAPTIONImage)
#define UnregisterCINImage PrependMagickMethod(UnregisterCINImage)
#define UnregisterCIPImage PrependMagickMethod(UnregisterCIPImage)
#define UnregisterCLIPImage PrependMagickMethod(UnregisterCLIPImage)
#define UnregisterCMYKImage PrependMagickMethod(UnregisterCMYKImage)
#define UnregisterCUTImage PrependMagickMethod(UnregisterCUTImage)
#define UnregisterDCMImage PrependMagickMethod(UnregisterDCMImage)
#define UnregisterDDSImage PrependMagickMethod(UnregisterDDSImage)
#define UnregisterDEBUGImage PrependMagickMethod(UnregisterDEBUGImage)
#define UnregisterDIBImage PrependMagickMethod(UnregisterDIBImage)
#define UnregisterDJVUImage PrependMagickMethod(UnregisterDJVUImage)
#define UnregisterDNGImage PrependMagickMethod(UnregisterDNGImage)
#define UnregisterDOTImage PrependMagickMethod(UnregisterDOTImage)
#define UnregisterDPXImage PrependMagickMethod(UnregisterDPXImage)
#define UnregisterEPTImage PrependMagickMethod(UnregisterEPTImage)
#define UnregisterEXRImage PrependMagickMethod(UnregisterEXRImage)
#define UnregisterFAXImage PrependMagickMethod(UnregisterFAXImage)
#define UnregisterFITSImage PrependMagickMethod(UnregisterFITSImage)
#define UnregisterGIFImage PrependMagickMethod(UnregisterGIFImage)
#define UnregisterGRADIENTImage PrependMagickMethod(UnregisterGRADIENTImage)
#define UnregisterGRAYImage PrependMagickMethod(UnregisterGRAYImage)
#define UnregisterHALDImage PrependMagickMethod(UnregisterHALDImage)
#define UnregisterHDRImage PrependMagickMethod(UnregisterHDRImage)
#define UnregisterHEICImage PrependMagickMethod(UnregisterHEICImage)
#define UnregisterHISTOGRAMImage PrependMagickMethod(UnregisterHISTOGRAMImage)
#define UnregisterHRZImage PrependMagickMethod(UnregisterHRZImage)
#define UnregisterHTMLImage PrependMagickMethod(UnregisterHTMLImage)
#define UnregisterICONImage PrependMagickMethod(UnregisterICONImage)
#define UnregisterINFOImage PrependMagickMethod(UnregisterINFOImage)
#define UnregisterINLINEImage PrependMagickMethod(UnregisterINLINEImage)
#define UnregisterIPLImage PrependMagickMethod(UnregisterIPLImage)
#define UnregisterJBIGImage PrependMagickMethod(UnregisterJBIGImage)
#define UnregisterJNXImage PrependMagickMethod(UnregisterJNXImage)
#define UnregisterJP2Image PrependMagickMethod(UnregisterJP2Image)
#define UnregisterJPEGImage PrependMagickMethod(UnregisterJPEGImage)
#define UnregisterJSONImage PrependMagickMethod(UnregisterJSONImage)
#define UnregisterLABELImage PrependMagickMethod(UnregisterLABELImage)
#define UnregisterMACImage PrependMagickMethod(UnregisterMACImage)
#define UnregisterMAGICKImage PrependMagickMethod(UnregisterMAGICKImage)
#define UnregisterMagickInfo PrependMagickMethod(UnregisterMagickInfo)
#define UnregisterMAPImage PrependMagickMethod(UnregisterMAPImage)
#define UnregisterMASKImage PrependMagickMethod(UnregisterMASKImage)
#define UnregisterMATImage PrependMagickMethod(UnregisterMATImage)
#define UnregisterMATTEImage PrependMagickMethod(UnregisterMATTEImage)
#define UnregisterMETAImage PrependMagickMethod(UnregisterMETAImage)
#define UnregisterMIFFImage PrependMagickMethod(UnregisterMIFFImage)
#define UnregisterMONOImage PrependMagickMethod(UnregisterMONOImage)
#define UnregisterMPCImage PrependMagickMethod(UnregisterMPCImage)
#define UnregisterMPRImage PrependMagickMethod(UnregisterMPRImage)
#define UnregisterMSLImage PrependMagickMethod(UnregisterMSLImage)
#define UnregisterMTVImage PrependMagickMethod(UnregisterMTVImage)
#define UnregisterMVGImage PrependMagickMethod(UnregisterMVGImage)
#define UnregisterNULLImage PrependMagickMethod(UnregisterNULLImage)
#define UnregisterOTBImage PrependMagickMethod(UnregisterOTBImage)
#define UnregisterPALMImage PrependMagickMethod(UnregisterPALMImage)
#define UnregisterPANGOImage PrependMagickMethod(UnregisterPANGOImage)
#define UnregisterPATTERNImage PrependMagickMethod(UnregisterPATTERNImage)
#define UnregisterPCDImage PrependMagickMethod(UnregisterPCDImage)
#define UnregisterPCLImage PrependMagickMethod(UnregisterPCLImage)
#define UnregisterPCXImage PrependMagickMethod(UnregisterPCXImage)
#define UnregisterPDBImage PrependMagickMethod(UnregisterPDBImage)
#define UnregisterPDFImage PrependMagickMethod(UnregisterPDFImage)
#define UnregisterPESImage PrependMagickMethod(UnregisterPESImage)
#define UnregisterPGXImage PrependMagickMethod(UnregisterPGXImage)
#define UnregisterPICTImage PrependMagickMethod(UnregisterPICTImage)
#define UnregisterPIXImage PrependMagickMethod(UnregisterPIXImage)
#define UnregisterPLASMAImage PrependMagickMethod(UnregisterPLASMAImage)
#define UnregisterPNGImage PrependMagickMethod(UnregisterPNGImage)
#define UnregisterPNMImage PrependMagickMethod(UnregisterPNMImage)
#define UnregisterPREVIEWImage PrependMagickMethod(UnregisterPREVIEWImage)
#define UnregisterPS2Image PrependMagickMethod(UnregisterPS2Image)
#define UnregisterPS3Image PrependMagickMethod(UnregisterPS3Image)
#define UnregisterPSDImage PrependMagickMethod(UnregisterPSDImage)
#define UnregisterPSImage PrependMagickMethod(UnregisterPSImage)
#define UnregisterPWPImage PrependMagickMethod(UnregisterPWPImage)
#define UnregisterRAWImage PrependMagickMethod(UnregisterRAWImage)
#define UnregisterRGBImage PrependMagickMethod(UnregisterRGBImage)
#define UnregisterRGFImage PrependMagickMethod(UnregisterRGFImage)
#define UnregisterRLAImage PrependMagickMethod(UnregisterRLAImage)
#define UnregisterRLEImage PrependMagickMethod(UnregisterRLEImage)
#define UnregisterSCREENSHOTImage PrependMagickMethod(UnregisterSCREENSHOTImage)
#define UnregisterSCRImage PrependMagickMethod(UnregisterSCRImage)
#define UnregisterSCTImage PrependMagickMethod(UnregisterSCTImage)
#define UnregisterSFWImage PrependMagickMethod(UnregisterSFWImage)
#define UnregisterSGIImage PrependMagickMethod(UnregisterSGIImage)
#define UnregisterSIXELImage PrependMagickMethod(UnregisterSIXELImage)
#define UnregisterStaticModule PrependMagickMethod(UnregisterStaticModule)
#define UnregisterStaticModules PrependMagickMethod(UnregisterStaticModules)
#define UnregisterSTEGANOImage PrependMagickMethod(UnregisterSTEGANOImage)
#define UnregisterSUNImage PrependMagickMethod(UnregisterSUNImage)
#define UnregisterSVGImage PrependMagickMethod(UnregisterSVGImage)
#define UnregisterTGAImage PrependMagickMethod(UnregisterTGAImage)
#define UnregisterTHUMBNAILImage PrependMagickMethod(UnregisterTHUMBNAILImage)
#define UnregisterTIFFImage PrependMagickMethod(UnregisterTIFFImage)
#define UnregisterTILEImage PrependMagickMethod(UnregisterTILEImage)
#define UnregisterTIMImage PrependMagickMethod(UnregisterTIMImage)
#define UnregisterTTFImage PrependMagickMethod(UnregisterTTFImage)
#define UnregisterTXTImage PrependMagickMethod(UnregisterTXTImage)
#define UnregisterUILImage PrependMagickMethod(UnregisterUILImage)
#define UnregisterUndefinedImage PrependMagickMethod(UnregisterUndefinedImage)
#define UnregisterURLImage PrependMagickMethod(UnregisterURLImage)
#define UnregisterUYVYImage PrependMagickMethod(UnregisterUYVYImage)
#define UnregisterVICARImage PrependMagickMethod(UnregisterVICARImage)
#define UnregisterVIDEOImage PrependMagickMethod(UnregisterVIDEOImage)
#define UnregisterVIDImage PrependMagickMethod(UnregisterVIDImage)
#define UnregisterVIFFImage PrependMagickMethod(UnregisterVIFFImage)
#define UnregisterVIPSImage PrependMagickMethod(UnregisterVIPSImage)
#define UnregisterWBMPImage PrependMagickMethod(UnregisterWBMPImage)
#define UnregisterWEBPImage PrependMagickMethod(UnregisterWEBPImage)
#define UnregisterWPGImage PrependMagickMethod(UnregisterWPGImage)
#define UnregisterXBMImage PrependMagickMethod(UnregisterXBMImage)
#define UnregisterXCFImage PrependMagickMethod(UnregisterXCFImage)
#define UnregisterXCImage PrependMagickMethod(UnregisterXCImage)
#define UnregisterXImage PrependMagickMethod(UnregisterXImage)
#define UnregisterXPMImage PrependMagickMethod(UnregisterXPMImage)
#define UnregisterXPSImage PrependMagickMethod(UnregisterXPSImage)
#define UnregisterXWDImage PrependMagickMethod(UnregisterXWDImage)
#define UnregisterYCBCRImage PrependMagickMethod(UnregisterYCBCRImage)
#define UnregisterYUVImage PrependMagickMethod(UnregisterYUVImage)
#define UnsharpMaskImageChannel PrependMagickMethod(UnsharpMaskImageChannel)
#define UnsharpMaskImage PrependMagickMethod(UnsharpMaskImage)
#define UnshiftImageList PrependMagickMethod(UnshiftImageList)
#define UpdateImageViewIterator PrependMagickMethod(UpdateImageViewIterator)
#define UpdateSignature PrependMagickMethod(UpdateSignature)
#define ValidateColormapIndex PrependMagickMethod(ValidateColormapIndex)
#define VignetteImage PrependMagickMethod(VignetteImage)
#define WaveImage PrependMagickMethod(WaveImage)
#define WaveletDenoiseImage PrependMagickMethod(WaveletDenoiseImage)
#define WhiteThresholdImageChannel PrependMagickMethod(WhiteThresholdImageChannel)
#define WhiteThresholdImage PrependMagickMethod(WhiteThresholdImage)
#define WriteBlobByte PrependMagickMethod(WriteBlobByte)
#define WriteBlobFloat PrependMagickMethod(WriteBlobFloat)
#define WriteBlobLong PrependMagickMethod(WriteBlobLong)
#define WriteBlobLSBLong PrependMagickMethod(WriteBlobLSBLong)
#define WriteBlobLSBShort PrependMagickMethod(WriteBlobLSBShort)
#define WriteBlobLSBSignedLong PrependMagickMethod(WriteBlobLSBSignedLong)
#define WriteBlobLSBSignedShort PrependMagickMethod(WriteBlobLSBSignedShort)
#define WriteBlobMSBLongLong PrependMagickMethod(WriteBlobMSBLongLong)
#define WriteBlobMSBLong PrependMagickMethod(WriteBlobMSBLong)
#define WriteBlobMSBShort PrependMagickMethod(WriteBlobMSBShort)
#define WriteBlobMSBSignedLong PrependMagickMethod(WriteBlobMSBSignedLong)
#define WriteBlobMSBSignedShort PrependMagickMethod(WriteBlobMSBSignedShort)
#define WriteBlob PrependMagickMethod(WriteBlob)
#define WriteBlobShort PrependMagickMethod(WriteBlobShort)
#define WriteBlobString PrependMagickMethod(WriteBlobString)
#define WriteDistributePixelCacheIndexes PrependMagickMethod(WriteDistributePixelCacheIndexes)
#define WriteDistributePixelCachePixels PrependMagickMethod(WriteDistributePixelCachePixels)
#define WriteImage PrependMagickMethod(WriteImage)
#define WriteImages PrependMagickMethod(WriteImages)
#define WriteStream PrependMagickMethod(WriteStream)
#define XAnimateBackgroundImage PrependMagickMethod(XAnimateBackgroundImage)
#define XAnimateImages PrependMagickMethod(XAnimateImages)
#define XAnnotateImage PrependMagickMethod(XAnnotateImage)
#define XBestFont PrependMagickMethod(XBestFont)
#define XBestIconSize PrependMagickMethod(XBestIconSize)
#define XBestPixel PrependMagickMethod(XBestPixel)
#define XBestVisualInfo PrependMagickMethod(XBestVisualInfo)
#define XCheckDefineCursor PrependMagickMethod(XCheckDefineCursor)
#define XCheckRefreshWindows PrependMagickMethod(XCheckRefreshWindows)
#define XClientMessage PrependMagickMethod(XClientMessage)
#define XColorBrowserWidget PrependMagickMethod(XColorBrowserWidget)
#define XCommandWidget PrependMagickMethod(XCommandWidget)
#define XComponentGenesis PrependMagickMethod(XComponentGenesis)
#define XComponentTerminus PrependMagickMethod(XComponentTerminus)
#define XConfigureImageColormap PrependMagickMethod(XConfigureImageColormap)
#define XConfirmWidget PrependMagickMethod(XConfirmWidget)
#define XConstrainWindowPosition PrependMagickMethod(XConstrainWindowPosition)
#define XDelay PrependMagickMethod(XDelay)
#define XDestroyResourceInfo PrependMagickMethod(XDestroyResourceInfo)
#define XDestroyWindowColors PrependMagickMethod(XDestroyWindowColors)
#define XDialogWidget PrependMagickMethod(XDialogWidget)
#define XDisplayBackgroundImage PrependMagickMethod(XDisplayBackgroundImage)
#define XDisplayImageInfo PrependMagickMethod(XDisplayImageInfo)
#define XDisplayImage PrependMagickMethod(XDisplayImage)
#define XDrawImage PrependMagickMethod(XDrawImage)
#define XError PrependMagickMethod(XError)
#define XFileBrowserWidget PrependMagickMethod(XFileBrowserWidget)
#define XFontBrowserWidget PrependMagickMethod(XFontBrowserWidget)
#define XFreeResources PrependMagickMethod(XFreeResources)
#define XFreeStandardColormap PrependMagickMethod(XFreeStandardColormap)
#define XGetAnnotateInfo PrependMagickMethod(XGetAnnotateInfo)
#define XGetImportInfo PrependMagickMethod(XGetImportInfo)
#define XGetMapInfo PrependMagickMethod(XGetMapInfo)
#define XGetPixelPacket PrependMagickMethod(XGetPixelPacket)
#define XGetResourceClass PrependMagickMethod(XGetResourceClass)
#define XGetResourceDatabase PrependMagickMethod(XGetResourceDatabase)
#define XGetResourceInfo PrependMagickMethod(XGetResourceInfo)
#define XGetResourceInstance PrependMagickMethod(XGetResourceInstance)
#define XGetScreenDensity PrependMagickMethod(XGetScreenDensity)
#define XGetWindowColor PrependMagickMethod(XGetWindowColor)
#define XGetWindowInfo PrependMagickMethod(XGetWindowInfo)
#define XHighlightEllipse PrependMagickMethod(XHighlightEllipse)
#define XHighlightLine PrependMagickMethod(XHighlightLine)
#define XHighlightRectangle PrependMagickMethod(XHighlightRectangle)
#define XImportImage PrependMagickMethod(XImportImage)
#define XInfoWidget PrependMagickMethod(XInfoWidget)
#define XInitializeWindows PrependMagickMethod(XInitializeWindows)
#define XListBrowserWidget PrependMagickMethod(XListBrowserWidget)
#define XMagickProgressMonitor PrependMagickMethod(XMagickProgressMonitor)
#define XMakeCursor PrependMagickMethod(XMakeCursor)
#define XMakeImage PrependMagickMethod(XMakeImage)
#define XMakeMagnifyImage PrependMagickMethod(XMakeMagnifyImage)
#define XMakeStandardColormap PrependMagickMethod(XMakeStandardColormap)
#define XMakeWindow PrependMagickMethod(XMakeWindow)
#define XMenuWidget PrependMagickMethod(XMenuWidget)
#define XMLTreeInfoToXML PrependMagickMethod(XMLTreeInfoToXML)
#define XNoticeWidget PrependMagickMethod(XNoticeWidget)
#define XPreferencesWidget PrependMagickMethod(XPreferencesWidget)
#define XProgressMonitorWidget PrependMagickMethod(XProgressMonitorWidget)
#define XQueryColorDatabase PrependMagickMethod(XQueryColorDatabase)
#define XQueryPosition PrependMagickMethod(XQueryPosition)
#define XRefreshWindow PrependMagickMethod(XRefreshWindow)
#define XRemoteCommand PrependMagickMethod(XRemoteCommand)
#define XRenderImage PrependMagickMethod(XRenderImage)
#define XRetainWindowColors PrependMagickMethod(XRetainWindowColors)
#define XSetCursorState PrependMagickMethod(XSetCursorState)
#define XSetWindows PrependMagickMethod(XSetWindows)
#define XTextViewWidget PrependMagickMethod(XTextViewWidget)
#define XUserPreferences PrependMagickMethod(XUserPreferences)
#define XWarning PrependMagickMethod(XWarning)
#define XWindowByID PrependMagickMethod(XWindowByID)
#define XWindowByName PrependMagickMethod(XWindowByName)
#define XWindowByProperty PrependMagickMethod(XWindowByProperty)
#define ZeroKernelNans PrependMagickMethod(ZeroKernelNans)
#define ZLIBEncodeImage PrependMagickMethod(ZLIBEncodeImage)
#define ZoomImage PrependMagickMethod(ZoomImage)
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/attribute.h 0000644 00000003421 15051111170 0010143 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore methods to set or get image attributes.
*/
#ifndef MAGICKCORE_ATTRIBUTE_H
#define MAGICKCORE_ATTRIBUTE_H
#include "magick/image.h"
#include "magick/exception.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport ImageType
GetImageType(const Image *,ExceptionInfo *),
IdentifyImageGray(const Image *,ExceptionInfo *),
IdentifyImageType(const Image *,ExceptionInfo *);
extern MagickExport MagickBooleanType
IdentifyImageMonochrome(const Image *,ExceptionInfo *),
IsGrayImage(const Image *,ExceptionInfo *),
IsMonochromeImage(const Image *,ExceptionInfo *),
IsOpaqueImage(const Image *,ExceptionInfo *),
SetImageChannelDepth(Image *,const ChannelType,const size_t),
SetImageDepth(Image *,const size_t),
SetImageType(Image *,const ImageType);
extern MagickExport RectangleInfo
GetImageBoundingBox(const Image *,ExceptionInfo *exception);
extern MagickExport size_t
GetImageChannelDepth(const Image *,const ChannelType,ExceptionInfo *),
GetImageDepth(const Image *,ExceptionInfo *),
GetImageQuantumDepth(const Image *,const MagickBooleanType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/method-attribute.h 0000644 00000010142 15051111170 0011417 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore method attributes.
*/
#ifndef MAGICKCORE_METHOD_ATTRIBUTE_H
#define MAGICKCORE_METHOD_ATTRIBUTE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if defined(_DLL)
# define _MAGICKDLL_
# define _MAGICKLIB_
# define MAGICKCORE_MODULES_SUPPORT
# undef MAGICKCORE_BUILD_MODULES
#endif
#if defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(__CYGWIN__)
# define MagickPrivate
# if defined(_MT) && defined(_DLL) && !defined(_MAGICKDLL_) && !defined(_LIB)
# define _MAGICKDLL_
# endif
# if defined(_MAGICKDLL_)
# if defined(_VISUALC_)
# pragma warning( disable: 4273 ) /* Disable the dll linkage warnings */
# endif
# if !defined(_MAGICKLIB_)
# if defined(__clang__) || defined(__GNUC__)
# define MagickExport __attribute__ ((dllimport))
# else
# define MagickExport __declspec(dllimport)
# endif
# else
# if defined(__clang__) || defined(__GNUC__)
# define MagickExport __attribute__ ((dllexport))
# else
# define MagickExport __declspec(dllexport)
# endif
# endif
# else
# define MagickExport
# endif
# if defined(_DLL) && !defined(_LIB)
# if defined(__clang__) || defined(__GNUC__)
# define ModuleExport __attribute__ ((dllexport))
# else
# define ModuleExport __declspec(dllexport)
# endif
# else
# define ModuleExport
# endif
# if defined(_VISUALC_)
# pragma warning(disable : 4018)
# pragma warning(disable : 4068)
# pragma warning(disable : 4244)
# pragma warning(disable : 4142)
# pragma warning(disable : 4800)
# pragma warning(disable : 4786)
# pragma warning(disable : 4996)
# endif
#else
# if defined(__clang__) || (__GNUC__ >= 4)
# define MagickExport __attribute__ ((visibility ("default")))
# define MagickPrivate __attribute__ ((visibility ("hidden")))
# else
# define MagickExport
# define MagickPrivate
# endif
# define ModuleExport MagickExport
#endif
#define MagickCoreSignature 0xabacadabUL
#define MagickSignature MagickCoreSignature
#if !defined(MaxTextExtent)
# define MaxTextExtent 4096 /* always >= max(4096,PATH_MAX) */
#endif
#define MagickTimeExtent 26
#if defined(MAGICKCORE_HAVE___ATTRIBUTE__)
# define magick_aligned(x,y) x __attribute__((aligned(y)))
# define magick_attribute __attribute__
# define magick_unused(x) magick_unused_ ## x __attribute__((unused))
# define magick_unreferenced(x) /* nothing */
#elif defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(__CYGWIN__)
# define magick_aligned(x,y) __declspec(align(y)) x
# define magick_attribute(x) /* nothing */
# define magick_unused(x) x
# define magick_unreferenced(x) (x)
#else
# define magick_aligned(x,y) /* nothing */
# define magick_attribute(x) /* nothing */
# define magick_unused(x) x
# define magick_unreferenced(x) /* nothing */
#endif
#if !defined(__clang__) && (defined(__GNUC__) && (__GNUC__) > 4)
# define magick_alloc_size(x) __attribute__((__alloc_size__(x)))
# define magick_alloc_sizes(x,y) __attribute__((__alloc_size__(x,y)))
# define magick_fallthrough __attribute__((fallthrough))
#else
# define magick_alloc_size(x) /* nothing */
# define magick_alloc_sizes(x,y) /* nothing */
# define magick_fallthrough /* nothing */
#endif
#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__) > 4)
# define magick_cold_spot __attribute__((__cold__))
# define magick_hot_spot __attribute__((__hot__))
#else
# define magick_cold_spot
# define magick_hot_spot
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/version-64.h 0000644 00000006076 15051111170 0010065 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License.
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore version methods.
*/
#ifndef _MAGICKCORE_VERSION_H
#define _MAGICKCORE_VERSION_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/*
Define declarations.
*/
#define MagickPackageName "ImageMagick"
#define MagickCopyright "(C) 1999 ImageMagick Studio LLC"
#define MagickLibVersion 0x69D
#define MagickLibVersionText "6.9.13"
#define MagickLibVersionNumber 7,0,0
#define MagickLibAddendum "-25"
#define MagickLibInterface 7
#define MagickLibMinInterface 7
#define MagickPlatform "x86_64"
#define MagickppLibVersionText "6.9.13"
#define MagickppLibVersionNumber 9:0:0
#define MagickppLibAddendum "-25"
#define MagickppLibInterface 9
#define MagickppLibMinInterface 9
#define MagickGitRevision "18639"
#define MagickReleaseDate "2025-03-29"
#define MagickHomeURL "file:///usr/share/doc/ImageMagick-6/index.html"
#define MagickAuthoritativeLicense \
"https://imagemagick.org/script/license.php"
#define MagickAuthoritativeURL "https://legacy.imagemagick.org"
#if (MAGICKCORE_QUANTUM_DEPTH == 8)
#define MagickQuantumDepth "Q8"
#define MagickQuantumRange "255"
#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
#define MagickQuantumDepth "Q16"
#define MagickQuantumRange "65535"
#elif (MAGICKCORE_QUANTUM_DEPTH == 32)
#define MagickQuantumDepth "Q32"
#define MagickQuantumRange "4294967295"
#elif (MAGICKCORE_QUANTUM_DEPTH == 64)
#define MagickQuantumDepth "Q64"
#define MagickQuantumRange "18446744073709551615.0"
#else
#define MagickQuantumDepth "Q?"
#define MagickQuantumRange "?"
#endif
#if defined(MAGICKCORE_HDRI_SUPPORT)
#define MagickHDRISupport "-HDRI"
#else
#define MagickHDRISupport ""
#endif
#define MagickVersion \
MagickPackageName " " MagickLibVersionText MagickLibAddendum " " \
MagickQuantumDepth MagickHDRISupport " " MagickPlatform " " \
MagickGitRevision " " MagickAuthoritativeURL
extern MagickExport char
*GetMagickHomeURL(void);
extern MagickExport const char
*GetMagickCopyright(void) magick_attribute((__const__)),
*GetMagickDelegates(void) magick_attribute((__const__)),
*GetMagickFeatures(void) magick_attribute((__const__)),
*GetMagickLicense(void) magick_attribute((__const__)),
*GetMagickPackageName(void) magick_attribute((__const__)),
*GetMagickQuantumDepth(size_t *),
*GetMagickQuantumRange(size_t *),
*GetMagickReleaseDate(void) magick_attribute((__const__)),
*GetMagickVersion(size_t *);
extern MagickExport void
ListMagickVersion(FILE *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/magick-baseconfig.h 0000644 00000000313 15051111170 0011466 0 ustar 00 #include <bits/wordsize.h>
#if __WORDSIZE == 32
# include "magick-baseconfig-32.h"
#elif __WORDSIZE == 64
# include "magick-baseconfig-64.h"
#else
# error "unexpected value for __WORDSIZE macro"
#endif
magick/blob.h 0000644 00000004637 15051111170 0007070 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore Binary Large OBjects methods.
*/
#ifndef MAGICKCORE_BLOB_H
#define MAGICKCORE_BLOB_H
#include "magick/image.h"
#include "magick/stream.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#define MagickMaxBufferExtent 524288
#define MagickMinBufferExtent 16384
typedef enum
{
ReadMode,
WriteMode,
IOMode,
PersistMode
} MapMode;
extern MagickExport FILE
*GetBlobFileHandle(const Image *) magick_attribute((__pure__));
extern MagickExport Image
*BlobToImage(const ImageInfo *,const void *,const size_t,ExceptionInfo *),
*PingBlob(const ImageInfo *,const void *,const size_t,ExceptionInfo *);
extern MagickExport MagickBooleanType
BlobToFile(char *,const void *,const size_t,ExceptionInfo *),
FileToImage(Image *,const char *),
GetBlobError(const Image *) magick_attribute((__pure__)),
ImageToFile(Image *,char *,ExceptionInfo *),
InjectImageBlob(const ImageInfo *,Image *,Image *,const char *,
ExceptionInfo *),
IsBlobExempt(const Image *) magick_attribute((__pure__)),
IsBlobSeekable(const Image *) magick_attribute((__pure__)),
IsBlobTemporary(const Image *) magick_attribute((__pure__));
extern MagickExport MagickSizeType
GetBlobSize(const Image *);
extern MagickExport StreamHandler
GetBlobStreamHandler(const Image *) magick_attribute((__pure__));
extern MagickExport unsigned char
*FileToBlob(const char *,const size_t,size_t *,ExceptionInfo *),
*GetBlobStreamData(const Image *) magick_attribute((__pure__)),
*ImageToBlob(const ImageInfo *,Image *,size_t *,ExceptionInfo *),
*ImagesToBlob(const ImageInfo *,Image *,size_t *,ExceptionInfo *);
extern MagickExport void
DestroyBlob(Image *),
DuplicateBlob(Image *,const Image *),
SetBlobExempt(Image *,const MagickBooleanType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/feature.h 0000644 00000003322 15051111170 0007573 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore feature methods.
*/
#ifndef MAGICKCORE_FEATURE_H
#define MAGICKCORE_FEATURE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/*
Haralick texture features.
*/
typedef struct _ChannelFeatures
{
double
angular_second_moment[4],
contrast[4],
correlation[4],
variance_sum_of_squares[4],
inverse_difference_moment[4],
sum_average[4],
sum_variance[4],
sum_entropy[4],
entropy[4],
difference_variance[4],
difference_entropy[4],
measure_of_correlation_1[4],
measure_of_correlation_2[4],
maximum_correlation_coefficient[4];
} ChannelFeatures;
extern MagickExport ChannelFeatures
*GetImageChannelFeatures(const Image *,const size_t,ExceptionInfo *);
extern MagickExport Image
*CannyEdgeImage(const Image *,const double,const double,const double,
const double,ExceptionInfo *),
*HoughLineImage(const Image *,const size_t,const size_t,const size_t,
ExceptionInfo *),
*MeanShiftImage(const Image *,const size_t,const size_t,const double,
ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/compare.h 0000644 00000004040 15051111170 0007564 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image compare methods.
*/
#ifndef MAGICKCORE_COMPARE_H
#define MAGICKCORE_COMPARE_H
#include "magick/image.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedMetric,
AbsoluteErrorMetric,
MeanAbsoluteErrorMetric,
MeanErrorPerPixelMetric,
MeanSquaredErrorMetric,
PeakAbsoluteErrorMetric,
PeakSignalToNoiseRatioMetric,
RootMeanSquaredErrorMetric,
NormalizedCrossCorrelationErrorMetric,
FuzzErrorMetric,
UndefinedErrorMetric = 0,
PerceptualHashErrorMetric = 0xff
} MetricType;
extern MagickExport double
*GetImageChannelDistortions(Image *,const Image *,const MetricType,
ExceptionInfo *);
extern MagickExport Image
*CompareImageChannels(Image *,const Image *,const ChannelType,
const MetricType,double *,ExceptionInfo *),
*CompareImages(Image *,const Image *,const MetricType,double *,
ExceptionInfo *),
*SimilarityImage(Image *,const Image *,RectangleInfo *,double *,
ExceptionInfo *),
*SimilarityMetricImage(Image *,const Image *,const MetricType,
RectangleInfo *,double *,ExceptionInfo *);
extern MagickExport MagickBooleanType
GetImageChannelDistortion(Image *,const Image *,const ChannelType,
const MetricType,double *,ExceptionInfo *),
GetImageDistortion(Image *,const Image *,const MetricType,double *,
ExceptionInfo *),
IsImagesEqual(Image *,const Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/list.h 0000644 00000004460 15051111170 0007117 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image list methods.
*/
#ifndef MAGICKCORE_LIST_H
#define MAGICKCORE_LIST_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport Image
*CloneImageList(const Image *,ExceptionInfo *),
*CloneImages(const Image *,const char *,ExceptionInfo *),
*DestroyImageList(Image *),
*DuplicateImages(Image *,const size_t,const char *,ExceptionInfo *),
*GetFirstImageInList(const Image *) magick_attribute((__pure__)),
*GetImageFromList(const Image *,const ssize_t) magick_attribute((__pure__)),
*GetLastImageInList(const Image *) magick_attribute((__pure__)),
*GetNextImageInList(const Image *) magick_attribute((__pure__)),
*GetPreviousImageInList(const Image *) magick_attribute((__pure__)),
**ImageListToArray(const Image *,ExceptionInfo *),
*NewImageList(void) magick_attribute((__const__)),
*RemoveImageFromList(Image **),
*RemoveLastImageFromList(Image **),
*RemoveFirstImageFromList(Image **),
*SpliceImageIntoList(Image **,const size_t,const Image *),
*SplitImageList(Image *),
*SyncNextImageInList(const Image *);
extern MagickExport size_t
GetImageListLength(const Image *) magick_attribute((__pure__));
extern MagickExport ssize_t
GetImageIndexInList(const Image *) magick_attribute((__pure__));
extern MagickExport void
AppendImageToList(Image **,const Image *),
DeleteImageFromList(Image **),
DeleteImages(Image **,const char *,ExceptionInfo *),
InsertImageInList(Image **,Image *),
PrependImageToList(Image **,Image *),
ReplaceImageInList(Image **,Image *),
ReplaceImageInListReturnLast(Image **,Image *),
ReverseImageList(Image **),
SyncImageList(Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/montage.h 0000644 00000003351 15051111170 0007574 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore montage methods.
*/
#ifndef MAGICKCORE_MONTAGE_H
#define MAGICKCORE_MONTAGE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedMode,
FrameMode,
UnframeMode,
ConcatenateMode
} MontageMode;
typedef struct _MontageInfo
{
char
*geometry,
*tile,
*title,
*frame,
*texture,
*font;
double
pointsize;
size_t
border_width;
MagickBooleanType
shadow;
PixelPacket
fill,
stroke,
background_color,
border_color,
matte_color;
GravityType
gravity;
char
filename[MaxTextExtent];
MagickBooleanType
debug;
size_t
signature;
} MontageInfo;
extern MagickExport Image
*MontageImages(const Image *,const MontageInfo *,ExceptionInfo *),
*MontageImageList(const ImageInfo *,const MontageInfo *,const Image *,
ExceptionInfo *);
extern MagickExport MontageInfo
*CloneMontageInfo(const ImageInfo *,const MontageInfo *),
*DestroyMontageInfo(MontageInfo *);
extern MagickExport void
GetMontageInfo(const ImageInfo *,MontageInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/paint.h 0000644 00000003355 15051111170 0007261 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image paint methods.
*/
#ifndef MAGICKCORE_PAINT_H
#define MAGICKCORE_PAINT_H
#include "magick/color.h"
#include "magick/draw.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport Image
*OilPaintImage(const Image *,const double,ExceptionInfo *);
extern MagickExport MagickBooleanType
FloodfillPaintImage(Image *,const ChannelType,const DrawInfo *,
const MagickPixelPacket *,const ssize_t,const ssize_t,
const MagickBooleanType),
GradientImage(Image *,const GradientType,const SpreadMethod,
const PixelPacket *,const PixelPacket *),
OpaquePaintImage(Image *,const MagickPixelPacket *,const MagickPixelPacket *,
const MagickBooleanType),
OpaquePaintImageChannel(Image *,const ChannelType,const MagickPixelPacket *,
const MagickPixelPacket *,const MagickBooleanType),
TransparentPaintImage(Image *,const MagickPixelPacket *,
const Quantum,const MagickBooleanType),
TransparentPaintImageChroma(Image *,const MagickPixelPacket *,
const MagickPixelPacket *,const Quantum,const MagickBooleanType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/version.h 0000644 00000000267 15051111170 0007632 0 ustar 00 #include <bits/wordsize.h>
#if __WORDSIZE == 32
# include "version-32.h"
#elif __WORDSIZE == 64
# include "version-64.h"
#else
# error "unexpected value for __WORDSIZE macro"
#endif
magick/quantum.h 0000644 00000012277 15051111170 0007643 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore quantum inline methods.
*/
#ifndef MAGICKCORE_QUANTUM_H
#define MAGICKCORE_QUANTUM_H
#include <float.h>
#include "magick/image.h"
#include "magick/semaphore.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#define RoundToQuantum(quantum) ClampToQuantum(quantum)
typedef enum
{
UndefinedEndian,
LSBEndian,
MSBEndian
} EndianType;
typedef enum
{
UndefinedQuantumAlpha,
AssociatedQuantumAlpha,
DisassociatedQuantumAlpha
} QuantumAlphaType;
typedef enum
{
UndefinedQuantumFormat,
FloatingPointQuantumFormat,
SignedQuantumFormat,
UnsignedQuantumFormat
} QuantumFormatType;
typedef enum
{
UndefinedQuantum,
AlphaQuantum,
BlackQuantum,
BlueQuantum,
CMYKAQuantum,
CMYKQuantum,
CyanQuantum,
GrayAlphaQuantum,
GrayQuantum,
GreenQuantum,
IndexAlphaQuantum,
IndexQuantum,
MagentaQuantum,
OpacityQuantum,
RedQuantum,
RGBAQuantum,
BGRAQuantum,
RGBOQuantum,
RGBQuantum,
YellowQuantum,
GrayPadQuantum, /* deprecated */
RGBPadQuantum,
CbYCrYQuantum,
CbYCrQuantum,
CbYCrAQuantum,
CMYKOQuantum,
BGRQuantum,
BGROQuantum
} QuantumType;
typedef struct _QuantumInfo
QuantumInfo;
static inline Quantum ClampToQuantum(const MagickRealType quantum)
{
#if defined(MAGICKCORE_HDRI_SUPPORT)
return((Quantum) quantum);
#else
if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
return((Quantum) 0);
if (quantum >= (MagickRealType) QuantumRange)
return(QuantumRange);
return((Quantum) (quantum+0.5));
#endif
}
#if (MAGICKCORE_QUANTUM_DEPTH == 8)
static inline unsigned char ScaleQuantumToChar(const Quantum quantum)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
return((unsigned char) quantum);
#else
if ((IsNaN(quantum) != 0) || (quantum <= 0.0f))
return(0);
if (quantum >= 255.0)
return(255);
return((unsigned char) (quantum+0.5f));
#endif
}
#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
static inline unsigned char ScaleQuantumToChar(const Quantum quantum)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
return((unsigned char) (((quantum+128UL)-((quantum+128UL) >> 8)) >> 8));
#else
if ((IsNaN(quantum) != 0) || (quantum <= 0.0f))
return(0);
if ((quantum/257.0f) >= 255.0f)
return(255);
return((unsigned char) (quantum/257.0f+0.5f));
#endif
}
#elif (MAGICKCORE_QUANTUM_DEPTH == 32)
static inline unsigned char ScaleQuantumToChar(const Quantum quantum)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
return((unsigned char) ((quantum+MagickULLConstant(8421504))/
MagickULLConstant(16843009)));
#else
if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
return(0);
if ((quantum/16843009.0) >= 255.0)
return(255);
return((unsigned char) (quantum/16843009.0+0.5));
#endif
}
#elif (MAGICKCORE_QUANTUM_DEPTH == 64)
static inline unsigned char ScaleQuantumToChar(const Quantum quantum)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
return((unsigned char) (quantum/72340172838076673.0+0.5));
#else
if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
return(0);
if ((quantum/72340172838076673.0) >= 255.0)
return(255);
return((unsigned char) (quantum/72340172838076673.0+0.5));
#endif
}
#endif
extern MagickExport EndianType
GetQuantumEndian(const QuantumInfo *);
extern MagickExport MagickBooleanType
SetQuantumDepth(const Image *,QuantumInfo *,const size_t),
SetQuantumEndian(const Image *,QuantumInfo *,const EndianType),
SetQuantumFormat(const Image *,QuantumInfo *,const QuantumFormatType),
SetQuantumPad(const Image *,QuantumInfo *,const size_t);
extern MagickExport QuantumFormatType
GetQuantumFormat(const QuantumInfo *);
extern MagickExport QuantumInfo
*AcquireQuantumInfo(const ImageInfo *,Image *),
*DestroyQuantumInfo(QuantumInfo *);
extern MagickExport QuantumType
GetQuantumType(Image *,ExceptionInfo *);
extern MagickExport size_t
ExportQuantumPixels(const Image *,const CacheView *,const QuantumInfo *,
const QuantumType,unsigned char *magick_restrict,ExceptionInfo *),
GetQuantumExtent(const Image *,const QuantumInfo *,const QuantumType),
ImportQuantumPixels(Image *,CacheView *,const QuantumInfo *,const QuantumType,
const unsigned char *magick_restrict,ExceptionInfo *);
extern MagickExport unsigned char
*GetQuantumPixels(const QuantumInfo *);
extern MagickExport void
GetQuantumInfo(const ImageInfo *,QuantumInfo *),
SetQuantumAlphaType(QuantumInfo *,const QuantumAlphaType),
SetQuantumImageType(Image *,const QuantumType),
SetQuantumMinIsWhite(QuantumInfo *,const MagickBooleanType),
SetQuantumPack(QuantumInfo *,const MagickBooleanType),
SetQuantumQuantum(QuantumInfo *,const size_t),
SetQuantumScale(QuantumInfo *,const double);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/delegate.h 0000644 00000004235 15051111170 0007716 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore delegates methods.
*/
#ifndef MAGICKCORE_DELEGATE_H
#define MAGICKCORE_DELEGATE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#include <stdarg.h>
#include "magick/semaphore.h"
typedef struct _DelegateInfo
{
char
*path,
*decode,
*encode,
*commands;
ssize_t
mode;
MagickBooleanType
thread_support,
spawn,
stealth;
struct _DelegateInfo
*previous,
*next; /* deprecated, use GetDelegateInfoList() */
size_t
signature;
SemaphoreInfo
*semaphore;
} DelegateInfo;
extern MagickExport char
*GetDelegateCommand(const ImageInfo *,Image *,const char *,const char *,
ExceptionInfo *),
**GetDelegateList(const char *,size_t *,ExceptionInfo *);
extern MagickExport const char
*GetDelegateCommands(const DelegateInfo *);
extern MagickExport const DelegateInfo
*GetDelegateInfo(const char *,const char *,ExceptionInfo *exception),
**GetDelegateInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport int
ExternalDelegateCommand(const MagickBooleanType,const MagickBooleanType,
const char *,char *,ExceptionInfo *);
extern MagickExport ssize_t
GetDelegateMode(const DelegateInfo *);
extern MagickExport MagickBooleanType
DelegateComponentGenesis(void),
GetDelegateThreadSupport(const DelegateInfo *),
InvokeDelegate(ImageInfo *,Image *,const char *,const char *,ExceptionInfo *),
ListDelegateInfo(FILE *,ExceptionInfo *);
extern MagickExport void
DelegateComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/artifact.h 0000644 00000002541 15051111170 0007737 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore artifact methods.
*/
#ifndef MAGICKCORE_ARTIFACT_H
#define MAGICKCORE_ARTIFACT_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport char
*GetNextImageArtifact(const Image *),
*RemoveImageArtifact(Image *,const char *);
extern MagickExport const char
*GetImageArtifact(const Image *,const char *);
extern MagickExport MagickBooleanType
CloneImageArtifacts(Image *,const Image *),
DefineImageArtifact(Image *,const char *),
DeleteImageArtifact(Image *,const char *),
SetImageArtifact(Image *,const char *,const char *);
extern MagickExport void
DestroyImageArtifacts(Image *),
ResetImageArtifactIterator(const Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/magick.h 0000644 00000007304 15051111170 0007377 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore magick methods.
*/
#ifndef MAGICKCORE_MAGICK_H
#define MAGICKCORE_MAGICK_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#include <stdarg.h>
#include "magick/semaphore.h"
#if defined(__cplusplus) || defined(c_plusplus)
# define magick_module _module /* reserved word in C++(20) */
#else
# define magick_module module
#endif
typedef enum
{
UndefinedFormatType,
ImplicitFormatType,
ExplicitFormatType
} MagickFormatType;
typedef enum
{
NoThreadSupport = 0x0000,
DecoderThreadSupport = 0x0001,
EncoderThreadSupport = 0x0002
} MagickThreadSupport;
typedef Image
*DecodeImageHandler(const ImageInfo *,ExceptionInfo *);
typedef MagickBooleanType
EncodeImageHandler(const ImageInfo *,Image *);
typedef MagickBooleanType
IsImageFormatHandler(const unsigned char *,const size_t);
typedef struct _MagickInfo
{
char
*name,
*description,
*version,
*note,
*magick_module;
ImageInfo
*image_info;
DecodeImageHandler
*decoder;
EncodeImageHandler
*encoder;
IsImageFormatHandler
*magick;
void
*client_data;
MagickBooleanType
adjoin,
raw,
endian_support,
blob_support,
seekable_stream;
MagickFormatType
format_type;
MagickStatusType
thread_support;
MagickBooleanType
stealth;
struct _MagickInfo
*previous,
*next; /* deprecated, use GetMagickInfoList() */
size_t
signature;
char
*mime_type;
SemaphoreInfo
*semaphore;
} MagickInfo;
extern MagickExport char
**GetMagickList(const char *,size_t *,ExceptionInfo *);
extern MagickExport const char
*GetMagickDescription(const MagickInfo *),
*GetMagickMimeType(const MagickInfo *);
extern MagickExport DecodeImageHandler
*GetImageDecoder(const MagickInfo *) magick_attribute((__pure__));
extern MagickExport EncodeImageHandler
*GetImageEncoder(const MagickInfo *) magick_attribute((__pure__));
extern MagickExport int
GetMagickPrecision(void),
SetMagickPrecision(const int);
extern MagickExport MagickBooleanType
GetImageMagick(const unsigned char *,const size_t,char *),
GetMagickAdjoin(const MagickInfo *) magick_attribute((__pure__)),
GetMagickBlobSupport(const MagickInfo *) magick_attribute((__pure__)),
GetMagickEndianSupport(const MagickInfo *) magick_attribute((__pure__)),
GetMagickRawSupport(const MagickInfo *) magick_attribute((__pure__)),
GetMagickSeekableStream(const MagickInfo *) magick_attribute((__pure__)),
IsMagickCoreInstantiated(void) magick_attribute((__pure__)),
MagickComponentGenesis(void),
UnregisterMagickInfo(const char *);
extern const MagickExport MagickInfo
*GetMagickInfo(const char *,ExceptionInfo *),
**GetMagickInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport MagickInfo
*RegisterMagickInfo(MagickInfo *),
*SetMagickInfo(const char *);
extern MagickExport MagickStatusType
GetMagickThreadSupport(const MagickInfo *);
extern MagickExport void
MagickComponentTerminus(void),
MagickCoreGenesis(const char *,const MagickBooleanType),
MagickCoreTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/cache-view.h 0000644 00000007374 15051111170 0010166 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore cache view methods.
*/
#ifndef MAGICKCORE_CACHE_VIEW_H
#define MAGICKCORE_CACHE_VIEW_H
#include "magick/pixel.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedVirtualPixelMethod,
BackgroundVirtualPixelMethod,
ConstantVirtualPixelMethod, /* deprecated */
DitherVirtualPixelMethod,
EdgeVirtualPixelMethod,
MirrorVirtualPixelMethod,
RandomVirtualPixelMethod,
TileVirtualPixelMethod,
TransparentVirtualPixelMethod,
MaskVirtualPixelMethod,
BlackVirtualPixelMethod,
GrayVirtualPixelMethod,
WhiteVirtualPixelMethod,
HorizontalTileVirtualPixelMethod,
VerticalTileVirtualPixelMethod,
HorizontalTileEdgeVirtualPixelMethod,
VerticalTileEdgeVirtualPixelMethod,
CheckerTileVirtualPixelMethod
} VirtualPixelMethod;
typedef struct _CacheView
CacheView;
extern MagickExport CacheView
*AcquireAuthenticCacheView(const Image *,ExceptionInfo *),
*AcquireCacheView(const Image *),
*AcquireVirtualCacheView(const Image *,ExceptionInfo *),
*CloneCacheView(const CacheView *),
*DestroyCacheView(CacheView *);
extern MagickExport ClassType
GetCacheViewStorageClass(const CacheView *) magick_attribute((__pure__));
extern MagickExport ColorspaceType
GetCacheViewColorspace(const CacheView *) magick_attribute((__pure__));
extern MagickExport const IndexPacket
*GetCacheViewVirtualIndexQueue(const CacheView *)
magick_attribute((__pure__));
extern MagickExport const PixelPacket
*GetCacheViewVirtualPixels(const CacheView *,const ssize_t,const ssize_t,
const size_t,const size_t,ExceptionInfo *) magick_hot_spot,
*GetCacheViewVirtualPixelQueue(const CacheView *) magick_hot_spot;
extern MagickExport ExceptionInfo
*GetCacheViewException(const CacheView *) magick_attribute((__pure__));
extern MagickExport IndexPacket
*GetCacheViewAuthenticIndexQueue(CacheView *) magick_attribute((__pure__));
extern MagickExport MagickBooleanType
GetOneCacheViewAuthenticPixel(const CacheView *magick_restrict,const ssize_t,
const ssize_t,PixelPacket *magick_restrict,ExceptionInfo *),
GetOneCacheViewVirtualMethodPixel(const CacheView *,
const VirtualPixelMethod,const ssize_t,const ssize_t,PixelPacket *,
ExceptionInfo *),
GetOneCacheViewVirtualPixel(const CacheView *magick_restrict,const ssize_t,
const ssize_t,PixelPacket *magick_restrict,ExceptionInfo *),
SetCacheViewStorageClass(CacheView *,const ClassType),
SetCacheViewVirtualPixelMethod(CacheView *magick_restrict,
const VirtualPixelMethod),
SyncCacheViewAuthenticPixels(CacheView *magick_restrict,ExceptionInfo *)
magick_hot_spot;
extern MagickExport MagickSizeType
GetCacheViewExtent(const CacheView *);
extern MagickExport size_t
GetCacheViewChannels(const CacheView *);
extern MagickExport PixelPacket
*GetCacheViewAuthenticPixelQueue(CacheView *) magick_hot_spot,
*GetCacheViewAuthenticPixels(CacheView *,const ssize_t,const ssize_t,
const size_t,const size_t,ExceptionInfo *) magick_hot_spot,
*QueueCacheViewAuthenticPixels(CacheView *,const ssize_t,const ssize_t,
const size_t,const size_t,ExceptionInfo *) magick_hot_spot;
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/vision.h 0000644 00000001670 15051111170 0007453 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore computer vision methods.
*/
#ifndef MAGICKCORE_VISION_H
#define MAGICKCORE_VISION_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport Image
*ConnectedComponentsImage(const Image *,const size_t,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/profile.h 0000644 00000003377 15051111170 0007612 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image profile methods.
*/
#ifndef MAGICKCORE_PROFILE_H
#define MAGICKCORE_PROFILE_H
#include "magick/string_.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _ProfileInfo
{
char
*name;
size_t
length;
unsigned char
*info;
size_t
signature;
} ProfileInfo;
typedef enum
{
UndefinedIntent,
SaturationIntent,
PerceptualIntent,
AbsoluteIntent,
RelativeIntent
} RenderingIntent;
extern MagickExport char
*GetNextImageProfile(const Image *);
extern MagickExport const StringInfo
*GetImageProfile(const Image *,const char *);
extern MagickExport MagickBooleanType
CloneImageProfiles(Image *,const Image *),
DeleteImageProfile(Image *,const char *),
ProfileImage(Image *,const char *,const void *,const size_t,
const MagickBooleanType),
SetImageProfile(Image *,const char *,const StringInfo *),
SyncImageProfiles(Image *);
extern MagickExport StringInfo
*RemoveImageProfile(Image *,const char *);
extern MagickExport void
DestroyImageProfiles(Image *),
ResetImageProfileIterator(const Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/resource_.h 0000644 00000003466 15051111170 0010137 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore resource methods.
*/
#ifndef MAGICKCORE_RESOURCE_H
#define MAGICKCORE_RESOURCE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedResource,
AreaResource,
DiskResource,
FileResource,
MapResource,
MemoryResource,
ThreadResource,
TimeResource,
ThrottleResource,
WidthResource,
HeightResource,
ListLengthResource
} ResourceType;
#define MagickResourceInfinity (MagickULLConstant(~0) >> 1)
extern MagickExport int
AcquireUniqueFileResource(char *);
extern MagickExport MagickBooleanType
AcquireMagickResource(const ResourceType,const MagickSizeType),
GetPathTemplate(char *),
ListMagickResourceInfo(FILE *,ExceptionInfo *),
RelinquishUniqueFileResource(const char *),
ResourceComponentGenesis(void),
SetMagickResourceLimit(const ResourceType,const MagickSizeType);
extern MagickExport MagickSizeType
GetMagickResource(const ResourceType),
GetMagickResourceLimit(const ResourceType);
extern MagickExport void
AsynchronousResourceComponentTerminus(void),
RelinquishMagickResource(const ResourceType,const MagickSizeType),
ResourceComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/configure.h 0000644 00000003753 15051111170 0010131 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore configure methods.
*/
#ifndef MAGICKCORE_CONFIGURE_H
#define MAGICKCORE_CONFIGURE_H
#include "magick/hashmap.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _ConfigureInfo
{
char
*path,
*name,
*value;
MagickBooleanType
exempt,
stealth;
struct _ConfigureInfo
*previous,
*next; /* deprecated, use GetConfigureInfoList() */
size_t
signature;
} ConfigureInfo;
extern MagickExport char
**GetConfigureList(const char *,size_t *,ExceptionInfo *),
*GetConfigureOption(const char *);
extern MagickExport const char
*GetConfigureValue(const ConfigureInfo *);
extern MagickExport const ConfigureInfo
*GetConfigureInfo(const char *,ExceptionInfo *),
**GetConfigureInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport LinkedListInfo
*DestroyConfigureOptions(LinkedListInfo *),
*GetConfigurePaths(const char *,ExceptionInfo *),
*GetConfigureOptions(const char *,ExceptionInfo *);
extern MagickExport MagickBooleanType
ConfigureComponentGenesis(void),
ListConfigureInfo(FILE *,ExceptionInfo *);
extern MagickExport void
ConfigureComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/display.h 0000644 00000002036 15051111170 0007606 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore methods to interactively display and edit an image.
*/
#ifndef MAGICKCORE_DISPLAY_H
#define MAGICKCORE_DISPLAY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
DisplayImages(const ImageInfo *,Image *),
RemoteDisplayCommand(const ImageInfo *,const char *,const char *,
ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/fourier.h 0000644 00000002611 15051111170 0007613 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore discrete Fourier transform (DFT) methods.
*/
#ifndef MAGICKCORE_FFT_H
#define MAGICKCORE_FFT_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedComplexOperator,
AddComplexOperator,
ConjugateComplexOperator,
DivideComplexOperator,
MagnitudePhaseComplexOperator,
MultiplyComplexOperator,
RealImaginaryComplexOperator,
SubtractComplexOperator
} ComplexOperator;
extern MagickExport Image
*ComplexImages(const Image *,const ComplexOperator,ExceptionInfo *),
*ForwardFourierTransformImage(const Image *,const MagickBooleanType,
ExceptionInfo *),
*InverseFourierTransformImage(const Image *,const Image *,
const MagickBooleanType,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/cache.h 0000644 00000005505 15051111170 0007210 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore cache methods.
*/
#ifndef MAGICKCORE_CACHE_H
#define MAGICKCORE_CACHE_H
#include "magick/blob.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedCache,
MemoryCache,
MapCache,
DiskCache,
PingCache,
DistributedCache
} CacheType;
extern MagickExport CacheType
GetImagePixelCacheType(const Image *);
extern MagickExport const char
*GetPixelCacheFilename(const Image *);
extern MagickExport const IndexPacket
*GetVirtualIndexQueue(const Image *);
extern MagickExport const PixelPacket
*GetVirtualPixels(const Image *,const ssize_t,const ssize_t,const size_t,
const size_t,ExceptionInfo *),
*GetVirtualPixelQueue(const Image *);
extern MagickExport const void
*AcquirePixelCachePixels(const Image *,MagickSizeType *,ExceptionInfo *);
extern MagickExport IndexPacket
*GetAuthenticIndexQueue(const Image *);
extern MagickExport MagickBooleanType
CacheComponentGenesis(void),
GetOneVirtualMagickPixel(const Image *,const ssize_t,const ssize_t,
MagickPixelPacket *,ExceptionInfo *),
GetOneVirtualPixel(const Image *,const ssize_t,const ssize_t,PixelPacket *,
ExceptionInfo *),
GetOneVirtualMethodPixel(const Image *,const VirtualPixelMethod,const ssize_t,
const ssize_t,PixelPacket *,ExceptionInfo *),
GetOneAuthenticPixel(Image *,const ssize_t,const ssize_t,PixelPacket *,
ExceptionInfo *),
PersistPixelCache(Image *,const char *,const MagickBooleanType,
MagickOffsetType *,ExceptionInfo *),
SyncAuthenticPixels(Image *,ExceptionInfo *);
extern MagickExport MagickSizeType
GetImageExtent(const Image *);
extern MagickExport PixelPacket
*GetAuthenticPixels(Image *,const ssize_t,const ssize_t,const size_t,
const size_t,ExceptionInfo *),
*GetAuthenticPixelQueue(const Image *),
*QueueAuthenticPixels(Image *,const ssize_t,const ssize_t,const size_t,
const size_t,ExceptionInfo *);
extern MagickExport VirtualPixelMethod
GetPixelCacheVirtualMethod(const Image *),
SetPixelCacheVirtualMethod(const Image *,const VirtualPixelMethod);
extern MagickExport void
CacheComponentTerminus(void),
*GetPixelCachePixels(Image *,MagickSizeType *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/matrix.h 0000644 00000003343 15051111170 0007447 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore matrix methods.
*/
#ifndef MAGICKCORE_MATRIX_H
#define MAGICKCORE_MATRIX_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _MatrixInfo
MatrixInfo;
extern MagickExport double
**AcquireMagickMatrix(const size_t,const size_t),
**RelinquishMagickMatrix(double **,const size_t);
extern MagickExport Image
*MatrixToImage(const MatrixInfo *,ExceptionInfo *);
extern MagickExport MagickBooleanType
GaussJordanElimination(double **,double **,const size_t,const size_t),
GetMatrixElement(const MatrixInfo *,const ssize_t,const ssize_t,void *),
NullMatrix(MatrixInfo *),
SetMatrixElement(const MatrixInfo *,const ssize_t,const ssize_t,const void *);
MagickExport MatrixInfo
*AcquireMatrixInfo(const size_t,const size_t,const size_t,ExceptionInfo *),
*DestroyMatrixInfo(MatrixInfo *);
MagickExport size_t
GetMatrixColumns(const MatrixInfo *),
GetMatrixRows(const MatrixInfo *);
extern MagickExport void
LeastSquaresAddTerms(double **,double **,const double *,const double *,
const size_t,const size_t);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/identify.h 0000644 00000001713 15051111170 0007453 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand identify command-line method.
*/
#ifndef MAGICKWAND_IDENTIFY_H
#define MAGICKWAND_IDENTIFY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
IdentifyImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/composite.h 0000644 00000001717 15051111170 0007646 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand composite command-line method.
*/
#ifndef MAGICKWAND_COMPOSITE_H
#define MAGICKWAND_COMPOSITE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
CompositeImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/wand-view.h 0000644 00000004563 15051111170 0007547 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand wand view methods.
*/
#ifndef MAGICKWAND_WAND_VIEW_H
#define MAGICKWAND_WAND_VIEW_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _WandView
WandView;
typedef MagickBooleanType
(*DuplexTransferWandViewMethod)(const WandView *,const WandView *,WandView *,
const ssize_t,const int,void *),
(*GetWandViewMethod)(const WandView *,const ssize_t,const int,void *),
(*SetWandViewMethod)(WandView *,const ssize_t,const int,void *),
(*TransferWandViewMethod)(const WandView *,WandView *,const ssize_t,
const int,void *),
(*UpdateWandViewMethod)(WandView *,const ssize_t,const int,void *);
extern WandExport char
*GetWandViewException(const WandView *,ExceptionType *);
extern WandExport MagickBooleanType
DuplexTransferWandViewIterator(WandView *,WandView *,WandView *,
DuplexTransferWandViewMethod,void *),
GetWandViewIterator(WandView *,GetWandViewMethod,void *),
IsWandView(const WandView *),
SetWandViewIterator(WandView *,SetWandViewMethod,void *),
TransferWandViewIterator(WandView *,WandView *,TransferWandViewMethod,void *),
UpdateWandViewIterator(WandView *,UpdateWandViewMethod,void *);
extern WandExport MagickWand
*GetWandViewWand(const WandView *);
extern WandExport PixelWand
**GetWandViewPixels(const WandView *);
extern WandExport RectangleInfo
GetWandViewExtent(const WandView *);
extern WandExport void
SetWandViewDescription(WandView *,const char *),
SetWandViewThreads(WandView *,const size_t);
extern WandExport WandView
*CloneWandView(const WandView *),
*DestroyWandView(WandView *),
*NewWandView(MagickWand *),
*NewWandViewExtent(MagickWand *,const ssize_t,const ssize_t,const size_t,
const size_t);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/MagickWand.h 0000644 00000006747 15051111170 0007661 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand Application Programming Interface declarations.
*/
#ifndef _MAGICK_WAND_H
#define _MAGICK_WAND_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if !defined(MAGICKWAND_CONFIG_H)
# define MAGICKWAND_CONFIG_H
# if !defined(vms) && !defined(macintosh)
# include "magick/magick-config.h"
# else
# include "magick-config.h"
# endif
#if defined(_magickcore_const) && !defined(const)
# define const _magickcore_const
#endif
#if defined(_magickcore_inline) && !defined(inline)
# define inline _magickcore_inline
#endif
#if !defined(magick_restrict)
# if !defined(_magickcore_restrict)
# define magick_restrict restrict
# else
# define magick_restrict _magickcore_restrict
# endif
#endif
# if defined(__cplusplus) || defined(c_plusplus)
# undef inline
# endif
#endif
#define MAGICKWAND_CHECK_VERSION(major,minor,micro) \
((MAGICKWAND_MAJOR_VERSION > (major)) || \
((MAGICKWAND_MAJOR_VERSION == (major)) && \
(MAGICKWAND_MINOR_VERSION > (minor))) || \
((MAGICKWAND_MAJOR_VERSION == (major)) && \
(MAGICKWAND_MINOR_VERSION == (minor)) && \
(MAGICKWAND_MICRO_VERSION >= (micro))))
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
#include <sys/types.h>
#include <time.h>
#if defined(WIN32) || defined(WIN64)
# define MAGICKWAND_WINDOWS_SUPPORT
#else
# define MAGICKWAND_POSIX_SUPPORT
#endif
typedef struct _MagickWand
MagickWand;
#include "wand/method-attribute.h"
#include "magick/MagickCore.h"
#include "wand/animate.h"
#include "wand/compare.h"
#include "wand/composite.h"
#include "wand/conjure.h"
#include "wand/convert.h"
#include "wand/deprecate.h"
#include "wand/display.h"
#include "wand/drawing-wand.h"
#include "wand/identify.h"
#include "wand/import.h"
#include "wand/magick-property.h"
#include "wand/magick-image.h"
#include "wand/mogrify.h"
#include "wand/montage.h"
#include "wand/pixel-iterator.h"
#include "wand/pixel-wand.h"
#include "wand/stream.h"
#include "wand/wand-view.h"
extern WandExport char
*MagickGetException(const MagickWand *,ExceptionType *);
extern WandExport ExceptionType
MagickGetExceptionType(const MagickWand *);
extern WandExport MagickBooleanType
IsMagickWand(const MagickWand *),
IsMagickWandInstantiated(void),
MagickClearException(MagickWand *),
MagickSetIteratorIndex(MagickWand *,const ssize_t);
extern WandExport MagickWand
*CloneMagickWand(const MagickWand *),
*DestroyMagickWand(MagickWand *),
*NewMagickWand(void),
*NewMagickWandFromImage(const Image *);
extern WandExport ssize_t
MagickGetIteratorIndex(MagickWand *);
extern WandExport void
ClearMagickWand(MagickWand *),
MagickWandGenesis(void),
MagickWandTerminus(void),
*MagickRelinquishMemory(void *),
MagickResetIterator(MagickWand *),
MagickSetFirstIterator(MagickWand *),
MagickSetLastIterator(MagickWand *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/mogrify.h 0000644 00000002735 15051111170 0007321 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand mogrify command-line method.
*/
#ifndef MAGICKWAND_MOGRIFY_H
#define MAGICKWAND_MOGRIFY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef MagickBooleanType
(*MagickCommand)(ImageInfo *,int,char **,char **,ExceptionInfo *);
extern WandExport MagickBooleanType
MagickCommandGenesis(ImageInfo *,MagickCommand,int,char **,char **,
ExceptionInfo *),
MogrifyImage(ImageInfo *,const int,const char **,Image **,ExceptionInfo *),
MogrifyImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *),
MogrifyImageInfo(ImageInfo *,const int,const char **,ExceptionInfo *),
MogrifyImageList(ImageInfo *,const int,const char **,Image **,
ExceptionInfo *),
MogrifyImages(ImageInfo *,const MagickBooleanType,const int,const char **,
Image **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/animate.h 0000644 00000001710 15051111170 0007253 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand animate command-line methods.
*/
#ifndef MAGICKWAND_ANIMATE_H
#define MAGICKWAND_ANIMATE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
AnimateImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/pixel-wand.h 0000644 00000010772 15051111170 0007715 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand pixel wand methods.
*/
#ifndef MAGICKWAND_PIXEL_WAND_H
#define MAGICKWAND_PIXEL_WAND_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _PixelWand
PixelWand;
extern WandExport char
*PixelGetColorAsNormalizedString(const PixelWand *),
*PixelGetColorAsString(const PixelWand *),
*PixelGetException(const PixelWand *,ExceptionType *);
extern WandExport double
PixelGetAlpha(const PixelWand *) magick_attribute((__pure__)),
PixelGetBlack(const PixelWand *) magick_attribute((__pure__)),
PixelGetBlue(const PixelWand *) magick_attribute((__pure__)),
PixelGetCyan(const PixelWand *) magick_attribute((__pure__)),
PixelGetFuzz(const PixelWand *) magick_attribute((__pure__)),
PixelGetGreen(const PixelWand *) magick_attribute((__pure__)),
PixelGetMagenta(const PixelWand *) magick_attribute((__pure__)),
PixelGetOpacity(const PixelWand *) magick_attribute((__pure__)),
PixelGetRed(const PixelWand *) magick_attribute((__pure__)),
PixelGetYellow(const PixelWand *) magick_attribute((__pure__));
extern WandExport ExceptionType
PixelGetExceptionType(const PixelWand *);
extern WandExport IndexPacket
PixelGetIndex(const PixelWand *);
extern WandExport MagickBooleanType
IsPixelWand(const PixelWand *),
IsPixelWandSimilar(PixelWand *,PixelWand *,const double),
PixelClearException(PixelWand *),
PixelSetColor(PixelWand *,const char *);
extern WandExport PixelWand
*ClonePixelWand(const PixelWand *),
**ClonePixelWands(const PixelWand **,const size_t),
*DestroyPixelWand(PixelWand *),
**DestroyPixelWands(PixelWand **,const size_t),
*NewPixelWand(void),
**NewPixelWands(const size_t);
extern WandExport Quantum
PixelGetAlphaQuantum(const PixelWand *) magick_attribute((__pure__)),
PixelGetBlackQuantum(const PixelWand *) magick_attribute((__pure__)),
PixelGetBlueQuantum(const PixelWand *) magick_attribute((__pure__)),
PixelGetCyanQuantum(const PixelWand *) magick_attribute((__pure__)),
PixelGetGreenQuantum(const PixelWand *) magick_attribute((__pure__)),
PixelGetMagentaQuantum(const PixelWand *) magick_attribute((__pure__)),
PixelGetOpacityQuantum(const PixelWand *) magick_attribute((__pure__)),
PixelGetRedQuantum(const PixelWand *) magick_attribute((__pure__)),
PixelGetYellowQuantum(const PixelWand *) magick_attribute((__pure__));
extern WandExport size_t
PixelGetColorCount(const PixelWand *) magick_attribute((__pure__));
extern WandExport void
ClearPixelWand(PixelWand *),
PixelGetHSL(const PixelWand *,double *,double *,double *),
PixelGetMagickColor(const PixelWand *,MagickPixelPacket *),
PixelGetQuantumColor(const PixelWand *,PixelPacket *),
PixelSetAlpha(PixelWand *,const double),
PixelSetAlphaQuantum(PixelWand *,const Quantum),
PixelSetBlack(PixelWand *,const double),
PixelSetBlackQuantum(PixelWand *,const Quantum),
PixelSetBlue(PixelWand *,const double),
PixelSetBlueQuantum(PixelWand *,const Quantum),
PixelSetColorFromWand(PixelWand *,const PixelWand *),
PixelSetColorCount(PixelWand *,const size_t),
PixelSetCyan(PixelWand *,const double),
PixelSetCyanQuantum(PixelWand *,const Quantum),
PixelSetFuzz(PixelWand *,const double),
PixelSetGreen(PixelWand *,const double),
PixelSetGreenQuantum(PixelWand *,const Quantum),
PixelSetHSL(PixelWand *,const double,const double,const double),
PixelSetIndex(PixelWand *,const IndexPacket),
PixelSetMagenta(PixelWand *,const double),
PixelSetMagentaQuantum(PixelWand *,const Quantum),
PixelSetMagickColor(PixelWand *,const MagickPixelPacket *),
PixelSetOpacity(PixelWand *,const double),
PixelSetOpacityQuantum(PixelWand *,const Quantum),
PixelSetQuantumColor(PixelWand *,const PixelPacket *),
PixelSetRed(PixelWand *,const double),
PixelSetRedQuantum(PixelWand *,const Quantum),
PixelSetYellow(PixelWand *,const double),
PixelSetYellowQuantum(PixelWand *,const Quantum);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/magick-wand.h 0000644 00000001450 15051111170 0010020 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand API (deprecated, use magick-wand.h instead).
*/
#ifndef MAGICKWAND_MAGICK_WAND_DEPRECATED_H
#define MAGICKWAND_MAGICK_WAND_DEPRECATED_H
#include "wand/MagickWand.h"
#endif
wand/magick-image.h 0000644 00000054036 15051111170 0010161 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand image Methods.
*/
#ifndef MAGICKWAND_MAGICK_IMAGE_H
#define MAGICKWAND_MAGICK_IMAGE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport ChannelFeatures
*MagickGetImageChannelFeatures(MagickWand *,const size_t);
extern WandExport ChannelStatistics
*MagickGetImageChannelStatistics(MagickWand *);
extern WandExport char
*MagickGetImageFilename(MagickWand *),
*MagickGetImageFormat(MagickWand *),
*MagickGetImageSignature(MagickWand *),
*MagickIdentifyImage(MagickWand *);
extern WandExport ColorspaceType
MagickGetImageColorspace(MagickWand *);
extern WandExport CompositeOperator
MagickGetImageCompose(MagickWand *);
extern WandExport CompressionType
MagickGetImageCompression(MagickWand *);
extern WandExport DisposeType
MagickGetImageDispose(MagickWand *);
extern WandExport double
*MagickGetImageChannelDistortions(MagickWand *,const MagickWand *,
const MetricType),
MagickGetImageFuzz(MagickWand *),
MagickGetImageGamma(MagickWand *),
MagickGetImageTotalInkDensity(MagickWand *);
extern WandExport EndianType
MagickGetImageEndian(MagickWand *);
extern WandExport GravityType
MagickGetImageGravity(MagickWand *);
extern WandExport Image
*MagickDestroyImage(Image *),
*GetImageFromMagickWand(const MagickWand *);
extern WandExport ImageType
MagickGetImageType(MagickWand *);
extern WandExport InterlaceType
MagickGetImageInterlaceScheme(MagickWand *);
extern WandExport InterpolatePixelMethod
MagickGetImageInterpolateMethod(MagickWand *);
extern WandExport MagickBooleanType
MagickAdaptiveBlurImage(MagickWand *,const double,const double),
MagickAdaptiveBlurImageChannel(MagickWand *,const ChannelType,const double,
const double),
MagickAdaptiveResizeImage(MagickWand *,const size_t,const size_t),
MagickAdaptiveSharpenImage(MagickWand *,const double,const double),
MagickAdaptiveSharpenImageChannel(MagickWand *,const ChannelType,const double,
const double),
MagickAdaptiveThresholdImage(MagickWand *,const size_t,const size_t,
const ssize_t),
MagickAddImage(MagickWand *,const MagickWand *),
MagickAddNoiseImage(MagickWand *,const NoiseType),
MagickAddNoiseImageChannel(MagickWand *,const ChannelType,const NoiseType),
MagickAffineTransformImage(MagickWand *,const DrawingWand *),
MagickAnnotateImage(MagickWand *,const DrawingWand *,const double,
const double,const double,const char *),
MagickAnimateImages(MagickWand *,const char *),
MagickAutoGammaImage(MagickWand *),
MagickAutoGammaImageChannel(MagickWand *,const ChannelType),
MagickAutoLevelImage(MagickWand *),
MagickAutoLevelImageChannel(MagickWand *,const ChannelType),
MagickAutoOrientImage(MagickWand *),
MagickBlackThresholdImage(MagickWand *,const PixelWand *),
MagickBlueShiftImage(MagickWand *,const double),
MagickBlurImage(MagickWand *,const double,const double),
MagickBlurImageChannel(MagickWand *,const ChannelType,const double,
const double),
MagickBorderImage(MagickWand *,const PixelWand *,const size_t,const size_t),
MagickBrightnessContrastImage(MagickWand *,const double,const double),
MagickBrightnessContrastImageChannel(MagickWand *,const ChannelType,
const double,const double),
MagickCharcoalImage(MagickWand *,const double,const double),
MagickChopImage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t),
MagickClampImage(MagickWand *),
MagickClampImageChannel(MagickWand *,const ChannelType),
MagickClipImage(MagickWand *),
MagickClipImagePath(MagickWand *,const char *,const MagickBooleanType),
MagickClutImage(MagickWand *,const MagickWand *),
MagickClutImageChannel(MagickWand *,const ChannelType,const MagickWand *),
MagickColorDecisionListImage(MagickWand *,const char *),
MagickColorizeImage(MagickWand *,const PixelWand *,const PixelWand *),
MagickColorMatrixImage(MagickWand *,const KernelInfo *),
MagickCommentImage(MagickWand *,const char *),
MagickCompositeImage(MagickWand *,const MagickWand *,const CompositeOperator,
const ssize_t,const ssize_t),
MagickCompositeImageChannel(MagickWand *,const ChannelType,const MagickWand *,
const CompositeOperator,const ssize_t,const ssize_t),
MagickCompositeImageGravity(MagickWand *,const MagickWand *,
const CompositeOperator,const GravityType),
MagickCompositeLayers(MagickWand *,const MagickWand *,const CompositeOperator,
const ssize_t,const ssize_t),
MagickConstituteImage(MagickWand *,const size_t,const size_t,const char *,
const StorageType,const void *),
MagickContrastImage(MagickWand *,const MagickBooleanType),
MagickContrastStretchImage(MagickWand *,const double,const double),
MagickContrastStretchImageChannel(MagickWand *,const ChannelType,const double,
const double),
MagickConvolveImage(MagickWand *,const size_t,const double *),
MagickConvolveImageChannel(MagickWand *,const ChannelType,const size_t,
const double *),
MagickCropImage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t),
MagickCycleColormapImage(MagickWand *,const ssize_t),
MagickDecipherImage(MagickWand *,const char *),
MagickDeskewImage(MagickWand *,const double),
MagickDespeckleImage(MagickWand *),
MagickDisplayImage(MagickWand *,const char *),
MagickDisplayImages(MagickWand *,const char *),
MagickDistortImage(MagickWand *,const DistortImageMethod,const size_t,
const double *,const MagickBooleanType),
MagickDrawImage(MagickWand *,const DrawingWand *),
MagickEdgeImage(MagickWand *,const double),
MagickEmbossImage(MagickWand *,const double,const double),
MagickEncipherImage(MagickWand *,const char *),
MagickEnhanceImage(MagickWand *),
MagickEqualizeImage(MagickWand *),
MagickEqualizeImageChannel(MagickWand *,const ChannelType),
MagickEvaluateImage(MagickWand *,const MagickEvaluateOperator,const double),
MagickEvaluateImageChannel(MagickWand *,const ChannelType,
const MagickEvaluateOperator,const double),
MagickExportImagePixels(MagickWand *,const ssize_t,const ssize_t,
const size_t,const size_t,const char *,const StorageType,void *),
MagickExtentImage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t),
MagickFilterImage(MagickWand *,const KernelInfo *),
MagickFilterImageChannel(MagickWand *,const ChannelType,const KernelInfo *),
MagickFlipImage(MagickWand *),
MagickFloodfillPaintImage(MagickWand *,const ChannelType,const PixelWand *,
const double,const PixelWand *,const ssize_t,const ssize_t,
const MagickBooleanType),
MagickFlopImage(MagickWand *),
MagickForwardFourierTransformImage(MagickWand *,const MagickBooleanType),
MagickFrameImage(MagickWand *,const PixelWand *,const size_t,const size_t,
const ssize_t,const ssize_t),
MagickFunctionImage(MagickWand *,const MagickFunction,const size_t,
const double *),
MagickFunctionImageChannel(MagickWand *,const ChannelType,
const MagickFunction,const size_t,const double *),
MagickGammaImage(MagickWand *,const double),
MagickGammaImageChannel(MagickWand *,const ChannelType,const double),
MagickGaussianBlurImage(MagickWand *,const double,const double),
MagickGaussianBlurImageChannel(MagickWand *,const ChannelType,const double,
const double),
MagickGetImageAlphaChannel(MagickWand *),
MagickGetImageBackgroundColor(MagickWand *,PixelWand *),
MagickGetImageBluePrimary(MagickWand *,double *,double *),
MagickGetImageBorderColor(MagickWand *,PixelWand *),
MagickGetImageChannelDistortion(MagickWand *,const MagickWand *,
const ChannelType,const MetricType,double *),
MagickGetImageChannelKurtosis(MagickWand *,const ChannelType,double *,
double *),
MagickGetImageChannelMean(MagickWand *,const ChannelType,double *,double *),
MagickGetImageChannelRange(MagickWand *,const ChannelType,double *,double *),
MagickGetImageColormapColor(MagickWand *,const size_t,PixelWand *),
MagickGetImageDistortion(MagickWand *,const MagickWand *,const MetricType,
double *),
MagickGetImageGreenPrimary(MagickWand *,double *,double *),
MagickGetImageMatteColor(MagickWand *,PixelWand *),
MagickGetImageLength(MagickWand *,MagickSizeType *),
MagickGetImagePage(MagickWand *,size_t *,size_t *,ssize_t *,
ssize_t *),
MagickGetImagePixelColor(MagickWand *,const ssize_t,const ssize_t,
PixelWand *),
MagickGetImageRange(MagickWand *,double *,double *),
MagickGetImageRedPrimary(MagickWand *,double *,double *),
MagickGetImageResolution(MagickWand *,double *,double *),
MagickGetImageWhitePoint(MagickWand *,double *,double *),
MagickHaldClutImage(MagickWand *,const MagickWand *),
MagickHaldClutImageChannel(MagickWand *,const ChannelType,const MagickWand *),
MagickHasNextImage(MagickWand *),
MagickHasPreviousImage(MagickWand *),
MagickImplodeImage(MagickWand *,const double),
MagickImportImagePixels(MagickWand *,const ssize_t,const ssize_t,const size_t,
const size_t,const char *,const StorageType,const void *),
MagickInverseFourierTransformImage(MagickWand *,MagickWand *,
const MagickBooleanType),
MagickLabelImage(MagickWand *,const char *),
MagickLevelImage(MagickWand *,const double,const double,const double),
MagickLevelImageChannel(MagickWand *,const ChannelType,const double,
const double,const double),
MagickLevelImageColors(MagickWand *,const PixelWand *,const PixelWand *,
const MagickBooleanType),
MagickLevelImageColorsChannel(MagickWand *,const ChannelType,
const PixelWand *,const PixelWand *,const MagickBooleanType),
MagickLevelizeImage(MagickWand *,const double,const double,const double),
MagickLevelizeImageChannel(MagickWand *,const ChannelType,const double,
const double,const double),
MagickLinearStretchImage(MagickWand *,const double,const double),
MagickLiquidRescaleImage(MagickWand *,const size_t,const size_t,const double,
const double),
MagickLocalContrastImage(MagickWand *,const double,const double),
MagickMagnifyImage(MagickWand *),
MagickMedianFilterImage(MagickWand *,const double),
MagickMinifyImage(MagickWand *),
MagickModeImage(MagickWand *,const double),
MagickModulateImage(MagickWand *,const double,const double,const double),
MagickMorphologyImage(MagickWand *,const MorphologyMethod,const ssize_t,
const KernelInfo *),
MagickMorphologyImageChannel(MagickWand *,const ChannelType,
const MorphologyMethod,const ssize_t,const KernelInfo *),
MagickMotionBlurImage(MagickWand *,const double,const double,const double),
MagickMotionBlurImageChannel(MagickWand *,const ChannelType,const double,
const double,const double),
MagickNegateImage(MagickWand *,const MagickBooleanType),
MagickNegateImageChannel(MagickWand *,const ChannelType,
const MagickBooleanType),
MagickNewImage(MagickWand *,const size_t,const size_t,const PixelWand *),
MagickNextImage(MagickWand *),
MagickNormalizeImage(MagickWand *),
MagickNormalizeImageChannel(MagickWand *,const ChannelType),
MagickOilPaintImage(MagickWand *,const double),
MagickOpaquePaintImage(MagickWand *,const PixelWand *,const PixelWand *,
const double,const MagickBooleanType),
MagickOpaquePaintImageChannel(MagickWand *,const ChannelType,
const PixelWand *,const PixelWand *,const double,const MagickBooleanType),
MagickOrderedPosterizeImage(MagickWand *,const char *),
MagickOrderedPosterizeImageChannel(MagickWand *,const ChannelType,
const char *),
MagickOptimizeImageTransparency(MagickWand *),
MagickTransparentPaintImage(MagickWand *,const PixelWand *,
const double,const double,const MagickBooleanType invert),
MagickPingImage(MagickWand *,const char *),
MagickPingImageBlob(MagickWand *,const void *,const size_t),
MagickPingImageFile(MagickWand *,FILE *),
MagickPolaroidImage(MagickWand *,const DrawingWand *,const double),
MagickPosterizeImage(MagickWand *,const size_t,const MagickBooleanType),
MagickPreviousImage(MagickWand *),
MagickQuantizeImage(MagickWand *,const size_t,const ColorspaceType,
const size_t,const MagickBooleanType,const MagickBooleanType),
MagickQuantizeImages(MagickWand *,const size_t,const ColorspaceType,
const size_t,const MagickBooleanType,const MagickBooleanType),
MagickRaiseImage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t,const MagickBooleanType),
MagickRandomThresholdImage(MagickWand *,const double,const double),
MagickRandomThresholdImageChannel(MagickWand *,const ChannelType,const double,
const double),
MagickReadImage(MagickWand *,const char *),
MagickReadImageBlob(MagickWand *,const void *,const size_t),
MagickReadImageFile(MagickWand *,FILE *),
MagickReduceNoiseImage(MagickWand *,const double),
MagickRemapImage(MagickWand *,const MagickWand *,const DitherMethod),
MagickRemoveImage(MagickWand *),
MagickResampleImage(MagickWand *,const double,const double,const FilterTypes,
const double),
MagickResetImagePage(MagickWand *,const char *),
MagickResizeImage(MagickWand *,const size_t,const size_t,const FilterTypes,
const double),
MagickRollImage(MagickWand *,const ssize_t,const ssize_t),
MagickRotateImage(MagickWand *,const PixelWand *,const double),
MagickRotationalBlurImage(MagickWand *,const double),
MagickRotationalBlurImageChannel(MagickWand *,const ChannelType,
const double),
MagickSampleImage(MagickWand *,const size_t,const size_t),
MagickScaleImage(MagickWand *,const size_t,const size_t),
MagickSegmentImage(MagickWand *,const ColorspaceType,const MagickBooleanType,
const double,const double),
MagickSelectiveBlurImage(MagickWand *,const double,const double,const double),
MagickSelectiveBlurImageChannel(MagickWand *,const ChannelType,const double,
const double,const double),
MagickSeparateImageChannel(MagickWand *,const ChannelType),
MagickSepiaToneImage(MagickWand *,const double),
MagickSetImage(MagickWand *,const MagickWand *),
MagickSetImageAlphaChannel(MagickWand *,const AlphaChannelType),
MagickSetImageBackgroundColor(MagickWand *,const PixelWand *),
MagickSetImageBias(MagickWand *,const double),
MagickSetImageBluePrimary(MagickWand *,const double,const double),
MagickSetImageBorderColor(MagickWand *,const PixelWand *),
MagickSetImageChannelDepth(MagickWand *,const ChannelType,const size_t),
MagickSetImageClipMask(MagickWand *,const MagickWand *),
MagickSetImageColor(MagickWand *,const PixelWand *),
MagickSetImageColormapColor(MagickWand *,const size_t,
const PixelWand *),
MagickSetImageColorspace(MagickWand *,const ColorspaceType),
MagickSetImageCompose(MagickWand *,const CompositeOperator),
MagickSetImageCompression(MagickWand *,const CompressionType),
MagickSetImageDelay(MagickWand *,const size_t),
MagickSetImageDepth(MagickWand *,const size_t),
MagickSetImageDispose(MagickWand *,const DisposeType),
MagickSetImageCompressionQuality(MagickWand *,const size_t),
MagickSetImageEndian(MagickWand *,const EndianType),
MagickSetImageExtent(MagickWand *,const size_t,const size_t),
MagickSetImageFilename(MagickWand *,const char *),
MagickSetImageFormat(MagickWand *,const char *),
MagickSetImageFuzz(MagickWand *,const double),
MagickSetImageGamma(MagickWand *,const double),
MagickSetImageGravity(MagickWand *,const GravityType),
MagickSetImageGreenPrimary(MagickWand *,const double,const double),
MagickSetImageInterlaceScheme(MagickWand *,const InterlaceType),
MagickSetImageInterpolateMethod(MagickWand *,const InterpolatePixelMethod),
MagickSetImageIterations(MagickWand *,const size_t),
MagickSetImageMatte(MagickWand *,const MagickBooleanType),
MagickSetImageMatteColor(MagickWand *,const PixelWand *),
MagickSetImageOpacity(MagickWand *,const double),
MagickSetImageOrientation(MagickWand *,const OrientationType),
MagickSetImagePage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t),
MagickSetImageRedPrimary(MagickWand *,const double,const double),
MagickSetImageRenderingIntent(MagickWand *,const RenderingIntent),
MagickSetImageResolution(MagickWand *,const double,const double),
MagickSetImageScene(MagickWand *,const size_t),
MagickSetImagePixelColor(MagickWand *,const ssize_t,const ssize_t,
const PixelWand *),
MagickSetImageTicksPerSecond(MagickWand *,const ssize_t),
MagickSetImageType(MagickWand *,const ImageType),
MagickSetImageUnits(MagickWand *,const ResolutionType),
MagickSetImageWhitePoint(MagickWand *,const double,const double),
MagickShadeImage(MagickWand *,const MagickBooleanType,const double,
const double),
MagickShadowImage(MagickWand *,const double,const double,const ssize_t,
const ssize_t),
MagickSharpenImage(MagickWand *,const double,const double),
MagickSharpenImageChannel(MagickWand *,const ChannelType,const double,
const double),
MagickShaveImage(MagickWand *,const size_t,const size_t),
MagickShearImage(MagickWand *,const PixelWand *,const double,const double),
MagickSigmoidalContrastImage(MagickWand *,const MagickBooleanType,
const double,const double),
MagickSigmoidalContrastImageChannel(MagickWand *,const ChannelType,
const MagickBooleanType,const double,const double),
MagickSketchImage(MagickWand *,const double,const double,const double),
MagickSolarizeImage(MagickWand *,const double),
MagickSolarizeImageChannel(MagickWand *,const ChannelType,const double),
MagickSparseColorImage(MagickWand *,const ChannelType,const SparseColorMethod,
const size_t,const double *),
MagickSpliceImage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t),
MagickSpreadImage(MagickWand *,const double),
MagickStatisticImage(MagickWand *,const StatisticType,const size_t,
const size_t),
MagickStatisticImageChannel(MagickWand *,const ChannelType,
const StatisticType,const size_t,const size_t),
MagickStripImage(MagickWand *),
MagickSwirlImage(MagickWand *,const double),
MagickTintImage(MagickWand *,const PixelWand *,const PixelWand *),
MagickTransformImageColorspace(MagickWand *,const ColorspaceType),
MagickTransposeImage(MagickWand *),
MagickTransverseImage(MagickWand *),
MagickThresholdImage(MagickWand *,const double),
MagickThresholdImageChannel(MagickWand *,const ChannelType,const double),
MagickThumbnailImage(MagickWand *,const size_t,const size_t),
MagickTrimImage(MagickWand *,const double),
MagickUniqueImageColors(MagickWand *),
MagickUnsharpMaskImage(MagickWand *,const double,const double,const double,
const double),
MagickUnsharpMaskImageChannel(MagickWand *,const ChannelType,const double,
const double,const double,const double),
MagickVignetteImage(MagickWand *,const double,const double,const ssize_t,
const ssize_t),
MagickWaveImage(MagickWand *,const double,const double),
MagickWhiteThresholdImage(MagickWand *,const PixelWand *),
MagickWriteImage(MagickWand *,const char *),
MagickWriteImageFile(MagickWand *,FILE *),
MagickWriteImages(MagickWand *,const char *,const MagickBooleanType),
MagickWriteImagesFile(MagickWand *,FILE *);
extern WandExport MagickProgressMonitor
MagickSetImageProgressMonitor(MagickWand *,const MagickProgressMonitor,
void *);
extern WandExport MagickWand
*MagickAppendImages(MagickWand *,const MagickBooleanType),
*MagickCoalesceImages(MagickWand *),
*MagickCombineImages(MagickWand *,const ChannelType),
*MagickCompareImageChannels(MagickWand *,const MagickWand *,const ChannelType,
const MetricType,double *),
*MagickCompareImages(MagickWand *,const MagickWand *,const MetricType,
double *),
*MagickCompareImageLayers(MagickWand *,const ImageLayerMethod),
*MagickDeconstructImages(MagickWand *),
*MagickEvaluateImages(MagickWand *,const MagickEvaluateOperator),
*MagickFxImage(MagickWand *,const char *),
*MagickFxImageChannel(MagickWand *,const ChannelType,const char *),
*MagickGetImage(MagickWand *),
*MagickGetImageClipMask(MagickWand *),
*MagickGetImageRegion(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t),
*MagickMergeImageLayers(MagickWand *,const ImageLayerMethod),
*MagickMorphImages(MagickWand *,const size_t),
*MagickMontageImage(MagickWand *,const DrawingWand *,const char *,
const char *,const MontageMode,const char *),
*MagickOptimizeImageLayers(MagickWand *),
*MagickPreviewImages(MagickWand *wand,const PreviewType),
*MagickSimilarityImage(MagickWand *,const MagickWand *,RectangleInfo *,
double *),
*MagickSmushImages(MagickWand *,const MagickBooleanType,const ssize_t),
*MagickSteganoImage(MagickWand *,const MagickWand *,const ssize_t),
*MagickStereoImage(MagickWand *,const MagickWand *),
*MagickTextureImage(MagickWand *,const MagickWand *),
*MagickTransformImage(MagickWand *,const char *,const char *);
extern WandExport OrientationType
MagickGetImageOrientation(MagickWand *);
extern WandExport PixelWand
**MagickGetImageHistogram(MagickWand *,size_t *);
extern WandExport RenderingIntent
MagickGetImageRenderingIntent(MagickWand *);
extern WandExport ResolutionType
MagickGetImageUnits(MagickWand *);
extern WandExport size_t
MagickGetImageColors(MagickWand *),
MagickGetImageCompressionQuality(MagickWand *),
MagickGetImageDelay(MagickWand *),
MagickGetImageChannelDepth(MagickWand *,const ChannelType),
MagickGetImageDepth(MagickWand *),
MagickGetImageHeight(MagickWand *),
MagickGetImageIterations(MagickWand *),
MagickGetImageScene(MagickWand *),
MagickGetImageTicksPerSecond(MagickWand *),
MagickGetImageWidth(MagickWand *),
MagickGetNumberImages(MagickWand *);
extern WandExport unsigned char
*MagickGetImageBlob(MagickWand *,size_t *),
*MagickGetImagesBlob(MagickWand *,size_t *);
extern WandExport VirtualPixelMethod
MagickGetImageVirtualPixelMethod(MagickWand *),
MagickSetImageVirtualPixelMethod(MagickWand *,const VirtualPixelMethod);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/deprecate.h 0000644 00000017257 15051111170 0007606 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore deprecated methods.
*/
#ifndef MAGICKWAND_DEPRECATE_H
#define MAGICKWAND_DEPRECATE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if !defined(MAGICKCORE_EXCLUDE_DEPRECATED)
#include "wand/drawing-wand.h"
#include "wand/magick-wand.h"
#include "wand/pixel-iterator.h"
#include "wand/pixel-wand.h"
typedef struct _DrawingWand
*DrawContext;
typedef struct _PixelView
PixelView;
extern WandExport DrawingWand
*DrawAllocateWand(const DrawInfo *,Image *);
typedef MagickBooleanType
(*DuplexTransferPixelViewMethod)(const PixelView *,const PixelView *,
PixelView *,void *),
(*GetPixelViewMethod)(const PixelView *,void *),
(*SetPixelViewMethod)(PixelView *,void *),
(*TransferPixelViewMethod)(const PixelView *,PixelView *,void *),
(*UpdatePixelViewMethod)(PixelView *,void *);
extern WandExport char
*GetPixelViewException(const PixelView *,ExceptionType *)
magick_attribute((deprecated));
extern WandExport double
DrawGetFillAlpha(const DrawingWand *) magick_attribute((deprecated)),
DrawGetStrokeAlpha(const DrawingWand *) magick_attribute((deprecated));
extern WandExport DrawInfo
*DrawPeekGraphicWand(const DrawingWand *) magick_attribute((deprecated));
extern WandExport char
*MagickDescribeImage(MagickWand *) magick_attribute((deprecated)),
*MagickGetImageAttribute(MagickWand *,const char *)
magick_attribute((deprecated)),
*PixelIteratorGetException(const PixelIterator *,ExceptionType *)
magick_attribute((deprecated));
extern WandExport ssize_t
MagickGetImageIndex(MagickWand *) magick_attribute((deprecated));
extern WandExport MagickBooleanType
DuplexTransferPixelViewIterator(PixelView *,PixelView *,PixelView *,
DuplexTransferPixelViewMethod,void *) magick_attribute((deprecated)),
GetPixelViewIterator(PixelView *,GetPixelViewMethod,void *)
magick_attribute((deprecated)),
IsPixelView(const PixelView *) magick_attribute((deprecated)),
MagickClipPathImage(MagickWand *,const char *,const MagickBooleanType)
magick_attribute((deprecated)),
MagickColorFloodfillImage(MagickWand *,const PixelWand *,const double,
const PixelWand *,const ssize_t,const ssize_t)
magick_attribute((deprecated)),
MagickGetImageChannelExtrema(MagickWand *,const ChannelType,size_t *,
size_t *) magick_attribute((deprecated)),
MagickGetImageExtrema(MagickWand *,size_t *,size_t *)
magick_attribute((deprecated)),
MagickGetImageMatte(MagickWand *) magick_attribute((deprecated)),
MagickGetImagePixels(MagickWand *,const ssize_t,const ssize_t,const size_t,
const size_t,const char *,const StorageType,void *)
magick_attribute((deprecated)),
MagickMapImage(MagickWand *,const MagickWand *,const MagickBooleanType)
magick_attribute((deprecated)),
MagickMatteFloodfillImage(MagickWand *,const double,const double,
const PixelWand *,const ssize_t,const ssize_t)
magick_attribute((deprecated)),
MagickMedianFilterImage(MagickWand *,const double)
magick_attribute((deprecated)),
MagickModeImage(MagickWand *,const double) magick_attribute((deprecated)),
MagickReduceNoiseImage(MagickWand *,const double)
magick_attribute((deprecated)),
MagickRemapImage(MagickWand *,const MagickWand *,const DitherMethod),
MagickOpaqueImage(MagickWand *,const PixelWand *,const PixelWand *,
const double) magick_attribute((deprecated)),
MagickPaintFloodfillImage(MagickWand *,const ChannelType,const PixelWand *,
const double,const PixelWand *,const ssize_t,const ssize_t)
magick_attribute((deprecated)),
MagickPaintOpaqueImage(MagickWand *,const PixelWand *,const PixelWand *,
const double) magick_attribute((deprecated)),
MagickPaintOpaqueImageChannel(MagickWand *,const ChannelType,
const PixelWand *,const PixelWand *,const double)
magick_attribute((deprecated)),
MagickPaintTransparentImage(MagickWand *,const PixelWand *,const double,
const double) magick_attribute((deprecated)),
MagickRadialBlurImage(MagickWand *,const double)
magick_attribute((deprecated)),
MagickRadialBlurImageChannel(MagickWand *,const ChannelType,const double)
magick_attribute((deprecated)),
MagickRecolorImage(MagickWand *,const size_t,const double *)
magick_attribute((deprecated)),
MagickSetImageAttribute(MagickWand *,const char *,const char *)
magick_attribute((deprecated)),
MagickSetImageIndex(MagickWand *,const ssize_t)
magick_attribute((deprecated)),
MagickSetImageOption(MagickWand *,const char *,const char *,const char *)
magick_attribute((deprecated)),
MagickSetImagePixels(MagickWand *,const ssize_t,const ssize_t,const size_t,
const size_t,const char *,const StorageType,const void *)
magick_attribute((deprecated)),
MagickTransparentImage(MagickWand *,const PixelWand *,const double,
const double) magick_attribute((deprecated)),
SetPixelViewIterator(PixelView *,SetPixelViewMethod,void *)
magick_attribute((deprecated)),
TransferPixelViewIterator(PixelView *,PixelView *,TransferPixelViewMethod,
void *) magick_attribute((deprecated)),
UpdatePixelViewIterator(PixelView *,UpdatePixelViewMethod,void *)
magick_attribute((deprecated));
extern WandExport MagickWand
*GetPixelViewWand(const PixelView *) magick_attribute((deprecated)),
*MagickAverageImages(MagickWand *) magick_attribute((deprecated)),
*MagickFlattenImages(MagickWand *) magick_attribute((deprecated)),
*MagickMaximumImages(MagickWand *) magick_attribute((deprecated)),
*MagickMinimumImages(MagickWand *) magick_attribute((deprecated)),
*MagickMosaicImages(MagickWand *) magick_attribute((deprecated)),
*MagickRegionOfInterestImage(MagickWand *,const size_t,const size_t,
const ssize_t,const ssize_t) magick_attribute((deprecated));
extern WandExport MagickSizeType
MagickGetImageSize(MagickWand *) magick_attribute((deprecated));
extern WandExport PixelView
*ClonePixelView(const PixelView *) magick_attribute((deprecated)),
*DestroyPixelView(PixelView *) magick_attribute((deprecated)),
*NewPixelView(MagickWand *) magick_attribute((deprecated)),
*NewPixelViewRegion(MagickWand *,const ssize_t,const ssize_t,const size_t,
const size_t) magick_attribute((deprecated));
extern WandExport PixelWand
**GetPixelViewPixels(const PixelView *) magick_attribute((deprecated)),
**PixelGetNextRow(PixelIterator *) magick_attribute((deprecated));
extern WandExport size_t
GetPixelViewHeight(const PixelView *) magick_attribute((deprecated)),
GetPixelViewWidth(const PixelView *) magick_attribute((deprecated));
extern WandExport ssize_t
GetPixelViewX(const PixelView *) magick_attribute((deprecated)),
GetPixelViewY(const PixelView *) magick_attribute((deprecated));
extern WandExport unsigned char
*MagickWriteImageBlob(MagickWand *,size_t *) magick_attribute((deprecated));
extern WandExport void
DrawPopGraphicContext(DrawingWand *) magick_attribute((deprecated)),
DrawPushGraphicContext(DrawingWand *) magick_attribute((deprecated)),
DrawSetFillAlpha(DrawingWand *,const double) magick_attribute((deprecated)),
DrawSetStrokeAlpha(DrawingWand *,const double) magick_attribute((deprecated));
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/import.h 0000644 00000001703 15051111170 0007151 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand import command-line method.
*/
#ifndef MAGICKWAND_IMPORT_H
#define MAGICKWAND_IMPORT_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
ImportImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/pixel-iterator.h 0000644 00000004040 15051111170 0010604 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Pixel Iterator Methods.
*/
#ifndef MAGICKWAND_PIXEL_ITERATOR_H
#define MAGICKWAND_PIXEL_ITERATOR_H
#include "wand/magick-wand.h"
#include "wand/pixel-wand.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _PixelIterator
PixelIterator;
extern WandExport char
*PixelGetIteratorException(const PixelIterator *,ExceptionType *);
extern WandExport ExceptionType
PixelGetIteratorExceptionType(const PixelIterator *);
extern WandExport MagickBooleanType
IsPixelIterator(const PixelIterator *),
PixelClearIteratorException(PixelIterator *),
PixelSetIteratorRow(PixelIterator *,const ssize_t),
PixelSyncIterator(PixelIterator *);
extern WandExport PixelIterator
*ClonePixelIterator(const PixelIterator *),
*DestroyPixelIterator(PixelIterator *),
*NewPixelIterator(MagickWand *),
*NewPixelRegionIterator(MagickWand *,const ssize_t,const ssize_t,const size_t,
const size_t);
extern WandExport PixelWand
**PixelGetCurrentIteratorRow(PixelIterator *,size_t *),
**PixelGetNextIteratorRow(PixelIterator *,size_t *),
**PixelGetPreviousIteratorRow(PixelIterator *,size_t *);
extern WandExport ssize_t
PixelGetIteratorRow(PixelIterator *);
extern WandExport void
ClearPixelIterator(PixelIterator *),
PixelResetIterator(PixelIterator *),
PixelSetFirstIteratorRow(PixelIterator *),
PixelSetLastIteratorRow(PixelIterator *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/magick_wand.h 0000644 00000001450 15051111170 0010102 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand API (deprecated, use magick-wand.h instead).
*/
#ifndef MAGICKWAND_MAGICK_WAND_DEPRECATED_H
#define MAGICKWAND_MAGICK_WAND_DEPRECATED_H
#include "wand/MagickWand.h"
#endif
wand/stream.h 0000644 00000001704 15051111170 0007133 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand montage command-line method.
*/
#ifndef MAGICKWAND_STREAM_H
#define MAGICKWAND_STREAM_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
StreamImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/method-attribute.h 0000644 00000007016 15051111170 0011123 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand method attribute.
*/
#ifndef MAGICKWAND_METHOD_ATTRIBUTE_H
#define MAGICKWAND_METHOD_ATTRIBUTE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if defined(_DLL)
# define _MAGICKDLL_
# define _MAGICKLIB_
# define MAGICKCORE_MODULES_SUPPORT
# undef MAGICKCORE_BUILD_MODULES
#endif
#if defined(MAGICKWAND_WINDOWS_SUPPORT) && !defined(__CYGWIN__)
# define WandPrivate
# if defined(_MT) && defined(_DLL) && !defined(_MAGICKDLL_) && !defined(_LIB)
# define _MAGICKDLL_
# endif
# if defined(_MAGICKDLL_)
# if defined(_VISUALC_)
# pragma warning( disable: 4273 ) /* Disable the dll linkage warnings */
# endif
# if !defined(_MAGICKLIB_)
# if defined(__clang__) || defined(__GNUC__)
# define WandExport __attribute__ ((dllimport))
# else
# define WandExport __declspec(dllimport)
# endif
# else
# if defined(__clang__) || defined(__GNUC__)
# define WandExport __attribute__ ((dllexport))
# else
# define WandExport __declspec(dllexport)
# endif
# endif
# else
# define WandExport
# endif
# if defined(_VISUALC_)
# pragma warning(disable : 4018)
# pragma warning(disable : 4068)
# pragma warning(disable : 4244)
# pragma warning(disable : 4142)
# pragma warning(disable : 4800)
# pragma warning(disable : 4786)
# pragma warning(disable : 4996)
# endif
#else
# if defined(__clang__) || (__GNUC__ >= 4)
# define WandExport __attribute__ ((visibility ("default")))
# define WandPrivate __attribute__ ((visibility ("hidden")))
# else
# define WandExport
# define WandPrivate
# endif
#endif
#define WandSignature 0xabacadabUL
#if !defined(MaxTextExtent)
# define MaxTextExtent 4096
#endif
#if defined(MAGICKCORE_HAVE___ATTRIBUTE__)
# define wand_aligned(x) __attribute__((aligned(x)))
# define wand_attribute __attribute__
# define wand_unused(x) wand_unused_ ## x __attribute__((unused))
# define wand_unreferenced(x)
#elif defined(MAGICKWAND_WINDOWS_SUPPORT) && !defined(__CYGWIN__)
# define wand_aligned(x) __declspec(align(x))
# define wand_attribute(x) /* nothing */
# define wand_unused(x) x
# define wand_unreferenced(x) (x)
#else
# define wand_aligned(x) /* nothing */
# define wand_attribute(x) /* nothing */
# define wand_unused(x) x
# define wand_unreferenced(x) /* nothing */
#endif
#if !defined(__clang__) && (defined(__GNUC__) && (__GNUC__) > 4)
# define wand_alloc_size(x) __attribute__((__alloc_size__(x)))
# define wand_alloc_sizes(x,y) __attribute__((__alloc_size__(x,y)))
#else
# define wand_alloc_size(x) /* nothing */
# define wand_alloc_sizes(x,y) /* nothing */
#endif
#if !defined(__clang__) && (defined(__GNUC__) && (__GNUC__) > 4)
# define wand_cold_spot __attribute__((__cold__))
# define wand_hot_spot __attribute__((__hot__))
#else
# define wand_cold_spot
# define wand_hot_spot
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/convert.h 0000644 00000001707 15051111170 0007323 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand convert command-line method.
*/
#ifndef MAGICKWAND_CONVERT_H
#define MAGICKWAND_CONVERT_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
ConvertImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/compare.h 0000644 00000001707 15051111170 0007271 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand compare command-line method.
*/
#ifndef MAGICKWAND_COMPARE_H
#define MAGICKWAND_COMPARE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
CompareImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/drawing-wand.h 0000644 00000023305 15051111170 0010223 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand drawing wand methods.
*/
#ifndef MAGICKWAND_DRAWING_WAND_H
#define MAGICKWAND_DRAWING_WAND_H
#include "wand/pixel-wand.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _DrawingWand
DrawingWand;
extern WandExport AlignType
DrawGetTextAlignment(const DrawingWand *);
extern WandExport char
*DrawGetClipPath(const DrawingWand *),
*DrawGetDensity(const DrawingWand *),
*DrawGetException(const DrawingWand *,ExceptionType *),
*DrawGetFont(const DrawingWand *),
*DrawGetFontFamily(const DrawingWand *),
*DrawGetTextEncoding(const DrawingWand *),
*DrawGetVectorGraphics(DrawingWand *);
extern WandExport ClipPathUnits
DrawGetClipUnits(const DrawingWand *) magick_attribute((__pure__));
extern WandExport DecorationType
DrawGetTextDecoration(const DrawingWand *) magick_attribute((__pure__));
extern WandExport DirectionType
DrawGetTextDirection(const DrawingWand *);
extern WandExport double
DrawGetFillOpacity(const DrawingWand *) magick_attribute((__pure__)),
DrawGetFontSize(const DrawingWand *) magick_attribute((__pure__)),
DrawGetOpacity(const DrawingWand *) magick_attribute((__pure__)),
*DrawGetStrokeDashArray(const DrawingWand *,size_t *),
DrawGetStrokeDashOffset(const DrawingWand *) magick_attribute((__pure__)),
DrawGetStrokeOpacity(const DrawingWand *) magick_attribute((__pure__)),
DrawGetStrokeWidth(const DrawingWand *) magick_attribute((__pure__)),
DrawGetTextKerning(DrawingWand *) magick_attribute((__pure__)),
DrawGetTextInterlineSpacing(DrawingWand *) magick_attribute((__pure__)),
DrawGetTextInterwordSpacing(DrawingWand *) magick_attribute((__pure__));
extern WandExport DrawInfo
*PeekDrawingWand(const DrawingWand *);
extern WandExport DrawingWand
*AcquireDrawingWand(const DrawInfo *,Image *),
*CloneDrawingWand(const DrawingWand *),
*DestroyDrawingWand(DrawingWand *),
*NewDrawingWand(void);
extern WandExport ExceptionType
DrawGetExceptionType(const DrawingWand *);
extern WandExport FillRule
DrawGetClipRule(const DrawingWand *) magick_attribute((__pure__)),
DrawGetFillRule(const DrawingWand *) magick_attribute((__pure__));
extern WandExport GravityType
DrawGetGravity(const DrawingWand *) magick_attribute((__pure__));
extern WandExport LineCap
DrawGetStrokeLineCap(const DrawingWand *) magick_attribute((__pure__));
extern WandExport LineJoin
DrawGetStrokeLineJoin(const DrawingWand *) magick_attribute((__pure__));
extern WandExport MagickBooleanType
DrawClearException(DrawingWand *),
DrawComposite(DrawingWand *,const CompositeOperator,const double,const double,
const double,const double,MagickWand *),
DrawGetFontResolution(const DrawingWand *,double *,double *),
DrawGetStrokeAntialias(const DrawingWand *) magick_attribute((__pure__)),
DrawGetTextAntialias(const DrawingWand *) magick_attribute((__pure__)),
DrawPopPattern(DrawingWand *),
DrawPushPattern(DrawingWand *,const char *,const double,const double,
const double,const double),
DrawRender(DrawingWand *),
DrawSetClipPath(DrawingWand *,const char *),
DrawSetDensity(DrawingWand *,const char *),
DrawSetFillPatternURL(DrawingWand *,const char *),
DrawSetFont(DrawingWand *,const char *),
DrawSetFontFamily(DrawingWand *,const char *),
DrawSetFontResolution(DrawingWand *,const double,const double),
DrawSetStrokeDashArray(DrawingWand *,const size_t,const double *),
DrawSetStrokePatternURL(DrawingWand *,const char *),
DrawSetVectorGraphics(DrawingWand *,const char *),
IsDrawingWand(const DrawingWand *),
PopDrawingWand(DrawingWand *),
PushDrawingWand(DrawingWand *);
extern WandExport StretchType
DrawGetFontStretch(const DrawingWand *);
extern WandExport StyleType
DrawGetFontStyle(const DrawingWand *);
extern WandExport size_t
DrawGetFontWeight(const DrawingWand *) magick_attribute((__pure__)),
DrawGetStrokeMiterLimit(const DrawingWand *) magick_attribute((__pure__));
extern WandExport void
ClearDrawingWand(DrawingWand *),
DrawAffine(DrawingWand *,const AffineMatrix *),
DrawAnnotation(DrawingWand *,const double,const double,const unsigned char *),
DrawArc(DrawingWand *,const double,const double,const double,const double,
const double,const double),
DrawBezier(DrawingWand *,const size_t,const PointInfo *),
DrawGetBorderColor(const DrawingWand *,PixelWand *),
DrawCircle(DrawingWand *,const double,const double,const double,const double),
DrawColor(DrawingWand *,const double,const double,const PaintMethod),
DrawComment(DrawingWand *,const char *),
DrawEllipse(DrawingWand *,const double,const double,const double,const double,
const double,const double),
DrawGetFillColor(const DrawingWand *,PixelWand *),
DrawGetStrokeColor(const DrawingWand *,PixelWand *),
DrawSetTextKerning(DrawingWand *,const double),
DrawSetTextInterlineSpacing(DrawingWand *,const double),
DrawSetTextInterwordSpacing(DrawingWand *,const double),
DrawGetTextUnderColor(const DrawingWand *,PixelWand *),
DrawLine(DrawingWand *,const double, const double,const double,const double),
DrawMatte(DrawingWand *,const double,const double,const PaintMethod),
DrawPathClose(DrawingWand *),
DrawPathCurveToAbsolute(DrawingWand *,const double,const double,const double,
const double,const double,const double),
DrawPathCurveToRelative(DrawingWand *,const double,const double,const double,
const double,const double, const double),
DrawPathCurveToQuadraticBezierAbsolute(DrawingWand *,const double,
const double,const double,const double),
DrawPathCurveToQuadraticBezierRelative(DrawingWand *,const double,
const double,const double,const double),
DrawPathCurveToQuadraticBezierSmoothAbsolute(DrawingWand *,const double,
const double),
DrawPathCurveToQuadraticBezierSmoothRelative(DrawingWand *,const double,
const double),
DrawPathCurveToSmoothAbsolute(DrawingWand *,const double,const double,
const double,const double),
DrawPathCurveToSmoothRelative(DrawingWand *,const double,const double,
const double,const double),
DrawPathEllipticArcAbsolute(DrawingWand *,const double,const double,
const double,const MagickBooleanType,const MagickBooleanType,const double,
const double),
DrawPathEllipticArcRelative(DrawingWand *,const double,const double,
const double,const MagickBooleanType,const MagickBooleanType,const double,
const double),
DrawPathFinish(DrawingWand *),
DrawPathLineToAbsolute(DrawingWand *,const double,const double),
DrawPathLineToRelative(DrawingWand *,const double,const double),
DrawPathLineToHorizontalAbsolute(DrawingWand *,const double),
DrawPathLineToHorizontalRelative(DrawingWand *,const double),
DrawPathLineToVerticalAbsolute(DrawingWand *,const double),
DrawPathLineToVerticalRelative(DrawingWand *,const double),
DrawPathMoveToAbsolute(DrawingWand *,const double,const double),
DrawPathMoveToRelative(DrawingWand *,const double,const double),
DrawPathStart(DrawingWand *),
DrawPoint(DrawingWand *,const double,const double),
DrawPolygon(DrawingWand *,const size_t,const PointInfo *),
DrawPolyline(DrawingWand *,const size_t,const PointInfo *),
DrawPopClipPath(DrawingWand *),
DrawPopDefs(DrawingWand *),
DrawPushClipPath(DrawingWand *,const char *),
DrawPushDefs(DrawingWand *),
DrawRectangle(DrawingWand *,const double,const double,const double,
const double),
DrawResetVectorGraphics(DrawingWand *),
DrawRotate(DrawingWand *,const double),
DrawRoundRectangle(DrawingWand *,double,double,double,double,double,double),
DrawScale(DrawingWand *,const double,const double),
DrawSetBorderColor(DrawingWand *,const PixelWand *),
DrawSetClipRule(DrawingWand *,const FillRule),
DrawSetClipUnits(DrawingWand *,const ClipPathUnits),
DrawSetFillColor(DrawingWand *,const PixelWand *),
DrawSetFillOpacity(DrawingWand *,const double),
DrawSetFillRule(DrawingWand *,const FillRule),
DrawSetFontSize(DrawingWand *,const double),
DrawSetFontStretch(DrawingWand *,const StretchType),
DrawSetFontStyle(DrawingWand *,const StyleType),
DrawSetFontWeight(DrawingWand *,const size_t),
DrawSetGravity(DrawingWand *,const GravityType),
DrawSetOpacity(DrawingWand *,const double),
DrawSetStrokeAntialias(DrawingWand *,const MagickBooleanType),
DrawSetStrokeColor(DrawingWand *,const PixelWand *),
DrawSetStrokeDashOffset(DrawingWand *,const double dashoffset),
DrawSetStrokeLineCap(DrawingWand *,const LineCap),
DrawSetStrokeLineJoin(DrawingWand *,const LineJoin),
DrawSetStrokeMiterLimit(DrawingWand *,const size_t),
DrawSetStrokeOpacity(DrawingWand *, const double),
DrawSetStrokeWidth(DrawingWand *,const double),
DrawSetTextAlignment(DrawingWand *,const AlignType),
DrawSetTextAntialias(DrawingWand *,const MagickBooleanType),
DrawSetTextDecoration(DrawingWand *,const DecorationType),
DrawSetTextDirection(DrawingWand *,const DirectionType),
DrawSetTextEncoding(DrawingWand *,const char *),
DrawSetTextUnderColor(DrawingWand *,const PixelWand *),
DrawSetViewbox(DrawingWand *,ssize_t,ssize_t,ssize_t,ssize_t),
DrawSkewX(DrawingWand *,const double),
DrawSkewY(DrawingWand *,const double),
DrawTranslate(DrawingWand *,const double,const double);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/montage.h 0000644 00000001707 15051111170 0007275 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand montage command-line method.
*/
#ifndef MAGICKWAND_MONTAGE_H
#define MAGICKWAND_MONTAGE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
MontageImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/conjure.h 0000644 00000001707 15051111170 0007310 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand conjure command-line method.
*/
#ifndef MAGICKWAND_CONJURE_H
#define MAGICKWAND_CONJURE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
ConjureImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/display.h 0000644 00000001707 15051111170 0007310 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand display command-line method.
*/
#ifndef MAGICKWAND_DISPLAY_H
#define MAGICKWAND_DISPLAY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
DisplayImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/magick-property.h 0000644 00000012601 15051111170 0010753 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand property, options, and profile methods.
*/
#ifndef MAGICKWAND_MAGICK_PROPERTY_H
#define MAGICKWAND_MAGICK_PROPERTY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport char
*MagickGetFilename(const MagickWand *),
*MagickGetFormat(MagickWand *),
*MagickGetFont(MagickWand *),
*MagickGetHomeURL(void),
*MagickGetImageArtifact(MagickWand *,const char *),
**MagickGetImageArtifacts(MagickWand *,const char *,size_t *),
**MagickGetImageProfiles(MagickWand *,const char *,size_t *),
*MagickGetImageProperty(MagickWand *,const char *),
**MagickGetImageProperties(MagickWand *,const char *,size_t *),
*MagickGetOption(MagickWand *,const char *),
**MagickGetOptions(MagickWand *,const char *,size_t *),
*MagickQueryConfigureOption(const char *),
**MagickQueryConfigureOptions(const char *,size_t *),
**MagickQueryFonts(const char *,size_t *),
**MagickQueryFormats(const char *,size_t *);
extern WandExport ColorspaceType
MagickGetColorspace(MagickWand *);
extern WandExport CompressionType
MagickGetCompression(MagickWand *);
extern WandExport const char
*MagickGetCopyright(void),
*MagickGetPackageName(void),
*MagickGetQuantumDepth(size_t *),
*MagickGetQuantumRange(size_t *),
*MagickGetReleaseDate(void),
*MagickGetVersion(size_t *);
extern WandExport double
MagickGetPointsize(MagickWand *),
*MagickGetSamplingFactors(MagickWand *,size_t *),
*MagickQueryFontMetrics(MagickWand *,const DrawingWand *,const char *),
*MagickQueryMultilineFontMetrics(MagickWand *,const DrawingWand *,
const char *);
extern WandExport GravityType
MagickGetGravity(MagickWand *);
extern WandExport ImageType
MagickGetType(MagickWand *);
extern WandExport InterlaceType
MagickGetInterlaceScheme(MagickWand *);
extern WandExport InterpolatePixelMethod
MagickGetInterpolateMethod(MagickWand *);
extern WandExport OrientationType
MagickGetOrientation(MagickWand *);
extern WandExport MagickBooleanType
MagickDeleteImageArtifact(MagickWand *,const char *),
MagickDeleteImageProperty(MagickWand *,const char *),
MagickDeleteOption(MagickWand *,const char *),
MagickGetAntialias(const MagickWand *),
MagickGetPage(const MagickWand *,size_t *,size_t *,ssize_t *,ssize_t *),
MagickGetResolution(const MagickWand *,double *,double *),
MagickGetSize(const MagickWand *,size_t *,size_t *),
MagickGetSizeOffset(const MagickWand *,ssize_t *),
MagickProfileImage(MagickWand *,const char *,const void *,const size_t),
MagickSetAntialias(MagickWand *,const MagickBooleanType),
MagickSetBackgroundColor(MagickWand *,const PixelWand *),
MagickSetColorspace(MagickWand *,const ColorspaceType),
MagickSetCompression(MagickWand *,const CompressionType),
MagickSetCompressionQuality(MagickWand *,const size_t),
MagickSetDepth(MagickWand *,const size_t),
MagickSetExtract(MagickWand *,const char *),
MagickSetFilename(MagickWand *,const char *),
MagickSetFormat(MagickWand *,const char *),
MagickSetFont(MagickWand *,const char *),
MagickSetGravity(MagickWand *,const GravityType),
MagickSetImageArtifact(MagickWand *,const char *,const char *),
MagickSetImageProfile(MagickWand *,const char *,const void *,const size_t),
MagickSetImageProperty(MagickWand *,const char *,const char *),
MagickSetInterlaceScheme(MagickWand *,const InterlaceType),
MagickSetInterpolateMethod(MagickWand *,const InterpolatePixelMethod),
MagickSetOption(MagickWand *,const char *,const char *),
MagickSetOrientation(MagickWand *,const OrientationType),
MagickSetPage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t),
MagickSetPassphrase(MagickWand *,const char *),
MagickSetPointsize(MagickWand *,const double),
MagickSetResolution(MagickWand *,const double,const double),
MagickSetResourceLimit(const ResourceType type,const MagickSizeType limit),
MagickSetSamplingFactors(MagickWand *,const size_t,const double *),
MagickSetSecurityPolicy(MagickWand *,const char *),
MagickSetSize(MagickWand *,const size_t,const size_t),
MagickSetSizeOffset(MagickWand *,const size_t,const size_t,const ssize_t),
MagickSetType(MagickWand *,const ImageType);
extern WandExport MagickProgressMonitor
MagickSetProgressMonitor(MagickWand *,const MagickProgressMonitor,void *);
extern WandExport MagickSizeType
MagickGetResource(const ResourceType),
MagickGetResourceLimit(const ResourceType);
extern WandExport PixelWand
*MagickGetBackgroundColor(MagickWand *);
extern WandExport OrientationType
MagickGetOrientationType(MagickWand *);
extern WandExport size_t
MagickGetCompressionQuality(MagickWand *);
extern WandExport unsigned char
*MagickGetImageProfile(MagickWand *,const char *,size_t *),
*MagickRemoveImageProfile(MagickWand *,const char *,size_t *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif