Static build of Imagemagick 7.0.5-5

bin/7.0.5-5/include/ImageMagick-7/Magick++/Blob.h

@@ -0,0 +1,80 @@
+// 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) const;
+
+    // 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_,
+      const Allocator allocator_=NewAllocator);
+
+  private:
+    BlobRef *_blobRef;
+  };
+
+} // namespace Magick
+
+#endif // Magick_BlobRef_header

bin/7.0.5-5/include/ImageMagick-7/Magick++/CoderInfo.h

@@ -0,0 +1,88 @@
+// This may look like C code, but it is really -*- C++ -*-
+//
+// Copyright Bob Friesenhahn, 2001, 2002
+// Copyright Dirk Lemstra 2013-2015
+//
+// 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 can read multi-threaded
+    bool canReadMultithreaded(void) const;
+
+    // Format can write multi-threaded
+    bool canWriteMultithreaded(void) const;
+
+    // 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;
+
+    // Name of the module
+    std::string module(void) const;
+
+    // Format name
+    std::string name(void) const;
+
+    // Unregisters this coder
+    bool unregister(void) const;
+
+  private:
+    bool        _decoderThreadSupport;
+    std::string _description;
+    bool        _encoderThreadSupport;
+    bool        _isMultiFrame;
+    bool        _isReadable;
+    bool        _isWritable;
+    std::string _mimeType;
+    std::string _module;
+    std::string _name;
+  };
+
+} // namespace Magick
+
+#endif // Magick_CoderInfo_header

bin/7.0.5-5/include/ImageMagick-7/Magick++/Color.h

@@ -0,0 +1,440 @@
+// This may look like C code, but it is really -*- C++ -*-
+//
+// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003, 2008
+// Copyright Dirk Lemstra 2013-2014
+//
+// 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 RGBA components scaled to fit Quantum
+  // All double arguments have a valid range of 0.0 - 1.0.
+  class MagickPPExport Color
+  {
+  public:
+
+    // PixelType specifies the interpretation of PixelInfo members
+    // CYMKPixel:
+    //   Cyan     = red
+    //   Magenta  = green
+    //   Yellow   = blue
+    //   Black(K) = black
+    // CYMKPixel:
+    //   Cyan     = red
+    //   Magenta  = green
+    //   Yellow   = blue
+    //   Black(K) = black
+    //   Alpha    = alpha
+    // RGBPixel:
+    //   Red      = red;
+    //   Green    = green;
+    //   Blue     = blue;
+    // RGBAPixel:
+    //   Red      = red;
+    //   Green    = green;
+    //   Blue     = blue;
+    //   Alpha    = alpha;
+    enum PixelType
+    {
+      CMYKPixel,
+      CMYKAPixel,
+      RGBPixel,
+      RGBAPixel
+    };
+
+    // Default constructor
+    Color(void);
+
+    // Construct Color using the specified RGB values
+    Color(const Quantum red_,const Quantum green_,const Quantum blue_);
+
+    // Construct Color using the specified RGBA values
+    Color(const Quantum red_,const Quantum green_,const Quantum blue_,
+      const Quantum alpha_);
+
+    // Construct Color using the specified CMYKA values
+    Color(const Quantum cyan_,const Quantum magenta_,const Quantum yellow_,
+      const Quantum black_,const Quantum alpha_);
+
+    // Construct Color using the specified color string
+    Color(const char *color_);
+
+    // Copy constructor
+    Color(const Color &color_);
+
+    // Construct color via ImageMagick PixelInfo
+    Color(const PixelInfo &color_);
+
+    // Constructor Color using the specified color string
+    Color(const std::string &color_);
+
+    // Destructor
+    virtual ~Color(void);
+
+    // Assignment operator
+    Color& operator=(const Color &color_);
+
+    // Set color via X11 color specification string
+    const Color& operator=(const char *color);
+
+    // Set color via ImageMagick PixelInfo
+    const Color& operator=(const PixelInfo &color_);
+
+    // Set color via color specification string
+    const Color& operator=(const std::string &color);
+
+    // Return ImageMagick PixelInfo
+    operator PixelInfo() const;
+
+    // Return color specification string
+    operator std::string() const;
+
+    // Returns true if the distance between the other color is less than the
+    // specified distance in a linear three(or four) % dimensional color space.
+    bool isFuzzyEquivalent(const Color &color_,const double fuzz_) const;
+
+    // Does object contain valid color?
+    void isValid(const bool valid_);
+    bool isValid(void) const;
+
+    // Returns pixel type of the color
+    Magick::Color::PixelType pixelType(void) const;
+
+    // Alpha level (range OpaqueAlpha=0 to TransparentAlpha=QuantumRange)
+    void quantumAlpha(const Quantum alpha_);
+    Quantum quantumAlpha(void) const;
+
+    // Black color (range 0 to QuantumRange)
+    void quantumBlack(const Quantum black_);
+    Quantum quantumBlack(void) const;
+
+    // Blue/Yellow color (range 0 to QuantumRange)
+    void quantumBlue(const Quantum blue_);
+    Quantum quantumBlue(void) const;
+
+    // Green/Magenta color (range 0 to QuantumRange)
+    void quantumGreen(const Quantum green_);
+    Quantum quantumGreen(void) const;
+
+    // Red/Cyan color (range 0 to QuantumRange)
+    void quantumRed(const Quantum red_);
+    Quantum quantumRed(void) const;
+
+  protected:
+
+    // Constructor to construct with PixelInfo*
+    // Used to point Color at a pixel in an image
+    Color(PixelInfo *rep_,PixelType pixelType_);
+
+    // Constructor to construct with PixelType
+    Color(PixelType pixelType_);
+
+    // Set pixel
+    // Used to point Color at a pixel in an image
+    void pixel(PixelInfo *rep_,PixelType pixelType_);
+
+    // Scale a value expressed as a double (0-1) to Quantum range (0-QuantumRange)
+    static Quantum scaleDoubleToQuantum(const double double_);
+
+    // Scale a value expressed as a Quantum (0-QuantumRange) to double range (0-1)
+    static double scaleQuantumToDouble(const Quantum quantum_);
+
+    // PixelInfo represents a color pixel:
+    //  red     = red   (range 0 to QuantumRange)
+    //  green   = green (range 0 to QuantumRange)
+    //  blue    = blue  (range 0 to QuantumRange)
+    //  alpha   = alpha (range OpaqueAlpha=0 to TransparentAlpha=QuantumRange)
+    //  index   = PseudoColor colormap index
+    PixelInfo *_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 PixelInfo representation
+    void initPixel();
+
+    // Sets the pixel type using the specified PixelInfo.
+    void setPixelType(const PixelInfo &color_);
+  };
+
+  class MagickPPExport ColorCMYK: public Color
+  {
+  public:
+
+    // Default constructor
+    ColorCMYK(void);
+
+    // Copy constructor
+    ColorCMYK(const Color &color_);
+
+    // Construct ColorCMYK using the specified CMYK values
+    ColorCMYK(const double cyan_,const double magenta_,const double yellow_,
+      const double black_);
+
+    // Construct ColorCMYK using the specified CMYKA values
+    ColorCMYK(const double cyan_,const double magenta_,const double yellow_,
+      const double black_,const double alpha_);
+
+    // Destructor
+    ~ColorCMYK(void);
+
+    // Assignment operator from base class
+    ColorCMYK& operator=(const Color& color_);
+
+    // Alpha level (range 0 to 1.0)
+    void alpha(const double alpha_);
+    double alpha(void) const;
+
+    // Black/Key color (range 0 to 1.0)
+    void black(const double black_);
+    double black(void) const;
+
+    // Black/Key color (range 0.0 to 1.0)
+    void cyan(const double cyan_);
+    double cyan(void) const;
+
+    // Magenta color (range 0 to 1.0)
+    void magenta(const double magenta_);
+    double magenta(void) const;
+
+    // Yellow color (range 0 to 1.0)
+    void yellow(const double yellow_);
+    double yellow(void) const;
+
+  protected:
+
+    // Constructor to construct with PixelInfo*
+    ColorCMYK(PixelInfo *rep_,PixelType pixelType_);
+  };
+
+  //
+  // 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(const double shade_);
+
+    // Destructor
+    ~ColorGray();
+
+    // Shade
+    void shade(const double shade_);
+    double shade(void) const;
+
+    // Assignment operator from base class
+    ColorGray& operator=(const Color& color_);
+
+  protected:
+
+    // Constructor to construct with PixelInfo*
+    ColorGray(PixelInfo *rep_,PixelType pixelType_);
+  };
+
+  //
+  // HSL Colorspace colors
+  //
+  // All double arguments have a valid range of 0.0 - 1.0.
+  class MagickPPExport ColorHSL: public Color
+  {
+  public:
+
+    // Default constructor
+    ColorHSL(void);
+
+    // Copy constructor
+    ColorHSL(const Color &color_);
+
+    // Construct ColorHSL using the specified HSL values
+    ColorHSL(const double hue_,const double saturation_,
+      const double lightness_);
+
+    // Destructor
+    ~ColorHSL();
+
+    // Assignment operator from base class
+    ColorHSL& operator=(const Color& color_);
+
+    // Hue color
+    void hue(const double hue_);
+    double hue(void) const;
+
+    // Lightness color
+    void lightness(const double lightness_);
+    double lightness(void) const;
+
+    // Saturation color
+    void saturation(const double saturation_);
+    double saturation(void) const;
+
+  protected:
+
+    // Constructor to construct with PixelInfo*
+    ColorHSL(PixelInfo *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(const bool mono_);
+
+    // Copy constructor
+    ColorMono(const Color &color_);
+
+    // Destructor
+    ~ColorMono();
+
+    // Assignment operator from base class
+    ColorMono& operator=(const Color& color_);
+
+    // Mono color
+    void mono(const bool mono_);
+    bool mono(void) const;
+
+  protected:
+
+    // Constructor to construct with PixelInfo*
+    ColorMono(PixelInfo* rep_,PixelType pixelType_);
+  };
+
+  class MagickPPExport ColorRGB: public Color
+  {
+  public:
+
+    // Default constructor
+    ColorRGB(void);
+
+    // Copy constructor
+    ColorRGB(const Color &color_);
+
+    // Construct ColorRGB using the specified RGB values
+    ColorRGB(const double red_,const double green_,const double blue_);
+
+    // Construct ColorRGB using the specified RGBA values
+    ColorRGB(const double red_,const double green_,const double blue_,
+      const double alpha_);
+
+    // Destructor
+    ~ColorRGB(void);
+
+    // Assignment operator from base class
+    ColorRGB& operator=(const Color& color_);
+
+    // Alpha level (range 0 to 1.0)
+    void alpha(const double alpha_);
+    double alpha(void) const;
+
+    // Blue color (range 0.0 to 1.0)
+    void blue(const double blue_);
+    double blue(void) const;
+
+    // Green color (range 0 to 1.0)
+    void green(const double green_);
+    double green(void) const;
+
+    // Red color (range 0 to 1.0)
+    void red(const double red_);
+    double red(void) const;
+
+  protected:
+
+    // Constructor to construct with PixelInfo*
+    ColorRGB(PixelInfo *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(const double y_,const double u_,const double v_);
+
+    // Destructor
+    ~ColorYUV(void);
+
+    // Assignment operator from base class
+    ColorYUV& operator=(const Color& color_);
+
+    // Color U (0.0 through 1.0)
+    void u(const double u_);
+    double u(void) const;
+
+    // Color V (-0.5 through 0.5)
+    void v(const double v_);
+    double v(void) const;
+
+    // Color Y (-0.5 through 0.5)
+    void y(const double y_);
+    double y(void) const;
+
+  protected:
+
+    // Constructor to construct with PixelInfo*
+    ColorYUV(PixelInfo *rep_,PixelType pixelType_);
+
+  private:
+
+    void convert(const double y_,const double u_,const double v_);
+
+  };
+} // namespace Magick
+
+#endif // Magick_Color_header

bin/7.0.5-5/include/ImageMagick-7/Magick++/Exception.h

@@ -0,0 +1,425 @@
+// 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

bin/7.0.5-5/include/ImageMagick-7/Magick++/Functions.h

@@ -0,0 +1,37 @@
+// 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(void);
+
+  // 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

bin/7.0.5-5/include/ImageMagick-7/Magick++/Geometry.h

@@ -0,0 +1,261 @@
+// 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);
+
+    // 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;
+
+    // X offset from origin
+    void xOff(::ssize_t xOff_);
+    ::ssize_t xOff(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 _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;
+  };
+
+  class MagickPPExport Point;
+
+  // Compare two Point objects
+  MagickPPExport int operator ==
+    (const Magick::Point& left_,const Magick::Point& right_);
+  MagickPPExport int operator !=
+    (const Magick::Point& left_,const Magick::Point& right_);
+
+  class MagickPPExport Point
+  {
+  public:
+
+    // Default constructor
+    Point();
+
+    // Construct Point from specified string
+    Point(const char *point_);
+
+    // Copy constructor
+    Point(const Point &point_);
+
+    // Construct Point from specified string
+    Point(const std::string &point_);
+
+    // Construct Point from specified x and y
+    Point(double x_,double y_);
+
+    // Construct Point from specified x y
+    Point(double xy_);
+
+    // Destructor
+    ~Point(void);
+
+    // Set via point string
+    const Point& operator=(const char *point_);
+
+    // Set via double value
+    const Point& operator=(double xy_);
+
+    // Assignment operator
+    Point& operator=(const Point& point_);
+
+    // Set via point string
+    const Point& operator=(const std::string &point_);
+
+    // Return point string
+    operator std::string() const;
+
+    // Does object contain valid point?
+    bool isValid() const;
+
+    // X offset from origin
+    double x(void) const;
+
+    // Y offset from origin
+    double y(void) const;
+
+  private:
+    double _x;
+    double _y;
+  };
+} // namespace Magick
+
+#endif // Magick_Geometry_header

bin/7.0.5-5/include/ImageMagick-7/Magick++/Montage.h

@@ -0,0 +1,155 @@
+// 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;
+
+    // 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 colmns
+    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;
+    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 foreground color
+    void matteColor(const Color &matteColor_);
+    Color matteColor(void) const;
+
+    // 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;
+
+    //
+    // Implementation methods/members
+    //
+
+    // Update elements in existing MontageInfo structure
+    void updateMontageInfo(MagickCore::MontageInfo &montageInfo_) const;
+
+  private:
+
+    Color _matteColor;
+    Color _borderColor;
+    size_t _borderWidth;
+    Geometry _frame;
+  };
+} // namespace Magick
+
+#endif // Magick_Montage_header

bin/7.0.5-5/include/ImageMagick-7/Magick++/Pixels.h

@@ -0,0 +1,152 @@
+// 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.
+    Quantum *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 Quantum *getConst(const ::ssize_t x_,const ::ssize_t y_,
+      const size_t columns_,const size_t rows_);
+
+    // Return pixel metacontent
+    void *metacontent(void);
+
+    // Returns the offset for the specified channel.
+    ssize_t offset(PixelChannel channel) const;
+
+    // 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.
+    Quantum *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);
+
+    // Left ordinate of view
+    ::ssize_t x(void) const;
+
+    // Top ordinate of view
+    ::ssize_t y(void) const;
+
+    // Width of view
+    size_t columns(void) const;
+
+    // Height of view
+    size_t rows(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

bin/7.0.5-5/include/ImageMagick-7/Magick++/ResourceLimits.h

@@ -0,0 +1,72 @@
+// This may look like C code, but it is really -*- C++ -*-
+//
+// Copyright Dirk Lemstra 2014
+//
+// 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);
+
+    // 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

bin/7.0.5-5/include/ImageMagick-7/Magick++/Statistic.h

@@ -0,0 +1,307 @@
+// 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);
+
+    // X position of centroid
+    double centroidX(void) const;
+
+    // Y position of centroid
+    double centroidY(void) const;
+
+    // The channel
+    PixelChannel 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;
+
+    // Does object contain valid channel moments?
+    bool isValid() const;
+
+    //
+    // Implemementation methods
+    //
+
+    ChannelMoments(const PixelChannel channel_,
+      const MagickCore::ChannelMoments *channelMoments_);
+
+  private:
+    PixelChannel _channel;
+    std::vector<double> _huInvariants;
+    double _centroidX;
+    double _centroidY;
+    double _ellipseAxisX;
+    double _ellipseAxisY;
+    double _ellipseAngle;
+    double _ellipseEccentricity;
+    double _ellipseIntensity;
+  };
+
+  class MagickPPExport ChannelPerceptualHash
+  {
+  public:
+
+    // Default constructor
+    ChannelPerceptualHash(void);
+
+    // Copy constructor
+    ChannelPerceptualHash(const ChannelPerceptualHash &channelPerceptualHash_);
+
+    // Constructor using the specified hash string
+    ChannelPerceptualHash(const PixelChannel channel_,
+      const std::string &hash_);
+
+    // Destroy channel perceptual hash
+    ~ChannelPerceptualHash(void);
+
+    // Return hash string
+    operator std::string() const;
+
+    // The channel
+    PixelChannel channel(void) const;
+
+    // Does object contain valid channel perceptual hash?
+    bool isValid() const;
+
+    // Returns the sum squared difference between this hash and the other hash
+    double sumSquaredDifferences(
+      const ChannelPerceptualHash &channelPerceptualHash_);
+
+    // SRGB hu preceptual hash (valid range for index is 0-6)
+    double srgbHuPhash(const size_t index_) const;
+
+    // HCLp hu preceptual hash (valid range for index is 0-6)
+    double hclpHuPhash(const size_t index_) const;
+
+    //
+    // Implemementation methods
+    //
+
+    ChannelPerceptualHash(const PixelChannel channel_,
+      const MagickCore::ChannelPerceptualHash *channelPerceptualHash_);
+
+  private:
+    PixelChannel _channel;
+    std::vector<double> _srgbHuPhash;
+    std::vector<double> _hclpHuPhash;
+  };
+
+  // Obtain image statistics. Statistics are normalized to the range
+  // of 0.0 to 1.0 and are output to the specified ImageStatistics
+  // structure.
+  class MagickPPExport ChannelStatistics
+  {
+  public:
+
+    // Default constructor
+    ChannelStatistics(void);
+
+    // Copy constructor
+    ChannelStatistics(const ChannelStatistics &channelStatistics_);
+
+    // Destroy channel statistics
+    ~ChannelStatistics(void);
+
+    // Area
+    double area() const;
+
+    // The channel
+    PixelChannel channel(void) const;
+
+    // Depth
+    size_t depth() const;
+
+    // Entropy
+    double entropy() const;
+
+    // Does object contain valid channel statistics?
+    bool isValid() const;
+
+    // Kurtosis
+    double kurtosis() const;
+
+    // Minimum value observed
+    double maxima() const;
+
+    // Average (mean) value observed
+    double mean() const;
+
+    // Maximum value observed
+    double minima() const;
+
+    // Skewness
+    double skewness() const;
+
+    // Standard deviation, sqrt(variance)
+    double standardDeviation() const;
+
+    // Sum
+    double sum() const;
+
+    // Sum cubed
+    double sumCubed() const;
+
+    // Sum fourth power
+    double sumFourthPower() const;
+
+    // Sum squared
+    double sumSquared() const;
+
+    // Variance
+    double variance() const;
+
+    //
+    // Implemementation methods
+    //
+
+    ChannelStatistics(const PixelChannel channel_,
+      const MagickCore::ChannelStatistics *channelStatistics_);
+
+  private:
+    PixelChannel _channel;
+    double _area;
+    size_t _depth;
+    double _entropy;
+    double _kurtosis;
+    double _maxima;
+    double _mean;
+    double _minima;
+    double _skewness;
+    double _standardDeviation;
+    double _sum;
+    double _sumCubed;
+    double _sumFourthPower;
+    double _sumSquared;
+    double _variance;
+  };
+
+  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 PixelChannel channel_) const;
+
+    //
+    // Implemementation methods
+    //
+    ImageMoments(const Image &image_);
+
+  private:
+    std::vector<ChannelMoments> _channels;
+  };
+
+  class MagickPPExport ImagePerceptualHash
+  {
+  public:
+
+    // Default constructor
+    ImagePerceptualHash(void);
+
+    // Copy constructor
+    ImagePerceptualHash(const ImagePerceptualHash &imagePerceptualHash_);
+
+    // Constructor using the specified hash string
+    ImagePerceptualHash(const std::string &hash_);
+
+    // Destroy image perceptual hash
+    ~ImagePerceptualHash(void);
+
+    // Return hash string
+    operator std::string() const;
+
+    // Returns the perceptual hash for the specified channel
+    ChannelPerceptualHash channel(const PixelChannel channel_) const;
+
+    // Does object contain valid perceptual hash?
+    bool isValid() const;
+
+    // Returns the sum squared difference between this hash and the other hash
+    double sumSquaredDifferences(
+      const ImagePerceptualHash &channelPerceptualHash_);
+
+    //
+    // Implemementation methods
+    //
+    ImagePerceptualHash(const Image &image_);
+
+  private:
+    std::vector<ChannelPerceptualHash> _channels;
+  };
+
+  class MagickPPExport ImageStatistics
+  {
+  public:
+
+    // Default constructor
+    ImageStatistics(void);
+
+    // Copy constructor
+    ImageStatistics(const ImageStatistics &imageStatistics_);
+
+    // Destroy image statistics
+    ~ImageStatistics(void);
+
+    // Returns the statistics for the specified channel
+    ChannelStatistics channel(const PixelChannel channel_) const;
+
+    //
+    // Implemementation methods
+    //
+    ImageStatistics(const Image &image_);
+
+  private:
+    std::vector<ChannelStatistics> _channels;
+  };
+}
+
+#endif // Magick_ChannelMoments_header

bin/7.0.5-5/include/ImageMagick-7/Magick++/TypeMetric.h

@@ -0,0 +1,59 @@
+// 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