Static build of Imagemagick 7.0.5-5

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

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

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

bin/7.0.5-5/include/ImageMagick-7/MagickCore/MagickCore.h

@@ -0,0 +1,171 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/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
+#if __cplusplus > 199711L
+#define register
+#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 <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 "MagickCore/method-attribute.h"
+
+#if defined(MAGICKCORE_NAMESPACE_PREFIX)
+# include "MagickCore/methods.h"
+#endif
+#include "MagickCore/magick-type.h"
+#include "MagickCore/animate.h"
+#include "MagickCore/annotate.h"
+#include "MagickCore/artifact.h"
+#include "MagickCore/attribute.h"
+#include "MagickCore/blob.h"
+#include "MagickCore/cache.h"
+#include "MagickCore/cache-view.h"
+#include "MagickCore/channel.h"
+#include "MagickCore/cipher.h"
+#include "MagickCore/client.h"
+#include "MagickCore/coder.h"
+#include "MagickCore/color.h"
+#include "MagickCore/colorspace.h"
+#include "MagickCore/colormap.h"
+#include "MagickCore/compare.h"
+#include "MagickCore/composite.h"
+#include "MagickCore/compress.h"
+#include "MagickCore/configure.h"
+#include "MagickCore/constitute.h"
+#include "MagickCore/decorate.h"
+#include "MagickCore/delegate.h"
+#include "MagickCore/deprecate.h"
+#include "MagickCore/display.h"
+#include "MagickCore/distort.h"
+#include "MagickCore/distribute-cache.h"
+#include "MagickCore/draw.h"
+#include "MagickCore/effect.h"
+#include "MagickCore/enhance.h"
+#include "MagickCore/exception.h"
+#include "MagickCore/feature.h"
+#include "MagickCore/fourier.h"
+#include "MagickCore/fx.h"
+#include "MagickCore/gem.h"
+#include "MagickCore/geometry.h"
+#include "MagickCore/histogram.h"
+#include "MagickCore/identify.h"
+#include "MagickCore/image.h"
+#include "MagickCore/image-view.h"
+#include "MagickCore/layer.h"
+#include "MagickCore/linked-list.h"
+#include "MagickCore/list.h"
+#include "MagickCore/locale_.h"
+#include "MagickCore/log.h"
+#include "MagickCore/magic.h"
+#include "MagickCore/magick.h"
+#include "MagickCore/matrix.h"
+#include "MagickCore/memory_.h"
+#include "MagickCore/module.h"
+#include "MagickCore/mime.h"
+#include "MagickCore/monitor.h"
+#include "MagickCore/montage.h"
+#include "MagickCore/morphology.h"
+#include "MagickCore/opencl.h"
+#include "MagickCore/option.h"
+#include "MagickCore/paint.h"
+#include "MagickCore/pixel.h"
+#include "MagickCore/pixel-accessor.h"
+#include "MagickCore/policy.h"
+#include "MagickCore/prepress.h"
+#include "MagickCore/profile.h"
+#include "MagickCore/property.h"
+#include "MagickCore/quantize.h"
+#include "MagickCore/quantum.h"
+#include "MagickCore/registry.h"
+#include "MagickCore/random_.h"
+#include "MagickCore/resample.h"
+#include "MagickCore/resize.h"
+#include "MagickCore/resource_.h"
+#include "MagickCore/segment.h"
+#include "MagickCore/shear.h"
+#include "MagickCore/signature.h"
+#include "MagickCore/splay-tree.h"
+#include "MagickCore/stream.h"
+#include "MagickCore/statistic.h"
+#include "MagickCore/string_.h"
+#include "MagickCore/timer.h"
+#include "MagickCore/token.h"
+#include "MagickCore/transform.h"
+#include "MagickCore/threshold.h"
+#include "MagickCore/type.h"
+#include "MagickCore/utility.h"
+#include "MagickCore/version.h"
+#include "MagickCore/vision.h"
+#include "MagickCore/xml-tree.h"
+#include "MagickCore/xwindow.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/animate.h

@@ -0,0 +1,32 @@
+/*
+  Copyright 1999-2017 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://www.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 *,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/annotate.h

@@ -0,0 +1,41 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/draw.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport MagickBooleanType
+  AnnotateImage(Image *,const DrawInfo *,ExceptionInfo *),
+  GetMultilineTypeMetrics(Image *,const DrawInfo *,TypeMetric *,
+    ExceptionInfo *),
+  GetTypeMetrics(Image *,const DrawInfo *,TypeMetric *,ExceptionInfo *);
+
+extern MagickExport ssize_t
+  FormatMagickCaption(Image *,DrawInfo *,const MagickBooleanType,TypeMetric *,
+    char **,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/artifact.h

@@ -0,0 +1,46 @@
+/*
+  Copyright 1999-2017 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://www.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
+  *RemoveImageArtifact(Image *,const char *);
+
+extern MagickExport const char
+  *GetNextImageArtifact(const Image *),
+  *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

bin/7.0.5-5/include/ImageMagick-7/MagickCore/attribute.h

@@ -0,0 +1,52 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/image.h"
+#include "MagickCore/exception.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport ImageType
+  GetImageType(const Image *),
+  IdentifyImageGray(const Image *,ExceptionInfo *),
+  IdentifyImageType(const Image *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  IdentifyImageMonochrome(const Image *,ExceptionInfo *),
+  IsImageGray(const Image *),
+  IsImageMonochrome(const Image *),
+  IsImageOpaque(const Image *,ExceptionInfo *),
+  SetImageDepth(Image *,const size_t,ExceptionInfo *),
+  SetImageType(Image *,const ImageType,ExceptionInfo *);
+
+extern MagickExport RectangleInfo
+  GetImageBoundingBox(const Image *,ExceptionInfo *exception);
+
+extern MagickExport size_t
+  GetImageDepth(const Image *,ExceptionInfo *),
+  GetImageQuantumDepth(const Image *,const MagickBooleanType);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/blob.h

@@ -0,0 +1,98 @@
+/*
+  Copyright 1999-2017 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://www.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
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#define MagickMaxBufferExtent  81920
+
+typedef enum
+{
+  ReadMode,
+  WriteMode,
+  IOMode
+} MapMode;
+
+typedef ssize_t
+  (*CustomStreamHandler)(const unsigned char *,const size_t,const void *);
+
+typedef size_t
+  (*CustomStreamSeeker)(const MagickOffsetType,const int,const void *);
+
+typedef MagickOffsetType
+  (*CustomStreamTeller)(const void *);
+
+typedef struct _CustomStreamInfo
+  CustomStreamInfo;
+
+#include "MagickCore/image.h"
+#include "MagickCore/stream.h"
+
+extern MagickExport CustomStreamInfo
+  *AcquireCustomStreamInfo(ExceptionInfo *),
+  *DestroyCustomStreamInfo(CustomStreamInfo *);
+
+extern MagickExport FILE
+  *GetBlobFileHandle(const Image *);
+
+extern MagickExport Image
+  *BlobToImage(const ImageInfo *,const void *,const size_t,ExceptionInfo *),
+  *PingBlob(const ImageInfo *,const void *,const size_t,ExceptionInfo *),
+  *CustomStreamToImage(const ImageInfo *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  BlobToFile(char *,const void *,const size_t,ExceptionInfo *),
+  FileToImage(Image *,const char *,ExceptionInfo *),
+  GetBlobError(const Image *),
+  ImageToFile(Image *,char *,ExceptionInfo *),
+  InjectImageBlob(const ImageInfo *,Image *,Image *,const char *,
+    ExceptionInfo *),
+  IsBlobExempt(const Image *),
+  IsBlobSeekable(const Image *),
+  IsBlobTemporary(const Image *);
+
+extern MagickExport MagickSizeType
+  GetBlobSize(const Image *);
+
+extern MagickExport StreamHandler
+  GetBlobStreamHandler(const Image *);
+
+extern MagickExport void
+  *GetBlobStreamData(const Image *),
+  DestroyBlob(Image *),
+  DuplicateBlob(Image *,const Image *),
+  *FileToBlob(const char *,const size_t,size_t *,ExceptionInfo *),
+  *ImageToBlob(const ImageInfo *,Image *,size_t *,ExceptionInfo *),
+  ImageToCustomStream(const ImageInfo *,Image *,ExceptionInfo *),
+  *ImagesToBlob(const ImageInfo *,Image *,size_t *,ExceptionInfo *),
+  ImagesToCustomStream(const ImageInfo *,Image *,ExceptionInfo *),
+  SetBlobExempt(Image *,const MagickBooleanType),
+  SetCustomStreamData(CustomStreamInfo *,void *),
+  SetCustomStreamReader(CustomStreamInfo *,CustomStreamHandler),
+  SetCustomStreamSeeker(CustomStreamInfo *,CustomStreamSeeker),
+  SetCustomStreamTeller(CustomStreamInfo *,CustomStreamTeller),
+  SetCustomStreamWriter(CustomStreamInfo *,CustomStreamHandler);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/cache-view.h

@@ -0,0 +1,106 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/pixel.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  UndefinedVirtualPixelMethod,
+  BackgroundVirtualPixelMethod,
+  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 *),
+  *AcquireVirtualCacheView(const Image *,ExceptionInfo *),
+  *CloneCacheView(const CacheView *),
+  *DestroyCacheView(CacheView *);
+
+extern MagickExport ClassType
+  GetCacheViewStorageClass(const CacheView *);
+
+extern MagickExport ColorspaceType
+  GetCacheViewColorspace(const CacheView *);
+
+extern MagickExport const Image
+  *GetCacheViewImage(const CacheView *);
+
+extern MagickExport const Quantum
+  *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 const void
+  *GetCacheViewVirtualMetacontent(const CacheView *);
+
+extern MagickExport MagickBooleanType
+  GetOneCacheViewAuthenticPixel(const CacheView *,const ssize_t,const ssize_t,
+    Quantum *,ExceptionInfo *),
+  GetOneCacheViewVirtualMethodPixel(const CacheView *,const VirtualPixelMethod,
+    const ssize_t,const ssize_t,Quantum *,ExceptionInfo *),
+  GetOneCacheViewVirtualPixel(const CacheView *,const ssize_t,const ssize_t,
+    Quantum *,ExceptionInfo *),
+  GetOneCacheViewVirtualPixelInfo(const CacheView *,const ssize_t,const ssize_t,
+    PixelInfo *,ExceptionInfo *),
+  SetCacheViewStorageClass(CacheView *,const ClassType,ExceptionInfo *),
+  SetCacheViewVirtualPixelMethod(CacheView *magick_restrict,
+    const VirtualPixelMethod),
+  SyncCacheViewAuthenticPixels(CacheView *magick_restrict,ExceptionInfo *)
+    magick_hot_spot;
+
+extern MagickExport MagickSizeType
+  GetCacheViewExtent(const CacheView *);
+
+extern MagickExport Quantum
+  *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;
+
+extern MagickExport void
+  *GetCacheViewAuthenticMetacontent(CacheView *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/cache.h

@@ -0,0 +1,76 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/blob.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  UndefinedCache,
+  DiskCache,
+  DistributedCache,
+  MapCache,
+  MemoryCache,
+  PingCache
+} CacheType;
+
+extern MagickExport CacheType
+  GetImagePixelCacheType(const Image *);
+
+extern MagickExport const Quantum
+  *GetVirtualPixels(const Image *,const ssize_t,const ssize_t,const size_t,
+    const size_t,ExceptionInfo *) magick_hot_spot,
+  *GetVirtualPixelQueue(const Image *) magick_hot_spot;
+
+extern MagickExport const void
+  *GetVirtualMetacontent(const Image *);
+
+extern MagickExport MagickBooleanType
+  GetOneAuthenticPixel(Image *,const ssize_t,const ssize_t,Quantum *,
+    ExceptionInfo *),
+  GetOneVirtualPixel(const Image *,const ssize_t,const ssize_t,Quantum *,
+    ExceptionInfo *),
+  GetOneVirtualPixelInfo(const Image *,const VirtualPixelMethod,
+    const ssize_t,const ssize_t,PixelInfo *,ExceptionInfo *),
+  PersistPixelCache(Image *,const char *,const MagickBooleanType,
+    MagickOffsetType *,ExceptionInfo *),
+  SyncAuthenticPixels(Image *,ExceptionInfo *) magick_hot_spot;
+
+extern MagickExport MagickSizeType
+  GetImageExtent(const Image *);
+
+extern MagickExport Quantum
+  *GetAuthenticPixels(Image *,const ssize_t,const ssize_t,const size_t,
+    const size_t,ExceptionInfo *) magick_hot_spot,
+  *GetAuthenticPixelQueue(const Image *) magick_hot_spot,
+  *QueueAuthenticPixels(Image *,const ssize_t,const ssize_t,const size_t,
+    const size_t,ExceptionInfo *) magick_hot_spot;
+
+extern MagickExport void
+  *GetAuthenticMetacontent(const Image *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/channel.h

@@ -0,0 +1,41 @@
+/*
+  Copyright 1999-2017 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://www.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 <MagickCore/image.h>
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport Image
+  *ChannelFxImage(const Image *,const char *,ExceptionInfo *),
+  *CombineImages(const Image *,const ColorspaceType,ExceptionInfo *),
+  *SeparateImage(const Image *,const ChannelType,ExceptionInfo *),
+  *SeparateImages(const Image *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  GetImageAlphaChannel(const Image *),
+  SetImageAlphaChannel(Image *,const AlphaChannelOption,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/cipher.h

@@ -0,0 +1,35 @@
+/*
+  Copyright 1999-2017 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://www.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

bin/7.0.5-5/include/ImageMagick-7/MagickCore/client.h

@@ -0,0 +1,35 @@
+/*
+  Copyright 1999-2017 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://www.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),
+  *GetClientName(void),
+  *SetClientName(const char *),
+  *SetClientPath(const char *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/coder.h

@@ -0,0 +1,54 @@
+/*
+  Copyright 1999-2017 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://www.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;
+                                                                                
+  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
+  ListCoderInfo(FILE *,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/color.h

@@ -0,0 +1,92 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/pixel.h"
+#include "MagickCore/exception.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  UndefinedCompliance,
+  NoCompliance = 0x0000,
+  CSSCompliance = 0x0001,
+  SVGCompliance = 0x0001,
+  X11Compliance = 0x0002,
+  XPMCompliance = 0x0004,
+  AllCompliance = 0x7fffffff
+} ComplianceType;
+
+typedef struct _ColorInfo
+{
+  char
+    *path,
+    *name;
+
+  ComplianceType
+    compliance;
+
+  PixelInfo
+    color;
+
+  MagickBooleanType
+    exempt,
+    stealth;
+
+  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
+  IsEquivalentImage(const Image *,const Image *,ssize_t *x,ssize_t *y,
+    ExceptionInfo *),
+  ListColorInfo(FILE *,ExceptionInfo *),
+  QueryColorCompliance(const char *,const ComplianceType,PixelInfo *,
+    ExceptionInfo *),
+  QueryColorname(const Image *,const PixelInfo *,const ComplianceType,
+    char *,ExceptionInfo *);
+
+extern MagickExport void
+  ConcatenateColorComponent(const PixelInfo *,const PixelChannel,
+    const ComplianceType,char *),
+  GetColorTuple(const PixelInfo *,const MagickBooleanType,char *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/colormap.h

@@ -0,0 +1,34 @@
+/*
+  Copyright 1999-2017 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://www.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,ExceptionInfo *),
+  CycleColormapImage(Image *,const ssize_t,ExceptionInfo *),
+  SortColormapByIntensity(Image *,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/colorspace.h

@@ -0,0 +1,72 @@
+/*
+  Copyright 1999-2017 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://www.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,
+  CMYColorspace,           /* negated linear RGB colorspace */
+  CMYKColorspace,          /* CMY with Black separation */
+  GRAYColorspace,          /* Single Channel greyscale (linear) image */
+  HCLColorspace,
+  HCLpColorspace,
+  HSBColorspace,
+  HSIColorspace,
+  HSLColorspace,
+  HSVColorspace,           /* alias for HSB */
+  HWBColorspace,
+  LabColorspace,
+  LCHColorspace,           /* alias for LCHuv */
+  LCHabColorspace,         /* Cylindrical (Polar) Lab */
+  LCHuvColorspace,         /* Cylindrical (Polar) Luv */
+  LogColorspace,
+  LMSColorspace,
+  LuvColorspace,
+  OHTAColorspace,
+  Rec601YCbCrColorspace,
+  Rec709YCbCrColorspace,
+  RGBColorspace,           /* Linear RGB colorspace */
+  scRGBColorspace,         /* ??? */
+  sRGBColorspace,          /* Default: non-linear sRGB colorspace */
+  TransparentColorspace,
+  xyYColorspace,
+  XYZColorspace,           /* IEEE Color Reference colorspace */
+  YCbCrColorspace,
+  YCCColorspace,
+  YDbDrColorspace,
+  YIQColorspace,
+  YPbPrColorspace,
+  YUVColorspace
+} ColorspaceType;
+
+extern MagickExport MagickBooleanType
+  SetImageColorspace(Image *,const ColorspaceType,ExceptionInfo *),
+  SetImageGray(Image *,ExceptionInfo *),
+  SetImageMonochrome(Image *,ExceptionInfo *),
+  TransformImageColorspace(Image *,const ColorspaceType,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/compare.h

@@ -0,0 +1,61 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/image.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  UndefinedErrorMetric,
+  AbsoluteErrorMetric,
+  FuzzErrorMetric,
+  MeanAbsoluteErrorMetric,
+  MeanErrorPerPixelErrorMetric,
+  MeanSquaredErrorMetric,
+  NormalizedCrossCorrelationErrorMetric,
+  PeakAbsoluteErrorMetric,
+  PeakSignalToNoiseRatioErrorMetric,
+  PerceptualHashErrorMetric,
+  RootMeanSquaredErrorMetric
+} MetricType;
+
+extern MagickExport double
+  *GetImageDistortions(Image *,const Image *,const MetricType,ExceptionInfo *);
+
+extern MagickExport Image
+  *CompareImages(Image *,const Image *,const MetricType,double *,
+    ExceptionInfo *),
+  *SimilarityImage(const Image *,const Image *,const MetricType,const double,
+    RectangleInfo *,double *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  GetImageDistortion(Image *,const Image *,const MetricType,double *,
+    ExceptionInfo *),
+  IsImagesEqual(const Image *,const Image *,ExceptionInfo *),
+  SetImageColorMetric(Image *,const Image *,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/composite.h

@@ -0,0 +1,109 @@
+/*
+  Copyright 1999-2017 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://www.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,
+  AlphaCompositeOp,
+  AtopCompositeOp,
+  BlendCompositeOp,
+  BlurCompositeOp,
+  BumpmapCompositeOp,
+  ChangeMaskCompositeOp,
+  ClearCompositeOp,
+  ColorBurnCompositeOp,
+  ColorDodgeCompositeOp,
+  ColorizeCompositeOp,
+  CopyBlackCompositeOp,
+  CopyBlueCompositeOp,
+  CopyCompositeOp,
+  CopyCyanCompositeOp,
+  CopyGreenCompositeOp,
+  CopyMagentaCompositeOp,
+  CopyAlphaCompositeOp,
+  CopyRedCompositeOp,
+  CopyYellowCompositeOp,
+  DarkenCompositeOp,
+  DarkenIntensityCompositeOp,
+  DifferenceCompositeOp,
+  DisplaceCompositeOp,
+  DissolveCompositeOp,
+  DistortCompositeOp,
+  DivideDstCompositeOp,
+  DivideSrcCompositeOp,
+  DstAtopCompositeOp,
+  DstCompositeOp,
+  DstInCompositeOp,
+  DstOutCompositeOp,
+  DstOverCompositeOp,
+  ExclusionCompositeOp,
+  HardLightCompositeOp,
+  HardMixCompositeOp,
+  HueCompositeOp,
+  InCompositeOp,
+  IntensityCompositeOp,
+  LightenCompositeOp,
+  LightenIntensityCompositeOp,
+  LinearBurnCompositeOp,
+  LinearDodgeCompositeOp,
+  LinearLightCompositeOp,
+  LuminizeCompositeOp,
+  MathematicsCompositeOp,
+  MinusDstCompositeOp,
+  MinusSrcCompositeOp,
+  ModulateCompositeOp,
+  ModulusAddCompositeOp,
+  ModulusSubtractCompositeOp,
+  MultiplyCompositeOp,
+  NoCompositeOp,
+  OutCompositeOp,
+  OverCompositeOp,
+  OverlayCompositeOp,
+  PegtopLightCompositeOp,
+  PinLightCompositeOp,
+  PlusCompositeOp,
+  ReplaceCompositeOp,
+  SaturateCompositeOp,
+  ScreenCompositeOp,
+  SoftLightCompositeOp,
+  SrcAtopCompositeOp,
+  SrcCompositeOp,
+  SrcInCompositeOp,
+  SrcOutCompositeOp,
+  SrcOverCompositeOp,
+  ThresholdCompositeOp,
+  VividLightCompositeOp,
+  XorCompositeOp
+} CompositeOperator;
+
+extern MagickExport MagickBooleanType
+  CompositeImage(Image *,const Image *,const CompositeOperator,
+    const MagickBooleanType,const ssize_t,const ssize_t,ExceptionInfo *),
+  TextureImage(Image *,const Image *,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/compress.h

@@ -0,0 +1,73 @@
+/*
+  Copyright 1999-2017 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://www.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,
+  B44ACompression,
+  B44Compression,
+  BZipCompression,
+  DXT1Compression,
+  DXT3Compression,
+  DXT5Compression,
+  FaxCompression,
+  Group4Compression,
+  JBIG1Compression,        /* ISO/IEC std 11544 / ITU-T rec T.82 */
+  JBIG2Compression,        /* ISO/IEC std 14492 / ITU-T rec T.88 */
+  JPEG2000Compression,     /* ISO/IEC std 15444-1 */
+  JPEGCompression,
+  LosslessJPEGCompression,
+  LZMACompression,         /* Lempel-Ziv-Markov chain algorithm */
+  LZWCompression,
+  NoCompression,
+  PizCompression,
+  Pxr24Compression,
+  RLECompression,
+  ZipCompression,
+  ZipSCompression
+} CompressionType;
+
+typedef struct _Ascii85Info
+  Ascii85Info;
+
+extern MagickExport MagickBooleanType
+  HuffmanDecodeImage(Image *,ExceptionInfo *),
+  HuffmanEncodeImage(const ImageInfo *,Image *,Image *,ExceptionInfo *),
+  LZWEncodeImage(Image *,const size_t,unsigned char *magick_restrict,
+    ExceptionInfo *),
+  PackbitsEncodeImage(Image *,const size_t,unsigned char *magick_restrict,
+    ExceptionInfo *),
+  ZLIBEncodeImage(Image *,const size_t,unsigned char *magick_restrict,
+    ExceptionInfo *);
+
+extern MagickExport void
+  Ascii85Encode(Image *,const unsigned char),
+  Ascii85Flush(Image *),
+  Ascii85Initialize(Image *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/configure.h

@@ -0,0 +1,66 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/linked-list.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef struct _ConfigureInfo
+{
+  char
+    *path,
+    *name,
+    *value;
+                                                                                
+  MagickBooleanType
+    exempt,
+    stealth;
+                                                                                
+  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
+  ListConfigureInfo(FILE *,ExceptionInfo *);
+
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/constitute.h

@@ -0,0 +1,44 @@
+/*
+  Copyright 1999-2017 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://www.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
+
+#include "MagickCore/pixel.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport Image
+  *ConstituteImage(const size_t,const size_t,const char *,const StorageType,
+    const void *,ExceptionInfo *),
+  *PingImage(const ImageInfo *,ExceptionInfo *),
+  *PingImages(ImageInfo *,const char *,ExceptionInfo *),
+  *ReadImage(const ImageInfo *,ExceptionInfo *),
+  *ReadImages(ImageInfo *,const char *,ExceptionInfo *),
+  *ReadInlineImage(const ImageInfo *,const char *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  WriteImage(const ImageInfo *,Image *,ExceptionInfo *),
+  WriteImages(const ImageInfo *,Image *,const char *,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/decorate.h

@@ -0,0 +1,54 @@
+/*
+  Copyright 1999-2017 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://www.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
+
+#include "MagickCore/image.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 *,const CompositeOperator,
+    ExceptionInfo *),
+  *FrameImage(const Image *,const FrameInfo *,const CompositeOperator,
+    ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  RaiseImage(Image *,const RectangleInfo *,const MagickBooleanType,
+    ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/delegate.h

@@ -0,0 +1,79 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/semaphore.h"
+
+typedef struct _DelegateInfo
+{
+  char
+    *path,
+    *decode,
+    *encode,
+    *commands;
+
+  ssize_t
+    mode;
+
+  MagickBooleanType
+    thread_support,
+    spawn,
+    stealth;
+
+  SemaphoreInfo
+    *semaphore;
+
+  size_t
+    signature;
+} 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
+  GetDelegateThreadSupport(const DelegateInfo *),
+  InvokeDelegate(ImageInfo *,Image *,const char *,const char *,ExceptionInfo *),
+  ListDelegateInfo(FILE *,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/deprecate.h

@@ -0,0 +1,41 @@
+/*
+  Copyright 1999-2017 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://www.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
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#if !defined(MAGICKCORE_EXCLUDE_DEPRECATED)
+
+#include "MagickCore/magick.h"
+
+typedef int
+  *(*BlobFifo)(const Image *,const void *,const size_t);
+
+extern MagickExport MagickBooleanType
+  GetMagickSeekableStream(const MagickInfo *);
+
+#endif
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/display.h

@@ -0,0 +1,34 @@
+/*
+  Copyright 1999-2017 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://www.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 *,ExceptionInfo *),
+  RemoteDisplayCommand(const ImageInfo *,const char *,const char *,
+    ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/distort.h

@@ -0,0 +1,86 @@
+/*
+  Copyright 1999-2017 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://www.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
+} DistortMethod;
+
+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 DistortMethod,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 SparseColorMethod,const size_t,
+    const double *,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/distribute-cache.h

@@ -0,0 +1,34 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/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

bin/7.0.5-5/include/ImageMagick-7/MagickCore/draw.h

@@ -0,0 +1,391 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/geometry.h"
+#include "MagickCore/image.h"
+#include "MagickCore/pixel.h"
+#include "MagickCore/type.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
+} 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,
+  AlphaPrimitive,
+  ArcPrimitive,
+  BezierPrimitive,
+  CirclePrimitive,
+  ColorPrimitive,
+  EllipsePrimitive,
+  ImagePrimitive,
+  LinePrimitive,
+  PathPrimitive,
+  PointPrimitive,
+  PolygonPrimitive,
+  PolylinePrimitive,
+  RectanglePrimitive,
+  RoundRectanglePrimitive,
+  TextPrimitive
+} PrimitiveType;
+
+typedef enum
+{
+  UndefinedReference,
+  GradientReference
+} ReferenceType;
+
+typedef enum
+{
+  UndefinedSpread,
+  PadSpread,
+  ReflectSpread,
+  RepeatSpread
+} SpreadMethod;
+
+typedef struct _StopInfo
+{
+  PixelInfo
+    color;
+
+  double
+    offset;
+} StopInfo;
+
+typedef struct _GradientInfo
+{
+  GradientType
+    type;
+
+  RectangleInfo
+    bounding_box;
+
+  SegmentInfo
+    gradient_vector;
+
+  StopInfo
+    *stops;
+
+  size_t
+    number_stops;
+
+  SpreadMethod
+    spread;
+
+  MagickBooleanType
+    debug;
+
+  PointInfo
+    center,
+    radii;
+
+  double
+    radius,
+    angle;
+
+  size_t
+    signature;
+} GradientInfo;
+
+typedef struct _ElementReference
+{
+  char
+    *id;
+
+  ReferenceType
+    type;
+
+  GradientInfo
+    gradient;
+
+  struct _ElementReference
+    *previous,
+    *next;
+
+  size_t
+    signature;
+} ElementReference;
+
+typedef struct _DrawInfo
+{
+  char
+    *primitive,
+    *geometry;
+
+  RectangleInfo
+    viewbox;
+
+  AffineMatrix
+    affine;
+
+  PixelInfo
+    fill,
+    stroke,
+    undercolor,
+    border_color;
+
+  Image
+    *fill_pattern,
+    *stroke_pattern;
+
+  double
+    stroke_width;
+
+  GradientInfo
+    gradient;
+
+  MagickBooleanType
+    stroke_antialias,
+    text_antialias;
+
+  FillRule
+    fill_rule;
+
+  LineCap
+    linecap;
+
+  LineJoin
+    linejoin;
+
+  size_t
+    miterlimit;
+
+  double
+    dash_offset;
+
+  DecorationType
+    decorate;
+
+  CompositeOperator
+    compose;
+
+  char
+    *text,
+    *font,
+    *metrics,
+    *family;
+
+  size_t
+    face;
+
+  StyleType
+    style;
+
+  StretchType
+    stretch;
+
+  size_t
+    weight;
+
+  char
+    *encoding;
+
+  double
+    pointsize;
+
+  char
+    *density;
+
+  AlignType
+    align;
+
+  GravityType
+    gravity;
+
+  char
+    *server_name;
+
+  double
+    *dash_pattern;
+
+  char
+    *clip_mask;
+
+  SegmentInfo
+    bounds;
+
+  ClipPathUnits
+    clip_units;
+
+  Quantum
+    alpha;
+
+  MagickBooleanType
+    render;
+
+  ElementReference
+    element_reference;
+
+  double
+    kerning,
+    interword_spacing,
+    interline_spacing;
+
+  DirectionType
+    direction;
+
+  MagickBooleanType
+    debug;
+
+  size_t
+    signature;
+
+  double
+    fill_alpha,
+    stroke_alpha;
+} DrawInfo;
+
+
+typedef struct _PrimitiveInfo
+{
+  PointInfo
+    point;
+
+  size_t
+    coordinates;
+
+  PrimitiveType
+    primitive;
+
+  PaintMethod
+    method;
+
+  char
+    *text;
+} 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 *,ExceptionInfo *),
+  DrawClipPath(Image *,const DrawInfo *,const char *,ExceptionInfo *),
+  DrawGradientImage(Image *,const DrawInfo *,ExceptionInfo *),
+  DrawImage(Image *,const DrawInfo *,ExceptionInfo *),
+  DrawPatternPath(Image *,const DrawInfo *,const char *,Image **,
+    ExceptionInfo *),
+  DrawPrimitive(Image *,const DrawInfo *,const PrimitiveInfo *,ExceptionInfo *);
+
+extern MagickExport void
+  GetAffineMatrix(AffineMatrix *),
+  GetDrawInfo(const ImageInfo *,DrawInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/effect.h

@@ -0,0 +1,91 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/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 *),
+  *AdaptiveSharpenImage(const Image *,const double,const double,
+     ExceptionInfo *),
+  *BlurImage(const Image *,const double,const double,ExceptionInfo *),
+  *ConvolveImage(const Image *,const KernelInfo *,ExceptionInfo *),
+  *DespeckleImage(const Image *,ExceptionInfo *),
+  *EdgeImage(const Image *,const double,ExceptionInfo *),
+  *EmbossImage(const Image *,const double,const double,ExceptionInfo *),
+  *GaussianBlurImage(const Image *,const double,const double,ExceptionInfo *),
+  *KuwaharaImage(const Image *,const double,const double,ExceptionInfo *),
+  *LocalContrastImage(const Image *,const double,const double,ExceptionInfo *),
+  *MotionBlurImage(const Image *,const double,const double,const double,
+    ExceptionInfo *),
+  *PreviewImage(const Image *,const PreviewType,ExceptionInfo *),
+  *RotationalBlurImage(const Image *,const double,ExceptionInfo *),
+  *SelectiveBlurImage(const Image *,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 *),
+  *SpreadImage(const Image *,const PixelInterpolateMethod,const double,
+    ExceptionInfo *),
+  *UnsharpMaskImage(const Image *,const double,const double,const double,
+    const double,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/enhance.h

@@ -0,0 +1,57 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/pixel.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport MagickBooleanType
+  AutoGammaImage(Image *,ExceptionInfo *),
+  AutoLevelImage(Image *,ExceptionInfo *),
+  BrightnessContrastImage(Image *,const double,const double,ExceptionInfo *),
+  ClutImage(Image *,const Image *,const PixelInterpolateMethod,ExceptionInfo *),
+  ColorDecisionListImage(Image *,const char *,ExceptionInfo *),
+  ContrastImage(Image *,const MagickBooleanType,ExceptionInfo *),
+  ContrastStretchImage(Image *,const double,const double,ExceptionInfo *),
+  EqualizeImage(Image *image,ExceptionInfo *),
+  GammaImage(Image *,const double,ExceptionInfo *),
+  GrayscaleImage(Image *,const PixelIntensityMethod,ExceptionInfo *),
+  HaldClutImage(Image *,const Image *,ExceptionInfo *),
+  LevelImage(Image *,const double,const double,const double,ExceptionInfo *),
+  LevelizeImage(Image *,const double,const double,const double,ExceptionInfo *),
+  LevelImageColors(Image *,const PixelInfo *,const PixelInfo *,
+    const MagickBooleanType,ExceptionInfo *),
+  LinearStretchImage(Image *,const double,const double,ExceptionInfo *),
+  ModulateImage(Image *,const char *,ExceptionInfo *),
+  NegateImage(Image *,const MagickBooleanType,ExceptionInfo *),
+  NormalizeImage(Image *,ExceptionInfo *),
+  SigmoidalContrastImage(Image *,const MagickBooleanType,const double,
+    const double,ExceptionInfo *);
+
+extern MagickExport Image
+  *EnhanceImage(const Image *,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/exception.h

@@ -0,0 +1,176 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/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 *);
+
+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 *),
+  ThrowMagickExceptionList(ExceptionInfo *,const char *,const char *,
+    const size_t,const ExceptionType,const char *,const char *,va_list),
+  ThrowMagickException(ExceptionInfo *,const char *,const char *,const size_t,
+    const ExceptionType,const char *,const char *,...)
+    magick_attribute((__format__ (__printf__,7,8)));
+
+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 *),
+  MagickWarning(const ExceptionType,const char *,const char *);
+
+extern MagickExport WarningHandler
+  SetWarningHandler(WarningHandler);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/feature.h

@@ -0,0 +1,62 @@
+/*
+  Copyright 1999-2017 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://www.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
+  *GetImageFeatures(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

bin/7.0.5-5/include/ImageMagick-7/MagickCore/fourier.h

@@ -0,0 +1,48 @@
+/*
+  Copyright 1999-2017 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://www.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

bin/7.0.5-5/include/ImageMagick-7/MagickCore/fx.h

@@ -0,0 +1,77 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/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,const double,ExceptionInfo *),
+  *BlueShiftImage(const Image *,const double,ExceptionInfo *),
+  *CharcoalImage(const Image *,const double,const double,ExceptionInfo *),
+  *ColorizeImage(const Image *,const char *,const PixelInfo *,ExceptionInfo *),
+  *ColorMatrixImage(const Image *,const KernelInfo *kernel,ExceptionInfo *),
+  *FxImage(const Image *,const char *,ExceptionInfo *),
+  *ImplodeImage(const Image *,const double,const PixelInterpolateMethod,
+    ExceptionInfo *),
+  *MorphImages(const Image *,const size_t,ExceptionInfo *),
+  *PolaroidImage(const Image *,const DrawInfo *,const char *,const double,
+    const PixelInterpolateMethod,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,const PixelInterpolateMethod,
+    ExceptionInfo *),
+  *TintImage(const Image *,const char *,const PixelInfo *,ExceptionInfo *),
+  *VignetteImage(const Image *,const double,const double,const ssize_t,
+    const ssize_t,ExceptionInfo *),
+  *WaveImage(const Image *,const double,const double,
+    const PixelInterpolateMethod,ExceptionInfo *),
+  *WaveletDenoiseImage(const Image *,const double,const double,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  PlasmaImage(Image *,const SegmentInfo *,size_t,size_t,ExceptionInfo *),
+  SolarizeImage(Image *,const double,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/gem.h

@@ -0,0 +1,41 @@
+/*
+  Copyright 1999-2017 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://www.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 gems methods.
+*/
+#ifndef MAGICKCORE_GEM_H
+#define MAGICKCORE_GEM_H
+
+#include "MagickCore/fx.h"
+#include "MagickCore/random_.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport double
+  ExpandAffine(const AffineMatrix *);
+
+extern MagickExport void
+  ConvertHSLToRGB(const double,const double,const double,double *,double *,
+    double *),
+  ConvertRGBToHSL(const double,const double,const double,double *,double *,
+    double *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/geometry.h

@@ -0,0 +1,166 @@
+/*
+  Copyright 1999-2017 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://www.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  */
+#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
+#endif
+
+typedef enum
+{
+  UndefinedGravity,
+  ForgetGravity = 0,
+  NorthWestGravity = 1,
+  NorthGravity = 2,
+  NorthEastGravity = 3,
+  WestGravity = 4,
+  CenterGravity = 5,
+  EastGravity = 6,
+  SouthWestGravity = 7,
+  SouthGravity = 8,
+  SouthEastGravity = 9
+} 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 _PointInfo
+{
+  double
+    x,
+    y;
+} PointInfo;
+
+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

bin/7.0.5-5/include/ImageMagick-7/MagickCore/histogram.h

@@ -0,0 +1,45 @@
+/*
+  Copyright 1999-2017 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://www.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
+
+extern MagickExport PixelInfo
+  *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 *),
+  MinMaxStretchImage(Image *,const double,const double,const double,
+    ExceptionInfo *);
+
+extern MagickExport size_t
+  GetNumberColors(const Image *,FILE *,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/identify.h

@@ -0,0 +1,32 @@
+/*
+  Copyright 1999-2017 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://www.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,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/image-view.h

@@ -0,0 +1,83 @@
+/*
+  Copyright 1999-2017 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://www.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 CONDITTransferNS 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 Quantum
+  *GetImageViewVirtualPixels(const ImageView *);
+
+extern MagickExport const void
+  *GetImageViewVirtualMetacontent(const ImageView *);
+
+extern MagickExport Image
+  *GetImageViewImage(const ImageView *);
+
+extern MagickExport ImageView
+  *CloneImageView(const ImageView *),
+  *DestroyImageView(ImageView *),
+  *NewImageView(Image *,ExceptionInfo *),
+  *NewImageViewRegion(Image *,const ssize_t,const ssize_t,const size_t,
+    const size_t,ExceptionInfo *);
+
+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 Quantum
+  *GetImageViewAuthenticPixels(const ImageView *);
+
+extern MagickExport RectangleInfo
+  GetImageViewExtent(const ImageView *);
+
+extern MagickExport void
+  SetImageViewDescription(ImageView *,const char *),
+  SetImageViewThreads(ImageView *,const size_t);
+
+extern MagickExport void
+  *GetImageViewAuthenticMetacontent(const ImageView *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/image.h

@@ -0,0 +1,577 @@
+/*
+  Copyright 1999-2017 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://www.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
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#define OpaqueAlpha  ((Quantum) QuantumRange)
+#define TransparentAlpha  ((Quantum) 0)
+
+typedef enum
+{
+  UndefinedAlphaChannel,
+  ActivateAlphaChannel,
+  AssociateAlphaChannel,
+  BackgroundAlphaChannel,
+  CopyAlphaChannel,
+  DeactivateAlphaChannel,
+  DiscreteAlphaChannel,
+  DisassociateAlphaChannel,
+  ExtractAlphaChannel,
+  OffAlphaChannel,
+  OnAlphaChannel,
+  OpaqueAlphaChannel,
+  RemoveAlphaChannel,
+  SetAlphaChannel,
+  ShapeAlphaChannel,
+  TransparentAlphaChannel
+} AlphaChannelOption;
+
+typedef enum
+{
+  UndefinedType,
+  BilevelType,
+  GrayscaleType,
+  GrayscaleAlphaType,
+  PaletteType,
+  PaletteAlphaType,
+  TrueColorType,
+  TrueColorAlphaType,
+  ColorSeparationType,
+  ColorSeparationAlphaType,
+  OptimizeType,
+  PaletteBilevelAlphaType
+} 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 "MagickCore/blob.h"
+#include "MagickCore/colorspace.h"
+#include "MagickCore/cache-view.h"
+#include "MagickCore/color.h"
+#include "MagickCore/composite.h"
+#include "MagickCore/compress.h"
+#include "MagickCore/effect.h"
+#include "MagickCore/geometry.h"
+#include "MagickCore/layer.h"
+#include "MagickCore/locale_.h"
+#include "MagickCore/monitor.h"
+#include "MagickCore/pixel.h"
+#include "MagickCore/profile.h"
+#include "MagickCore/quantum.h"
+#include "MagickCore/resample.h"
+#include "MagickCore/resize.h"
+#include "MagickCore/semaphore.h"
+#include "MagickCore/stream.h"
+#include "MagickCore/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 */
+
+  size_t
+    columns,            /* physical size of image */
+    rows,
+    depth,              /* depth of image on read/write */
+    colors;             /* Size of color table, or actual color count */
+                        /* Only valid if image is not DirectClass */
+
+  PixelInfo
+    *colormap,
+    alpha_color,        /* deprecated */
+    background_color,   /* current background color attribute */
+    border_color,       /* current bordercolor attribute */
+    transparent_color;  /* color for 'transparent' color index in GIF */
+
+  double
+    gamma;
+
+  ChromaticityInfo
+    chromaticity;
+
+  RenderingIntent
+    rendering_intent;
+
+  void
+    *profiles;
+
+  ResolutionType
+    units;          /* resolution/density  ppi or ppc */
+
+  char
+    *montage,
+    *directory,
+    *geometry;
+
+  ssize_t
+    offset;         /* ??? */
+
+  PointInfo
+    resolution;     /* image resolution/density */
+
+  RectangleInfo
+    page,           /* virtual canvas size and offset of image */
+    extract_info;
+
+  double
+    fuzz;           /* current color fuzz attribute - move to image_info */
+
+  FilterType
+    filter;         /* resize/distort filter to apply */
+
+  PixelIntensityMethod
+    intensity;      /* method to generate an intensity value from a pixel */
+
+  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 */
+
+  size_t
+    scene,          /* index of image in multi-image file */
+    delay,          /* Animation delay time */
+    duration;       /* Total animation duration sum(delay*iterations) */
+
+  ssize_t
+    ticks_per_second;  /* units for delay time, default 100 for GIF */
+
+  size_t
+    iterations,        /* number of interations for GIF animations */
+    total_colors;
+
+  ssize_t
+    start_loop;        /* ??? */
+
+  PixelInterpolateMethod
+    interpolate;       /* Interpolation of color for between pixel lookups */
+
+  MagickBooleanType
+    black_point_compensation;
+
+  RectangleInfo
+    tile_offset;
+
+  ImageType
+    type;
+
+  MagickBooleanType
+    dither;            /* dithering on/off */
+
+  MagickSizeType
+    extent;            /* Size of image read from disk */
+
+  MagickBooleanType
+    ping;              /* no image data read, just attributes */
+
+  MagickBooleanType
+    read_mask,
+    write_mask;
+
+  PixelTrait
+    alpha_trait;       /* is transparency channel defined and active */
+
+  size_t
+    number_channels,
+    number_meta_channels,
+    metacontent_extent;
+
+  ChannelType
+    channel_mask;
+
+  PixelChannelMap
+    *channel_map;
+
+  void
+    *cache;
+
+  ErrorInfo
+    error;
+
+  TimerInfo
+    timer;
+
+  MagickProgressMonitor
+    progress_monitor;
+
+  void
+    *client_data;
+
+  Ascii85Info
+    *ascii85;
+
+  ProfileInfo
+    *generic_profile;
+
+  void
+    *properties,       /* general settings, to save with image */
+    *artifacts;        /* general operational/coder settings, not saved */
+
+  char
+    filename[MagickPathExtent],        /* images input filename */
+    magick_filename[MagickPathExtent], /* given image filename (with read mods) */
+    magick[MagickPathExtent];          /* images file format (file magic) */
+
+  size_t
+    magick_columns,     /* size of image when read/created */
+    magick_rows;
+
+  BlobInfo
+    *blob;             /* image file as in-memory string of 'extent' */
+
+  time_t
+    timestamp;
+
+  MagickBooleanType
+    debug;             /* debug output attribute */
+
+  volatile ssize_t
+    reference_count;   /* image data sharing memory management */
+
+  SemaphoreInfo
+    *semaphore;
+
+  struct _ImageInfo
+    *image_info;       /* (Optional) Image belongs to this ImageInfo 'list'
+                        * For access to 'global options' when no per-image
+                        * attribute, properity, or artifact has been set.
+                        */
+
+  struct _Image
+    *list,             /* Undo/Redo image processing list (for display) */
+    *previous,         /* Image list links */
+    *next;
+
+  size_t
+    signature;
+
+  PixelInfo
+    matte_color;        /* current mattecolor attribute */
+};
+
+/*
+  ImageInfo structure:
+    Stores an image list, as well as all global settings used by all images
+    held, -- unless overridden for that specific image.  See SyncImagesettings()
+    which maps any global setting that always overrides specific image settings.
+*/
+struct _ImageInfo
+{
+  CompressionType
+    compression;        /* compression method when reading/saving image */
+
+  OrientationType
+    orientation;        /* orientation setting */
+
+  MagickBooleanType
+    temporary,          /* image file to be deleted after read "empemeral:" */
+    adjoin,             /* save images to separate scene files */
+    affirm,
+    antialias;
+
+  char
+    *size,              /* image generation size */
+    *extract,           /* crop/resize string on image read */
+    *page,
+    *scenes;            /* scene numbers that is to be read in */
+
+  size_t
+    scene,              /* starting value for image save numbering */
+    number_scenes,      /* total number of images in list - for escapes */
+    depth;              /* current read/save depth of images */
+
+  InterlaceType
+    interlace;          /* interlace for image write */
+
+  EndianType
+    endian;             /* integer endian order for raw image data */
+
+  ResolutionType
+    units;              /* denisty pixels/inch or pixel/cm */
+
+  size_t
+    quality;            /* compression quality */
+
+  char
+    *sampling_factor,   /* JPEG write sampling factor */
+    *server_name,       /* X windows server name - display/animate */
+    *font,              /* DUP for draw_info */
+    *texture,           /* montage/display background tile */
+    *density;           /* DUP for image and draw_info */
+
+  double
+    pointsize,
+    fuzz;               /* current color fuzz attribute */
+
+  PixelInfo
+    alpha_color,        /* deprecated */
+    background_color,   /* user set background color */
+    border_color,       /* user set border color */
+    transparent_color;  /* color for transparent index in color tables */
+                        /* NB: fill color is only needed in draw_info! */
+                        /* the same for undercolor (for font drawing) */
+
+  MagickBooleanType
+    dither,             /* dither enable-disable */
+    monochrome;         /* read/write pcl,pdf,ps,xps as monocrome image */
+
+  ColorspaceType
+    colorspace;
+
+  CompositeOperator
+    compose;
+
+  ImageType
+    type;
+
+  MagickBooleanType
+    ping,                    /* fast read image attributes, not image data */
+    verbose;                 /* verbose output enable/disable */
+
+  ChannelType
+    channel;
+
+  void
+    *options;                /* splay tree of global options */
+
+  void
+    *profile;
+
+  MagickBooleanType
+    synchronize;
+
+  MagickProgressMonitor
+    progress_monitor;
+
+  void
+    *client_data,
+    *cache;
+
+  StreamHandler
+    stream;
+
+  FILE
+    *file;
+
+  void
+    *blob;
+
+  size_t
+    length;
+
+  char
+    magick[MagickPathExtent],    /* image file format (file magick) */
+    unique[MagickPathExtent],    /* unique tempory filename - delegates */
+    filename[MagickPathExtent];  /* filename when reading/writing image */
+
+  MagickBooleanType
+    debug;
+
+  size_t
+    signature;
+
+  CustomStreamInfo
+    *custom_stream;
+
+  PixelInfo
+    matte_color;        /* matte (frame) color */
+};
+
+extern MagickExport ChannelType
+  SetImageChannelMask(Image *,const ChannelType);
+
+extern MagickExport const char
+  DefaultTileGeometry[],
+  DefaultTileLabel[],
+  LoadImageTag[],
+  LoadImagesTag[],
+  PSDensityGeometry[],
+  PSPageGeometry[],
+  SaveImageTag[],
+  SaveImagesTag[];
+
+extern MagickExport const double
+  DefaultResolution;
+
+extern MagickExport ExceptionType
+  CatchImageException(Image *);
+
+extern MagickExport FILE
+  *GetImageInfoFile(const ImageInfo *);
+
+extern MagickExport Image
+  *AcquireImage(const ImageInfo *,ExceptionInfo *),
+  *AppendImages(const Image *,const MagickBooleanType,ExceptionInfo *),
+  *CloneImage(const Image *,const size_t,const size_t,const MagickBooleanType,
+    ExceptionInfo *),
+  *DestroyImage(Image *),
+  *GetImageMask(const Image *,const PixelMask,ExceptionInfo *),
+  *NewMagickImage(const ImageInfo *,const size_t,const size_t,const PixelInfo *,
+    ExceptionInfo *),
+  *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 *,ExceptionInfo *),
+  ClipImagePath(Image *,const char *,const MagickBooleanType,ExceptionInfo *),
+  CopyImagePixels(Image *,const Image *,const RectangleInfo *,
+    const OffsetInfo *,ExceptionInfo *),
+  IsTaintImage(const Image *),
+  IsHighDynamicRangeImage(const Image *,ExceptionInfo *),
+  IsImageObject(const Image *),
+  ListMagickInfo(FILE *,ExceptionInfo *),
+  ModifyImage(Image **,ExceptionInfo *),
+  ResetImagePage(Image *,const char *),
+  SetImageAlpha(Image *,const Quantum,ExceptionInfo *),
+  SetImageBackgroundColor(Image *,ExceptionInfo *),
+  SetImageColor(Image *,const PixelInfo *,ExceptionInfo *),
+  SetImageExtent(Image *,const size_t,const size_t,ExceptionInfo *),
+  SetImageInfo(ImageInfo *,const unsigned int,ExceptionInfo *),
+  SetImageMask(Image *,const PixelMask type,const Image *,ExceptionInfo *),
+  SetImageRegionMask(Image *,const PixelMask type,const RectangleInfo *,
+    ExceptionInfo *),
+  SetImageStorageClass(Image *,const ClassType,ExceptionInfo *),
+  StripImage(Image *,ExceptionInfo *),
+  SyncImage(Image *,ExceptionInfo *),
+  SyncImageSettings(const ImageInfo *,Image *,ExceptionInfo *),
+  SyncImagesSettings(ImageInfo *,Image *,ExceptionInfo *);
+
+extern MagickExport size_t
+  InterpretImageFilename(const ImageInfo *,Image *,const char *,int,char *,
+    ExceptionInfo *);
+
+extern MagickExport ssize_t
+  GetImageReferenceCount(Image *);
+
+extern MagickExport VirtualPixelMethod
+  GetImageVirtualPixelMethod(const Image *),
+  SetImageVirtualPixelMethod(Image *,const VirtualPixelMethod,ExceptionInfo *);
+
+extern MagickExport void
+  AcquireNextImage(const ImageInfo *,Image *,ExceptionInfo *),
+  DestroyImagePixels(Image *),
+  DisassociateImageStream(Image *),
+  GetImageInfo(ImageInfo *),
+  SetImageInfoBlob(ImageInfo *,const void *,const size_t),
+  SetImageInfoFile(ImageInfo *,FILE *),
+  SetImageInfoCustomStream(ImageInfo *,CustomStreamInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/layer.h

@@ -0,0 +1,76 @@
+/*
+  Copyright 1999-2017 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://www.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
+
+#include "MagickCore/composite.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
+} LayerMethod;
+
+extern MagickExport Image
+  *CoalesceImages(const Image *,ExceptionInfo *),
+  *DisposeImages(const Image *,ExceptionInfo *),
+  *CompareImagesLayers(const Image *,const LayerMethod,ExceptionInfo *),
+  *MergeImageLayers(Image *,const LayerMethod,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

bin/7.0.5-5/include/ImageMagick-7/MagickCore/linked-list.h

@@ -0,0 +1,57 @@
+/*
+  Copyright 1999-2017 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://www.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 linked list methods.
+*/
+#ifndef MAGICKCORE_LINKED_LIST_H
+#define MAGICKCORE_LINKED_LIST_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef struct _LinkedListInfo
+  LinkedListInfo;
+
+extern MagickExport LinkedListInfo
+  *DestroyLinkedList(LinkedListInfo *,void *(*)(void *)),
+  *NewLinkedList(const size_t);
+
+extern MagickExport MagickBooleanType
+  AppendValueToLinkedList(LinkedListInfo *,const void *),
+  InsertValueInLinkedList(LinkedListInfo *,const size_t,const void *),
+  InsertValueInSortedLinkedList(LinkedListInfo *,
+    int (*)(const void *,const void *),void **,const void *),
+  IsLinkedListEmpty(const LinkedListInfo *),
+  LinkedListToArray(LinkedListInfo *,void **);
+
+extern MagickExport size_t
+  GetNumberOfElementsInLinkedList(const LinkedListInfo *);
+
+extern MagickExport void
+  ClearLinkedList(LinkedListInfo *,void *(*)(void *)),
+  *GetLastValueInLinkedList(LinkedListInfo *),
+  *GetNextValueInLinkedList(LinkedListInfo *),
+  *GetValueFromLinkedList(LinkedListInfo *,const size_t),
+  *RemoveElementByValueFromLinkedList(LinkedListInfo *,const void *),
+  *RemoveElementFromLinkedList(LinkedListInfo *,const size_t),
+  *RemoveLastElementFromLinkedList(LinkedListInfo *),
+  ResetLinkedListIterator(LinkedListInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/list.h

@@ -0,0 +1,65 @@
+/*
+  Copyright 1999-2017 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://www.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 *),
+  *GetImageFromList(const Image *,const ssize_t),
+  *GetLastImageInList(const Image *),
+  *GetNextImageInList(const Image *),
+  *GetPreviousImageInList(const Image *),
+  **ImageListToArray(const Image *,ExceptionInfo *),
+  *NewImageList(void),
+  *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 *);
+
+extern MagickExport ssize_t
+  GetImageIndexInList(const Image *);
+
+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

bin/7.0.5-5/include/ImageMagick-7/MagickCore/locale_.h

@@ -0,0 +1,80 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/linked-list.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef struct _LocaleInfo
+{
+  char
+    *path,
+    *tag,
+    *message;
+                                                                                
+  MagickBooleanType
+    stealth;
+                                                                                
+  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 *),
+  LocaleNCompare(const char *,const char *,const size_t);
+
+extern MagickExport LinkedListInfo
+  *DestroyLocaleOptions(LinkedListInfo *),
+  *GetLocaleOptions(const char *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  ListLocaleInfo(FILE *,ExceptionInfo *);
+
+extern MagickExport ssize_t
+  FormatLocaleFile(FILE *,const char *magick_restrict,...)
+    magick_attribute((__format__ (__printf__,2,3))),
+  FormatLocaleString(char *magick_restrict,const size_t,
+    const char *magick_restrict,...)
+    magick_attribute((__format__ (__printf__,3,4)));
+
+extern MagickExport void
+  LocaleLower(char *),
+  LocaleUpper(char *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/log.h

@@ -0,0 +1,98 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/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 = 0x000000,
+  NoEvents = 0x00000,
+  AccelerateEvent = 0x00001,
+  AnnotateEvent = 0x00002,
+  BlobEvent = 0x00004,
+  CacheEvent = 0x00008,
+  CoderEvent = 0x00010,
+  ConfigureEvent = 0x00020,
+  DeprecateEvent = 0x00040,
+  DrawEvent = 0x00080,
+  ExceptionEvent = 0x00100,   /* Log Errors and Warnings immediately */
+  ImageEvent = 0x00200,
+  LocaleEvent = 0x00400,
+  ModuleEvent = 0x00800,      /* Loding of coder and filter modules */
+  PixelEvent = 0x01000,
+  PolicyEvent = 0x02000,
+  ResourceEvent = 0x04000,
+  TraceEvent = 0x08000,
+  TransformEvent = 0x10000,
+  UserEvent = 0x20000,
+  WandEvent = 0x40000,        /* Log MagickWand */
+  X11Event = 0x80000,
+  CommandEvent = 0x100000,    /* Log Command Processing (CLI & Scripts) */
+  AllEvents = 0x7fffffff
+} LogEventType;
+
+typedef struct _LogInfo
+  LogInfo;
+
+typedef void
+  (*MagickLogMethod)(const LogEventType,const char *);
+
+extern MagickExport char
+  **GetLogList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport const char
+  *GetLogName(void),
+  *SetLogName(const char *);
+
+extern MagickExport const LogInfo
+  **GetLogInfoList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport LogEventType
+  SetLogEventMask(const char *);
+
+extern MagickExport MagickBooleanType
+  IsEventLogging(void),
+  ListLogInfo(FILE *,ExceptionInfo *),
+  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),
+  SetLogFormat(const char *),
+  SetLogMethod(MagickLogMethod);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/magic.h

@@ -0,0 +1,69 @@
+/*
+  Copyright 1999-2017 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://www.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;
+
+  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 *);
+
+extern MagickExport const MagicInfo
+  *GetMagicInfo(const unsigned char *,const size_t,ExceptionInfo *),
+  **GetMagicInfoList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport size_t
+  GetMagicPatternExtent(ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/magick-config.h

@@ -0,0 +1,205 @@
+/*
+  Copyright 2012 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://www.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
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "MagickCore/magick-baseconfig.h"
+
+/* 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
+
+/* 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 yours 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__) || defined(__MINGW64__)
+ 
+/* 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_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_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
+
+#endif
+ 
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+ 
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/magick-type.h

@@ -0,0 +1,186 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/magick-config.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#if !defined(MAGICKCORE_QUANTUM_DEPTH)
+#define MAGICKCORE_QUANTUM_DEPTH  16
+#endif
+
+#if defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(__MINGW32__) && !defined(__MINGW64__)
+#  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 !defined(MAGICKCORE_HAVE_DOUBLE_T)
+typedef double double_t;
+#endif
+#if !defined(MAGICKCORE_HAVE_FLOAT_T)
+typedef float float_t;
+#endif
+
+#if (MAGICKCORE_QUANTUM_DEPTH == 8)
+#define MaxColormapSize  256UL
+#define MaxMap  255UL
+typedef double_t MagickRealType;
+
+#if defined(MAGICKCORE_HDRI_SUPPORT)
+typedef float_t Quantum;
+#define QuantumRange  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 double_t MagickRealType;
+
+#if defined(MAGICKCORE_HDRI_SUPPORT)
+typedef float_t Quantum;
+#define QuantumRange  65535.0f
+#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 double_t MagickRealType;
+
+#if defined(MAGICKCORE_HDRI_SUPPORT)
+typedef double Quantum;
+#define QuantumRange  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 long double MagickRealType;
+typedef long double Quantum;
+#define QuantumRange  18446744073709551615.0
+#define QuantumFormat  "%g"
+#else
+#error "MAGICKCORE_QUANTUM_DEPTH must be one of 8, 16, 32, or 64"
+#endif
+#define MagickEpsilon  (1.0e-15)
+#define MagickMaximumValue  1.79769313486231570E+308
+#define MagickMinimumValue   2.22507385850720140E-308
+#define QuantumScale  ((double) 1.0/(double) QuantumRange)
+
+/*
+  Typedef declarations.
+*/
+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(_MSC_VER) && (_MSC_VER == 1200)
+typedef MagickOffsetType QuantumAny;
+#else
+typedef MagickSizeType QuantumAny;
+#endif
+
+#if defined(macintosh)
+#define ExceptionInfo  MagickExceptionInfo
+#endif
+
+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)
+#  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 (log(0))
+#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

bin/7.0.5-5/include/ImageMagick-7/MagickCore/magick.h

@@ -0,0 +1,147 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/semaphore.h"
+
+typedef enum
+{
+  UndefinedFormatType,
+  ImplicitFormatType,
+  ExplicitFormatType
+} MagickFormatType;
+
+typedef enum
+{
+  CoderNoFlag = 0x0000,
+  CoderAdjoinFlag = 0x0001,
+  CoderBlobSupportFlag = 0x0002,
+  CoderDecoderThreadSupportFlag = 0x0004,
+  CoderEncoderThreadSupportFlag = 0x0008,
+  CoderEndianSupportFlag = 0x0010,
+  CoderRawSupportFlag = 0x0020,
+  CoderSeekableStreamFlag = 0x0040, /* deprecated */
+  CoderStealthFlag = 0x0080,
+  CoderUseExtensionFlag = 0x0100,
+  CoderDecoderSeekableStreamFlag = 0x0200,
+  CoderEncoderSeekableStreamFlag = 0x0400,
+
+} MagickInfoFlag;
+
+typedef Image
+  *DecodeImageHandler(const ImageInfo *,ExceptionInfo *);
+
+typedef MagickBooleanType
+  EncodeImageHandler(const ImageInfo *,Image *,ExceptionInfo *);
+
+typedef MagickBooleanType
+  IsImageFormatHandler(const unsigned char *,const size_t);
+
+typedef struct _MagickInfo
+{
+  char
+    *name,
+    *description,
+    *version,
+    *mime_type,
+    *note,
+    *module;
+
+  DecodeImageHandler
+    *decoder;
+
+  EncodeImageHandler
+    *encoder;
+
+  ImageInfo
+    *image_info;
+
+  IsImageFormatHandler
+    *magick;
+
+  MagickFormatType
+    format_type;
+
+  MagickStatusType
+    flags;
+
+  SemaphoreInfo
+    *semaphore;
+
+  size_t
+    signature;
+
+  void
+    *client_data;
+} 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 *);
+
+extern MagickExport EncodeImageHandler
+  *GetImageEncoder(const MagickInfo *);
+
+extern MagickExport int
+  GetMagickPrecision(void),
+  SetMagickPrecision(const int);
+
+extern MagickExport MagickBooleanType
+  GetImageMagick(const unsigned char *,const size_t,char *),
+  GetMagickAdjoin(const MagickInfo *),
+  GetMagickBlobSupport(const MagickInfo *),
+  GetMagickDecoderSeekableStream(const MagickInfo *),
+  GetMagickDecoderThreadSupport(const MagickInfo *),
+  GetMagickEncoderSeekableStream(const MagickInfo *),
+  GetMagickEncoderThreadSupport(const MagickInfo *),
+  GetMagickEndianSupport(const MagickInfo *),
+  GetMagickRawSupport(const MagickInfo *),
+  GetMagickStealth(const MagickInfo *),
+  GetMagickUseExtension(const MagickInfo *),
+  IsMagickCoreInstantiated(void),
+  RegisterMagickInfo(MagickInfo *),
+  UnregisterMagickInfo(const char *);
+
+extern const MagickExport MagickInfo
+  *GetMagickInfo(const char *,ExceptionInfo *),
+  **GetMagickInfoList(const char *,size_t *,ExceptionInfo *);
+
+extern MagickExport MagickInfo
+  *AcquireMagickInfo(const char *, const char *, const char *);
+
+extern MagickExport void
+  MagickCoreGenesis(const char *,const MagickBooleanType),
+  MagickCoreTerminus(void);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/matrix.h

@@ -0,0 +1,52 @@
+/*
+  Copyright 1999-2017 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://www.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
+  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 *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/memory_.h

@@ -0,0 +1,64 @@
+/*
+  Copyright 1999-2017 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://www.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
+
+#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);
+
+extern MagickExport MemoryInfo
+  *AcquireVirtualMemory(const size_t,const size_t) magick_alloc_sizes(1,2),
+  *RelinquishVirtualMemory(MemoryInfo *);
+
+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),
+  *AcquireQuantumMemory(const size_t,const size_t)
+    magick_attribute((__malloc__)) magick_alloc_sizes(1,2),
+  *CopyMagickMemory(void *,const void *,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),
+  SetMagickMemoryMethods(AcquireMemoryHandler,ResizeMemoryHandler,
+    DestroyMemoryHandler);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/method-attribute.h

@@ -0,0 +1,147 @@
+/*
+  Copyright 1999-2017 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://www.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(__BORLANDC__) && defined(_DLL)
+#  pragma message("BCBMagick lib DLL export interface")
+#  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
+#   if defined(_VISUALC_)
+#    pragma message( "MagickCore lib DLL import interface" )
+#   endif
+#  else
+#   if defined(__clang__) || defined(__GNUC__)
+#    define MagickExport __attribute__ ((dllexport))
+#   else
+#    define MagickExport __declspec(dllexport)
+#   endif
+#   if defined(_VISUALC_)
+#    pragma message( "MagickCore lib DLL export interface" )
+#   endif
+#  endif
+# else
+#  define MagickExport
+#  if defined(_VISUALC_)
+#   pragma message( "MagickCore lib static interface" )
+#  endif
+# endif
+
+# if defined(_DLL) && !defined(_LIB)
+#   if defined(__clang__) || defined(__GNUC__)
+#    define ModuleExport __attribute__ ((dllexport))
+#   else
+#    define ModuleExport __declspec(dllexport)
+#   endif
+#  if defined(_VISUALC_)
+#   pragma message( "MagickCore module DLL export interface" )
+#  endif
+# else
+#  define ModuleExport
+#  if defined(_VISUALC_)
+#   pragma message( "MagickCore module static interface" )
+#  endif
+
+# 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
+#if !defined(MagickPathExtent)
+# define MagickPathExtent  4096  /* always >= 4096 */
+#endif
+# define MaxTextExtent  MagickPathExtent
+
+#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__) && (((__GNUC__) > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)))
+#  define magick_alloc_size(x)  __attribute__((__alloc_size__(x)))
+#  define magick_alloc_sizes(x,y)  __attribute__((__alloc_size__(x,y)))
+#else
+#  define magick_alloc_size(x)  /* nothing */
+#  define magick_alloc_sizes(x,y)  /* nothing */
+#endif
+
+#if defined(__clang__) || (((__GNUC__) > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)))
+#  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

bin/7.0.5-5/include/ImageMagick-7/MagickCore/mime.h

@@ -0,0 +1,48 @@
+/*
+  Copyright 1999-2017 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://www.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 *),
+  LoadMimeLists(const char *,ExceptionInfo *);
+
+extern MagickExport const MimeInfo
+  *GetMimeInfo(const char *,const unsigned char *,const size_t,ExceptionInfo *),
+  **GetMimeInfoList(const char *,size_t *,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/module.h

@@ -0,0 +1,87 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/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;
+
+  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 *);
+
+extern MagickExport ModuleInfo
+  *GetModuleInfo(const char *,ExceptionInfo *);
+
+extern MagickExport void
+  DestroyModuleList(void),
+  RegisterStaticModules(void),
+  UnregisterStaticModules(void);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/monitor.h

@@ -0,0 +1,49 @@
+/*
+  Copyright 1999-2017 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://www.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 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 % (span/100)) == 0)
+    return(MagickTrue);
+  return(MagickFalse);
+}
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/montage.h

@@ -0,0 +1,91 @@
+/*
+  Copyright 1999-2017 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://www.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;
+
+  PixelInfo
+    alpha_color,  /* deprecated */
+    background_color,
+    border_color,
+    fill,
+    stroke;
+
+  GravityType
+    gravity;
+
+  char
+    filename[MagickPathExtent];
+
+  MagickBooleanType
+    debug;
+
+  size_t
+    signature;
+
+  PixelInfo
+    matte_color;
+} 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

bin/7.0.5-5/include/ImageMagick-7/MagickCore/morphology.h

@@ -0,0 +1,152 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/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,
+  BinomialKernel,
+  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 */
+} 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 */
+  IterativeDistanceMorphology,  /* 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 */
+/* Directly Applied Morphology methods */
+  DistanceMorphology,           /* Add Kernel Value, take Minimum */
+  VoronoiMorphology             /* Distance matte channel copy nearest color */
+} MorphologyMethod;
+
+typedef struct _KernelInfo
+{
+  KernelInfoType
+    type;
+
+  size_t
+    width,
+    height;
+
+  ssize_t
+    x,
+    y;
+
+  MagickRealType
+    *values;
+
+  double
+    minimum,
+    maximum,
+    negative_range,
+    positive_range,
+    angle;
+
+  struct _KernelInfo
+    *next;
+
+  size_t
+    signature;
+} KernelInfo;
+
+extern MagickExport KernelInfo
+  *AcquireKernelInfo(const char *,ExceptionInfo *),
+  *AcquireKernelBuiltIn(const KernelInfoType,const GeometryInfo *,
+    ExceptionInfo *),
+  *CloneKernelInfo(const KernelInfo *),
+  *DestroyKernelInfo(KernelInfo *);
+
+extern MagickExport Image
+  *MorphologyImage(const Image *,const MorphologyMethod,const ssize_t,
+    const KernelInfo *,ExceptionInfo *);
+
+extern MagickExport void
+  ScaleGeometryKernelInfo(KernelInfo *,const char *),
+  ScaleKernelInfo(KernelInfo *,const double,const GeometryFlags),
+  UnityAddKernelInfo(KernelInfo *,const double);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/nt-base.h

@@ -0,0 +1,328 @@
+/*
+  Copyright 1999-2017 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://www.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 Windows NT utility methods.
+*/
+#ifndef MAGICKCORE_NT_BASE_H
+#define MAGICKCORE_NT_BASE_H
+
+#include "MagickCore/exception.h"
+#include "MagickCore/geometry.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#if defined(MAGICKCORE_WINDOWS_SUPPORT)
+
+#define WIN32_LEAN_AND_MEAN
+#define VC_EXTRALEAN
+#define _CRT_SECURE_NO_DEPRECATE  1
+#include <windows.h>
+#include <wchar.h>
+#include <winuser.h>
+#include <wingdi.h>
+#include <io.h>
+#include <process.h>
+#include <errno.h>
+#include <malloc.h>
+#include <sys/utime.h>
+#if defined(_DEBUG) && !defined(__MINGW32__) && !defined(__MINGW64__)
+#include <crtdbg.h>
+#endif
+
+#define PROT_READ  0x01
+#define PROT_WRITE  0x02
+#define MAP_SHARED  0x01
+#define MAP_PRIVATE  0x02
+#define MAP_ANONYMOUS  0x20
+#define F_OK 0
+#define R_OK 4
+#define W_OK 2
+#define RW_OK 6
+#define _SC_PAGESIZE 1
+#define _SC_PHYS_PAGES 2
+#define _SC_OPEN_MAX 3
+#if !defined(SSIZE_MAX)
+#define SSIZE_MAX  0x7fffffffL
+#endif
+
+/*
+  _MSC_VER values:
+    1100 MSVC 5.0
+    1200 MSVC 6.0
+    1300 MSVC 7.0 Visual C++ .NET 2002
+    1310 Visual c++ .NET 2003
+    1400 Visual C++ 2005
+    1500 Visual C++ 2008
+    1600 Visual C++ 2010
+    1700 Visual C++ 2012
+    1800 Visual C++ 2013
+    1900 Visual C++ 2015
+*/
+
+#if !defined(chsize)
+# if defined(__BORLANDC__)
+#   define chsize(file,length)  chsize(file,length)
+# else
+#   define chsize(file,length)  _chsize(file,length)
+# endif
+#endif
+
+#if !defined(access)
+#if defined(_VISUALC_) && (_MSC_VER >= 1400)
+#  define access(path,mode)  _access_s(path,mode)
+#endif
+#endif
+#if !defined(chdir)
+#  define chdir  _chdir
+#endif
+#if !defined(close)
+#  define close  _close
+#endif
+#if !defined(closedir)
+#  define closedir(directory)  NTCloseDirectory(directory)
+#endif
+#define MAGICKCORE_HAVE_ERF
+#if defined(_VISUALC_) && (_MSC_VER < 1700)
+#  define erf(x)  NTErf(x)
+#endif
+#if !defined(fdopen)
+#  define fdopen  _fdopen
+#endif
+#if !defined(fileno)
+#  define fileno  _fileno
+#endif
+#if !defined(fseek) && !defined(__MINGW32__) && !defined(__MINGW64__)
+#if defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(Windows95) && \
+  !(defined(_MSC_VER) && (_MSC_VER < 1400)) && \
+  !(defined(__MSVCRT_VERSION__) && (__MSVCRT_VERSION__ < 0x800))
+#  define fseek  _fseeki64
+#endif
+#endif
+#if !defined(fstat) && !defined(__BORLANDC__)
+#if defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(Windows95) && \
+  !(defined(_MSC_VER) && (_MSC_VER < 1400)) && \
+  !(defined(__MSVCRT_VERSION__) && (__MSVCRT_VERSION__ < 0x800))
+#  define fstat  _fstati64
+#else
+#  define fstat  _fstat
+#endif
+#endif
+#if !defined(fsync)
+#  define fsync  _commit
+#endif
+#if !defined(ftell) && !defined(__MINGW32__) && !defined(__MINGW64__)
+#if defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(Windows95) && \
+  !(defined(_MSC_VER) && (_MSC_VER < 1400)) && \
+  !(defined(__MSVCRT_VERSION__) && (__MSVCRT_VERSION__ < 0x800))
+#  define ftell  _ftelli64
+#endif
+#endif
+#if !defined(ftruncate)
+#  define ftruncate(file,length)  NTTruncateFile(file,length)
+#endif
+#if !defined(getcwd)
+#  define getcwd  _getcwd
+#endif
+#if !defined(getpid)
+#  define getpid  _getpid
+#endif
+#if !defined(hypot)
+#  define hypot  _hypot
+#endif
+#if !defined(isatty)
+#  define isatty  _isatty
+#endif
+#if !defined(locale_t)
+#define locale_t _locale_t
+#endif
+#if defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(Windows95) && \
+  !(defined(_MSC_VER) && (_MSC_VER < 1400)) && \
+  !(defined(__MSVCRT_VERSION__) && (__MSVCRT_VERSION__ < 0x800))
+#if !defined(lseek)
+#  define lseek  _lseeki64
+#endif
+#else
+#if !defined(lseek)
+#  define lseek  _lseek
+#endif
+#endif
+#if !defined(MAGICKCORE_LTDL_DELEGATE)
+#if !defined(lt_dlclose)
+#  define lt_dlclose(handle)  NTCloseLibrary(handle)
+#endif
+#if !defined(lt_dlerror)
+#  define lt_dlerror()  NTGetLibraryError()
+#endif
+#if !defined(lt_dlexit)
+#  define lt_dlexit()  NTExitLibrary()
+#endif
+#if !defined(lt_dlinit)
+#  define lt_dlinit()  NTInitializeLibrary()
+#endif
+#if !defined(lt_dlopen)
+#  define lt_dlopen(filename)  NTOpenLibrary(filename)
+#endif
+#if !defined(lt_dlsetsearchpath)
+#  define lt_dlsetsearchpath(path)  NTSetSearchPath(path)
+#endif
+#if !defined(lt_dlsym)
+#  define lt_dlsym(handle,name)  NTGetLibrarySymbol(handle,name)
+#endif
+#endif
+#if !defined(mkdir)
+#  define mkdir  _mkdir
+#endif
+#if !defined(mmap)
+#  define mmap(address,length,protection,access,file,offset) \
+  NTMapMemory(address,length,protection,access,file,offset)
+#endif
+#if !defined(msync)
+#  define msync(address,length,flags)  NTSyncMemory(address,length,flags)
+#endif
+#if !defined(munmap)
+#  define munmap(address,length)  NTUnmapMemory(address,length)
+#endif
+#if !defined(opendir)
+#  define opendir(directory)  NTOpenDirectory(directory)
+#endif
+#if !defined(open)
+#  define open  _open
+#endif
+#if !defined(pclose)
+#  define pclose  _pclose
+#endif
+#if !defined(popen)
+#  define popen  _popen
+#endif
+#if !defined(fprintf_l)
+#define fprintf_l  _fprintf_s_l
+#endif
+#if !defined(read)
+#  define read(fd,buffer,count)  _read(fd,buffer,(unsigned int) count)
+#endif
+#if !defined(readdir)
+#  define readdir(directory)  NTReadDirectory(directory)
+#endif
+#if !defined(seekdir)
+#  define seekdir(directory,offset)  NTSeekDirectory(directory,offset)
+#endif
+#if !defined(setmode)
+#  define setmode  _setmode
+#endif
+#if !defined(spawnvp)
+#  define spawnvp  _spawnvp
+#endif
+#if !defined(strtod_l)
+#define strtod_l  _strtod_l
+#endif
+#if !defined(stat) && !defined(__BORLANDC__)
+#if defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(Windows95) && \
+  !(defined(_MSC_VER) && (_MSC_VER < 1400)) && \
+  !(defined(__MSVCRT_VERSION__) && (__MSVCRT_VERSION__ < 0x800))
+#  define stat  _stati64
+#else
+#  define stat  _stat
+#endif
+#endif
+#if !defined(strcasecmp)
+#  define strcasecmp  _stricmp
+#endif
+#if !defined(strncasecmp)
+#  define strncasecmp  _strnicmp
+#endif
+#if !defined(sysconf)
+#  define sysconf(name)  NTSystemConfiguration(name)
+#endif
+#if defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(Windows95) && \
+  !(defined(_MSC_VER) && (_MSC_VER < 1400)) && \
+  !(defined(__MSVCRT_VERSION__) && (__MSVCRT_VERSION__ < 0x800))
+#  define tell  _telli64
+#else
+#  define tell  _tell
+#endif
+#if !defined(telldir)
+#  define telldir(directory)  NTTellDirectory(directory)
+#endif
+#if !defined(tempnam)
+#  define tempnam  _tempnam_s
+#endif
+#if !defined(umask)
+#  define umask  _umask
+#endif
+#if !defined(unlink)
+#  define unlink  _unlink
+#endif
+#if !defined(utime)
+#  define utime  _utime
+#endif
+#if !defined(vfprintf_l)
+#define vfprintf_l  _vfprintf_l
+#endif
+#if !defined(vsnprintf)
+#if !defined(_MSC_VER) || (defined(_MSC_VER) && _MSC_VER < 1500)
+#define vsnprintf _vsnprintf 
+#endif
+#endif
+#if !defined(vsnprintf_l)
+#define vsnprintf_l  _vsnprintf_l
+#endif
+#if !defined(write)
+#  define write(fd,buffer,count)  _write(fd,buffer,(unsigned int) count)
+#endif
+#if !defined(wstat) && !defined(__BORLANDC__)
+#if defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(Windows95) && \
+  !(defined(_MSC_VER) && (_MSC_VER < 1400)) && \
+  !(defined(__MSVCRT_VERSION__) && (__MSVCRT_VERSION__ < 0x800))
+#  define wstat  _wstati64
+#else
+#  define wstat  _wstat
+#endif
+#endif
+
+#if defined(__BORLANDC__)
+#undef _O_RANDOM
+#define _O_RANDOM 0
+#undef _O_SEQUENTIAL
+#define _O_SEQUENTIAL 0
+#undef _O_SHORT_LIVED
+#define _O_SHORT_LIVED 0
+#undef _O_TEMPORARY
+#define _O_TEMPORARY 0
+#endif
+
+#undef gettimeofday
+
+typedef struct _GhostInfo
+  GhostInfo_;
+
+extern MagickExport char
+  **NTArgvToUTF8(const int argc,wchar_t **);
+
+extern MagickExport const GhostInfo_
+  *NTGhostscriptDLLVectors(void);
+
+extern MagickExport void
+  NTErrorHandler(const ExceptionType,const char *,const char *),
+  NTGhostscriptUnLoadDLL(void),
+  NTWarningHandler(const ExceptionType,const char *,const char *);
+#endif
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/opencl.h

@@ -0,0 +1,78 @@
+/*
+  Copyright 1999-2017 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://www.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
+
+typedef enum
+{
+  UndefinedCLDeviceType,
+  CpuCLDeviceType,
+  GpuCLDeviceType
+} MagickCLDeviceType;
+
+typedef struct _KernelProfileRecord
+{
+  char
+    *kernel_name;
+
+  unsigned long
+    count,
+    max,
+    min,
+    total;
+}* KernelProfileRecord;
+
+typedef struct _MagickCLDevice* MagickCLDevice;
+
+extern MagickExport const char
+  *GetOpenCLDeviceName(const MagickCLDevice),
+  *GetOpenCLDeviceVendorName(const MagickCLDevice),
+  *GetOpenCLDeviceVersion(const MagickCLDevice);
+
+extern MagickExport const KernelProfileRecord
+  *GetOpenCLKernelProfileRecords(const MagickCLDevice,size_t *);
+
+extern MagickExport double
+  GetOpenCLDeviceBenchmarkScore(const MagickCLDevice);
+
+extern MagickExport MagickCLDevice
+  *GetOpenCLDevices(size_t *,ExceptionInfo *);
+
+extern MagickExport MagickCLDeviceType
+  GetOpenCLDeviceType(const MagickCLDevice);
+
+extern MagickExport MagickBooleanType
+  GetOpenCLDeviceEnabled(const MagickCLDevice),
+  GetOpenCLEnabled(void),
+  SetOpenCLEnabled(const MagickBooleanType);
+
+extern MagickExport void
+  SetOpenCLDeviceEnabled(MagickCLDevice,
+    const MagickBooleanType),
+  SetOpenCLKernelProfileEnabled(MagickCLDevice,
+    const MagickBooleanType);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/option.h

@@ -0,0 +1,211 @@
+/*
+  Copyright 1999-2017 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://www.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,
+  MagickAlphaChannelOptions,
+  MagickBooleanOptions,
+  MagickCacheOptions,
+  MagickChannelOptions,
+  MagickClassOptions,
+  MagickClipPathOptions,
+  MagickCoderOptions,
+  MagickColorOptions,
+  MagickColorspaceOptions,
+  MagickCommandOptions,
+  MagickComplexOptions,
+  MagickComplianceOptions,
+  MagickComposeOptions,
+  MagickCompressOptions,
+  MagickConfigureOptions,
+  MagickDataTypeOptions,
+  MagickDebugOptions,
+  MagickDecorateOptions,
+  MagickDelegateOptions,
+  MagickDirectionOptions,
+  MagickDisposeOptions,
+  MagickDistortOptions,
+  MagickDitherOptions,
+  MagickEndianOptions,
+  MagickEvaluateOptions,
+  MagickFillRuleOptions,
+  MagickFilterOptions,
+  MagickFontOptions,
+  MagickFontsOptions,
+  MagickFormatOptions,
+  MagickFunctionOptions,
+  MagickGradientOptions,
+  MagickGravityOptions,
+  MagickIntensityOptions,
+  MagickIntentOptions,
+  MagickInterlaceOptions,
+  MagickInterpolateOptions,
+  MagickKernelOptions,
+  MagickLayerOptions,
+  MagickLineCapOptions,
+  MagickLineJoinOptions,
+  MagickListOptions,
+  MagickLocaleOptions,
+  MagickLogEventOptions,
+  MagickLogOptions,
+  MagickMagicOptions,
+  MagickMethodOptions,
+  MagickMetricOptions,
+  MagickMimeOptions,
+  MagickModeOptions,
+  MagickModuleOptions,
+  MagickMorphologyOptions,
+  MagickNoiseOptions,
+  MagickOrientationOptions,
+  MagickPixelChannelOptions,
+  MagickPixelIntensityOptions,
+  MagickPixelMaskOptions,
+  MagickPixelTraitOptions,
+  MagickPolicyOptions,
+  MagickPolicyDomainOptions,
+  MagickPolicyRightsOptions,
+  MagickPreviewOptions,
+  MagickPrimitiveOptions,
+  MagickQuantumFormatOptions,
+  MagickResolutionOptions,
+  MagickResourceOptions,
+  MagickSparseColorOptions,
+  MagickStatisticOptions,
+  MagickStorageOptions,
+  MagickStretchOptions,
+  MagickStyleOptions,
+  MagickThresholdOptions,
+  MagickTypeOptions,
+  MagickValidateOptions,
+  MagickVirtualPixelOptions,
+  MagickWeightOptions
+} 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;
+
+/*
+  Flags to describe classes of image processing options.
+  These are used to determine how a option should be processed, and
+  avoid attempting to process all options in every way posible.
+*/
+typedef enum
+{
+  UndefinedOptionFlag       = 0x0000,  /* option flag is not in use */
+
+  ImageInfoOptionFlag       = 0x0001,  /* Setting stored in ImageInfo */
+  DrawInfoOptionFlag        = 0x0002,  /* Setting stored in DrawInfo */
+  QuantizeInfoOptionFlag    = 0x0004,  /* Setting stored in QuantizeInfo */
+  GlobalOptionFlag          = 0x0008,  /* Global Setting or Control */
+  SettingOptionFlags        = 0x000F,  /* mask any setting option */
+
+  NoImageOperatorFlag       = 0x0010,  /* Images not required operator */
+  SimpleOperatorFlag        = 0x0020,  /* Simple Image processing operator */
+  ListOperatorFlag          = 0x0040,  /* Multi-Image processing operator */
+  GenesisOptionFlag         = 0x0080,  /* MagickCommandGenesis() Only Option */
+
+  SpecialOptionFlag         = 0x0100,  /* Operator with Special Requirements */
+                                       /* EG: for specific CLI commands */
+
+  AlwaysInterpretArgsFlag   = 0x0400,  /* Always Interpret escapes in Args */
+                                       /* CF: "convert" compatibility mode */
+  NeverInterpretArgsFlag    = 0x0800,  /* Never Interpret escapes in Args */
+                                       /* EG: filename, or delayed escapes */
+
+  NonMagickOptionFlag       = 0x1000,  /* Option not used by Magick Command */
+  FireOptionFlag            = 0x2000,  /* Convert operation seq firing point */
+  DeprecateOptionFlag       = 0x4000,  /* Deprecate option (no code) */
+  ReplacedOptionFlag        = 0x8800   /* Replaced Option (but still works) */
+
+} CommandOptionFlags;
+
+typedef struct _OptionInfo
+{
+  const char
+    *mnemonic;
+
+  ssize_t
+    type,
+    flags;
+
+  MagickBooleanType
+    stealth;
+} OptionInfo;
+
+
+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 *),
+  ParsePixelChannelOption(const char *),
+  ParseCommandOption(const CommandOption,const MagickBooleanType,const char *);
+
+extern MagickExport void
+  DestroyImageOptions(ImageInfo *),
+  ResetImageOptions(const ImageInfo *),
+  ResetImageOptionIterator(const ImageInfo *);
+
+extern MagickExport const OptionInfo
+  *GetCommandOptionInfo(const char *value);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/paint.h

@@ -0,0 +1,47 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/color.h"
+#include "MagickCore/draw.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern MagickExport Image
+  *OilPaintImage(const Image *,const double,const double,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  FloodfillPaintImage(Image *,const DrawInfo *,const PixelInfo *,const ssize_t,
+    const ssize_t,const MagickBooleanType,ExceptionInfo *),
+  GradientImage(Image *,const GradientType,const SpreadMethod,const StopInfo *,
+    const size_t,ExceptionInfo *),
+  OpaquePaintImage(Image *,const PixelInfo *,const PixelInfo *,
+    const MagickBooleanType,ExceptionInfo *),
+  TransparentPaintImage(Image *,const PixelInfo *,
+    const Quantum,const MagickBooleanType,ExceptionInfo *),
+  TransparentPaintImageChroma(Image *,const PixelInfo *,
+    const PixelInfo *,const Quantum,const MagickBooleanType,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/pixel-accessor.h

@@ -0,0 +1,870 @@
+/*
+  Copyright 1999-2017 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://www.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 <assert.h>
+#include "MagickCore/cache.h"
+#include "MagickCore/cache-view.h"
+#include "MagickCore/color.h"
+#include "MagickCore/colorspace.h"
+#include "MagickCore/gem.h"
+#include "MagickCore/image.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#undef index
+
+static inline Quantum ClampPixel(const MagickRealType value)
+{ 
+  if (value < 0.0f)
+    return((Quantum) 0); 
+  if (value >= (MagickRealType) QuantumRange)
+    return((Quantum) QuantumRange);
+#if !defined(MAGICKCORE_HDRI_SUPPORT)
+  return((Quantum) (value+0.5f));
+#else
+  return((Quantum) value);
+#endif
+}
+
+static inline Quantum GetPixela(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  return(pixel[image->channel_map[aPixelChannel].offset]);
+}
+
+static inline Quantum GetPixelAlpha(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  if (image->channel_map[AlphaPixelChannel].traits == UndefinedPixelTrait)
+    return(OpaqueAlpha);
+  return(pixel[image->channel_map[AlphaPixelChannel].offset]);
+}
+
+static inline PixelTrait GetPixelAlphaTraits(
+  const Image *magick_restrict image)
+{
+  return(image->channel_map[AlphaPixelChannel].traits);
+}
+
+static inline Quantum GetPixelb(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  return(pixel[image->channel_map[bPixelChannel].offset]);
+}
+
+static inline Quantum GetPixelBlack(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  if (image->channel_map[BlackPixelChannel].traits == UndefinedPixelTrait)
+    return((Quantum) 0);
+  return(pixel[image->channel_map[BlackPixelChannel].offset]);
+}
+
+static inline PixelTrait GetPixelBlackTraits(
+  const Image *magick_restrict image)
+{
+  return(image->channel_map[BlackPixelChannel].traits);
+}
+
+static inline Quantum GetPixelBlue(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  return(pixel[image->channel_map[BluePixelChannel].offset]);
+}
+
+static inline PixelTrait GetPixelBlueTraits(const Image *magick_restrict image)
+{
+  return(image->channel_map[BluePixelChannel].traits);
+}
+
+static inline Quantum GetPixelCb(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  return(pixel[image->channel_map[CbPixelChannel].offset]);
+}
+
+static inline PixelTrait GetPixelCbTraits(const Image *magick_restrict image)
+{
+  return(image->channel_map[CbPixelChannel].traits);
+}
+
+static inline Quantum GetPixelChannel(const Image *magick_restrict image,
+  const PixelChannel channel,const Quantum *magick_restrict pixel)
+{
+  if (image->channel_map[channel].traits == UndefinedPixelTrait)
+    return((Quantum) 0);
+  return(pixel[image->channel_map[channel].offset]);
+}
+
+static inline PixelChannel GetPixelChannelChannel(
+  const Image *magick_restrict image,const ssize_t offset)
+{
+  return(image->channel_map[offset].channel);
+}
+
+static inline ssize_t GetPixelChannelOffset(const Image *magick_restrict image,
+  const PixelChannel channel)
+{
+  return(image->channel_map[channel].offset);
+}
+
+static inline PixelTrait GetPixelChannelTraits(
+  const Image *magick_restrict image,const PixelChannel channel)
+{
+  return(image->channel_map[channel].traits);
+}
+
+static inline size_t GetPixelChannels(const Image *magick_restrict image)
+{
+  return(image->number_channels);
+}
+
+static inline Quantum GetPixelCr(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  return(pixel[image->channel_map[CrPixelChannel].offset]);
+}
+
+static inline PixelTrait GetPixelCrTraits(const Image *magick_restrict image)
+{
+  return(image->channel_map[CrPixelChannel].traits);
+}
+
+static inline Quantum GetPixelCyan(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  return(pixel[image->channel_map[CyanPixelChannel].offset]);
+}
+
+static inline PixelTrait GetPixelCyanTraits(const Image *magick_restrict image)
+{
+  return(image->channel_map[CyanPixelChannel].traits);
+}
+
+static inline Quantum GetPixelGray(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  return(pixel[image->channel_map[GrayPixelChannel].offset]);
+}
+
+static inline PixelTrait GetPixelGrayTraits(const Image *magick_restrict image)
+{
+  return(image->channel_map[GrayPixelChannel].traits);
+}
+
+static inline Quantum GetPixelGreen(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  return(pixel[image->channel_map[GreenPixelChannel].offset]);
+}
+
+static inline PixelTrait GetPixelGreenTraits(
+  const Image *magick_restrict image)
+{
+  return(image->channel_map[GreenPixelChannel].traits);
+}
+
+static inline Quantum GetPixelIndex(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  if (image->channel_map[IndexPixelChannel].traits == UndefinedPixelTrait)
+    return((Quantum) 0);
+  return(pixel[image->channel_map[IndexPixelChannel].offset]);
+}
+
+static inline PixelTrait GetPixelIndexTraits(
+  const Image *magick_restrict image)
+{
+  return(image->channel_map[IndexPixelChannel].traits);
+}
+
+static inline MagickRealType GetPixelInfoChannel(
+  const PixelInfo *magick_restrict pixel_info,const PixelChannel channel)
+{
+  switch (channel)
+  {
+    case RedPixelChannel: return(pixel_info->red);
+    case GreenPixelChannel: return(pixel_info->green);
+    case BluePixelChannel: return(pixel_info->blue);
+    case BlackPixelChannel: return(pixel_info->black);
+    case AlphaPixelChannel: return(pixel_info->alpha);
+    case IndexPixelChannel: return(pixel_info->index);
+    default: return((MagickRealType) 0.0);
+  }
+}
+
+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 GetPixelInfoLuma(
+  const PixelInfo *magick_restrict pixel)
+{
+  MagickRealType
+    intensity;
+
+  if (pixel->colorspace == sRGBColorspace)
+    {
+      intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
+        0.072186f*pixel->blue);
+      return(intensity);
+    }
+  intensity=(MagickRealType) (0.212656f*EncodePixelGamma(pixel->red)+
+    0.715158f*EncodePixelGamma(pixel->green)+
+    0.072186f*EncodePixelGamma(pixel->blue));
+  return(intensity);
+}
+
+static inline MagickRealType GetPixelInfoLuminance(
+  const PixelInfo *magick_restrict pixel)
+{
+  MagickRealType
+    intensity;
+
+  if (pixel->colorspace != sRGBColorspace)
+    {
+      intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
+        0.072186f*pixel->blue);
+      return(intensity);
+    }
+  intensity=(MagickRealType) (0.212656f*DecodePixelGamma(pixel->red)+
+    0.715158f*DecodePixelGamma(pixel->green)+
+    0.072186f*DecodePixelGamma(pixel->blue));
+  return(intensity);
+}
+
+static inline Quantum GetPixelL(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  return(pixel[image->channel_map[LPixelChannel].offset]);
+}
+
+static inline ssize_t GetPixelLabel(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  return((ssize_t) pixel[image->channel_map[LabelPixelChannel].offset]);
+}
+
+static inline MagickRealType GetPixelLuma(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  MagickRealType
+    intensity;
+
+  intensity=(MagickRealType) (
+    0.212656f*pixel[image->channel_map[RedPixelChannel].offset]+
+    0.715158f*pixel[image->channel_map[GreenPixelChannel].offset]+
+    0.072186f*pixel[image->channel_map[BluePixelChannel].offset]);
+  return(intensity);
+}
+
+static inline MagickRealType GetPixelLuminance(
+  const Image *magick_restrict image,const Quantum *magick_restrict pixel)
+{
+  MagickRealType
+    intensity;
+
+  if (image->colorspace != sRGBColorspace)
+    {
+      intensity=(MagickRealType) (
+        0.212656f*pixel[image->channel_map[RedPixelChannel].offset]+
+        0.715158f*pixel[image->channel_map[GreenPixelChannel].offset]+
+        0.072186f*pixel[image->channel_map[BluePixelChannel].offset]);
+      return(intensity);
+    }
+  intensity=(MagickRealType) (0.212656f*DecodePixelGamma((MagickRealType)
+    pixel[image->channel_map[RedPixelChannel].offset])+0.715158f*
+    DecodePixelGamma((MagickRealType)
+    pixel[image->channel_map[GreenPixelChannel].offset])+0.072186f*
+    DecodePixelGamma((MagickRealType)
+    pixel[image->channel_map[BluePixelChannel].offset]));
+  return(intensity);
+}
+
+static inline Quantum GetPixelMagenta(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  return(pixel[image->channel_map[MagentaPixelChannel].offset]);
+}
+
+static inline PixelTrait GetPixelMagentaTraits(
+  const Image *magick_restrict image)
+{
+  return(image->channel_map[MagentaPixelChannel].traits);
+}
+
+static inline Quantum GetPixelReadMask(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  if (image->channel_map[ReadMaskPixelChannel].traits == UndefinedPixelTrait)
+    return((Quantum) QuantumRange);
+  return(pixel[image->channel_map[ReadMaskPixelChannel].offset]);
+}
+
+static inline Quantum GetPixelWriteMask(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  if (image->channel_map[WriteMaskPixelChannel].traits == UndefinedPixelTrait)
+    return((Quantum) QuantumRange);
+  return(pixel[image->channel_map[WriteMaskPixelChannel].offset]);
+}
+
+static inline PixelTrait GetPixelReadMaskTraits(
+  const Image *magick_restrict image)
+{
+  return(image->channel_map[ReadMaskPixelChannel].traits);
+}
+
+static inline size_t GetPixelMetaChannels(const Image *magick_restrict image)
+{
+  return(image->number_meta_channels);
+}
+
+static inline size_t GetPixelMetacontentExtent(
+  const Image *magick_restrict image)
+{
+  return(image->metacontent_extent);
+}
+
+static inline Quantum GetPixelOpacity(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  if (image->channel_map[AlphaPixelChannel].traits != BlendPixelTrait)
+    return(QuantumRange-OpaqueAlpha);
+  return(QuantumRange-pixel[image->channel_map[AlphaPixelChannel].offset]);
+}
+
+static inline Quantum GetPixelRed(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  return(pixel[image->channel_map[RedPixelChannel].offset]);
+}
+
+static inline PixelTrait GetPixelRedTraits(const Image *magick_restrict image)
+{
+  return(image->channel_map[RedPixelChannel].traits);
+}
+
+static inline void GetPixelInfoPixel(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel,PixelInfo *magick_restrict pixel_info)
+{
+  pixel_info->storage_class=image->storage_class;
+  pixel_info->colorspace=image->colorspace;
+  pixel_info->fuzz=image->fuzz;
+  pixel_info->depth=image->depth;
+  pixel_info->red=(MagickRealType)
+    pixel[image->channel_map[RedPixelChannel].offset];
+  pixel_info->green=(MagickRealType)
+    pixel[image->channel_map[GreenPixelChannel].offset];
+  pixel_info->blue=(MagickRealType)
+    pixel[image->channel_map[BluePixelChannel].offset];
+  pixel_info->black=0.0f;
+  if (image->channel_map[BlackPixelChannel].traits != UndefinedPixelTrait)
+    pixel_info->black=(MagickRealType)
+      pixel[image->channel_map[BlackPixelChannel].offset];
+  pixel_info->alpha=(MagickRealType) OpaqueAlpha;
+  pixel_info->alpha_trait=UndefinedPixelTrait;
+  if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
+    {
+      pixel_info->alpha=(MagickRealType)
+        pixel[image->channel_map[AlphaPixelChannel].offset];
+      pixel_info->alpha_trait=BlendPixelTrait;
+    }
+  pixel_info->index=0.0f;
+  if (image->channel_map[IndexPixelChannel].traits != UndefinedPixelTrait)
+    pixel_info->index=(MagickRealType)
+      pixel[image->channel_map[IndexPixelChannel].offset];
+  pixel_info->count=0;
+}
+
+static inline PixelTrait GetPixelTraits(const Image *magick_restrict image,
+  const PixelChannel channel)
+{
+  return(image->channel_map[channel].traits);
+}
+
+static inline Quantum GetPixelY(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  return(pixel[image->channel_map[YPixelChannel].offset]);
+}
+
+static inline PixelTrait GetPixelYTraits(const Image *magick_restrict image)
+{
+  return(image->channel_map[YPixelChannel].traits);
+}
+
+static inline Quantum GetPixelYellow(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  return(pixel[image->channel_map[YellowPixelChannel].offset]);
+}
+
+static inline PixelTrait GetPixelYellowTraits(
+  const Image *magick_restrict image)
+{
+  return(image->channel_map[YellowPixelChannel].traits);
+}
+
+static inline MagickRealType AbsolutePixelValue(const MagickRealType x)
+{
+  return(x < 0.0f ? -x : x);
+}
+
+static inline MagickBooleanType IsPixelAtDepth(const Quantum pixel,
+  const QuantumAny range)
+{
+  Quantum
+    quantum;
+
+#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*pixel)/QuantumRange+0.5)))/range);
+#endif
+  return(pixel == quantum ? MagickTrue : MagickFalse);
+}
+
+static inline MagickBooleanType IsPixelEquivalent(
+  const Image *magick_restrict image,const Quantum *magick_restrict p,
+  const PixelInfo *magick_restrict q)
+{
+  MagickRealType
+    value;
+
+  value=(MagickRealType) p[image->channel_map[AlphaPixelChannel].offset];
+  if ((image->alpha_trait != UndefinedPixelTrait) &&
+      (q->alpha_trait == UndefinedPixelTrait) &&
+      (AbsolutePixelValue(value-OpaqueAlpha) >= MagickEpsilon))
+    return(MagickFalse);
+  if ((q->alpha_trait != UndefinedPixelTrait) &&
+      (image->alpha_trait == UndefinedPixelTrait) &&
+      (AbsolutePixelValue(q->alpha-OpaqueAlpha)) >= MagickEpsilon)
+    return(MagickFalse);
+  if ((image->alpha_trait != UndefinedPixelTrait) &&
+      (q->alpha_trait != UndefinedPixelTrait))
+    {
+      if (AbsolutePixelValue(value-q->alpha) >= MagickEpsilon)
+        return(MagickFalse);
+      if (AbsolutePixelValue(value-TransparentAlpha) < MagickEpsilon)
+        return(MagickTrue);
+    }
+  value=(MagickRealType) p[image->channel_map[RedPixelChannel].offset];
+  if (AbsolutePixelValue(value-q->red) >= MagickEpsilon)
+    return(MagickFalse);
+  value=(MagickRealType) p[image->channel_map[GreenPixelChannel].offset];
+  if (AbsolutePixelValue(value-q->green) >= MagickEpsilon)
+    return(MagickFalse);
+  value=(MagickRealType) p[image->channel_map[BluePixelChannel].offset];
+  if (AbsolutePixelValue(value-q->blue) >= MagickEpsilon)
+    return(MagickFalse);
+  if (image->colorspace == CMYKColorspace)
+    {
+      value=(MagickRealType) p[image->channel_map[BlackPixelChannel].offset];
+      if (AbsolutePixelValue(value-q->black) >= MagickEpsilon)
+        return(MagickFalse);
+    }
+  return(MagickTrue);
+}
+
+static inline MagickBooleanType IsPixelGray(const Image *magick_restrict image,
+  const Quantum *magick_restrict pixel)
+{
+  MagickRealType
+    green_blue,
+    red_green;
+
+  red_green=(MagickRealType) pixel[image->channel_map[RedPixelChannel].offset]-
+    pixel[image->channel_map[GreenPixelChannel].offset];
+  green_blue=(MagickRealType)
+    pixel[image->channel_map[GreenPixelChannel].offset]-
+    pixel[image->channel_map[BluePixelChannel].offset];
+  if ((AbsolutePixelValue(red_green) < MagickEpsilon) &&
+      (AbsolutePixelValue(green_blue) < MagickEpsilon))
+    return(MagickTrue);
+  return(MagickFalse);
+}
+
+static inline MagickBooleanType IsPixelInfoEquivalent(
+  const PixelInfo *magick_restrict p,const PixelInfo *magick_restrict q)
+{
+  if ((p->alpha_trait != UndefinedPixelTrait) &&
+      (q->alpha_trait == UndefinedPixelTrait) &&
+      (AbsolutePixelValue(p->alpha-OpaqueAlpha) >= MagickEpsilon))
+    return(MagickFalse);
+  if ((q->alpha_trait != UndefinedPixelTrait) &&
+      (p->alpha_trait == UndefinedPixelTrait) &&
+      (AbsolutePixelValue(q->alpha-OpaqueAlpha)) >= MagickEpsilon)
+    return(MagickFalse);
+  if ((p->alpha_trait != UndefinedPixelTrait) &&
+      (q->alpha_trait != UndefinedPixelTrait))
+    {
+      if (AbsolutePixelValue(p->alpha-q->alpha) >= MagickEpsilon)
+        return(MagickFalse);
+      if (AbsolutePixelValue(p->alpha-TransparentAlpha) < MagickEpsilon)
+        return(MagickTrue);
+    }
+  if (AbsolutePixelValue(p->red-q->red) >= MagickEpsilon)
+    return(MagickFalse);
+  if (AbsolutePixelValue(p->green-q->green) >= MagickEpsilon)
+    return(MagickFalse);
+  if (AbsolutePixelValue(p->blue-q->blue) >= MagickEpsilon)
+    return(MagickFalse);
+  if ((p->colorspace == CMYKColorspace) &&
+      (AbsolutePixelValue(p->black-q->black) >= MagickEpsilon))
+    return(MagickFalse);
+  return(MagickTrue);
+}
+
+static inline MagickBooleanType IsPixelMonochrome(
+  const Image *magick_restrict image,const Quantum *magick_restrict pixel)
+{
+  MagickRealType
+    green_blue,
+    red,
+    red_green;
+
+  red=(MagickRealType) pixel[image->channel_map[RedPixelChannel].offset];
+  if ((AbsolutePixelValue(red) >= MagickEpsilon) &&
+      (AbsolutePixelValue(red-QuantumRange) >= MagickEpsilon))
+    return(MagickFalse);
+  red_green=(MagickRealType) pixel[image->channel_map[RedPixelChannel].offset]-
+    pixel[image->channel_map[GreenPixelChannel].offset];
+  green_blue=(MagickRealType)
+    pixel[image->channel_map[GreenPixelChannel].offset]-
+    pixel[image->channel_map[BluePixelChannel].offset];
+  if ((AbsolutePixelValue(red_green) < MagickEpsilon) &&
+      (AbsolutePixelValue(green_blue) < MagickEpsilon))
+    return(MagickTrue);
+  return(MagickFalse);
+}
+
+static inline MagickBooleanType IsPixelInfoGray(
+  const PixelInfo *magick_restrict pixel)
+{
+  if ((AbsolutePixelValue(pixel->red-pixel->green) < MagickEpsilon) &&
+      (AbsolutePixelValue(pixel->green-pixel->blue) < MagickEpsilon))
+    return(MagickTrue);
+  return(MagickFalse);
+}
+
+static inline MagickBooleanType IsPixelInfoMonochrome(
+  const PixelInfo *magick_restrict pixel_info)
+{
+  MagickRealType
+    green_blue,
+    red_green;
+
+  if ((AbsolutePixelValue(pixel_info->red) >= MagickEpsilon) ||
+      (AbsolutePixelValue(pixel_info->red-QuantumRange) >= MagickEpsilon))
+    return(MagickFalse);
+  red_green=pixel_info->red-pixel_info->green;
+  green_blue=pixel_info->green-pixel_info->blue;
+  if ((AbsolutePixelValue(red_green) < MagickEpsilon) &&
+      (AbsolutePixelValue(green_blue) < MagickEpsilon))
+    return(MagickTrue);
+  return(MagickFalse);
+}
+
+static inline void SetPixela(const Image *magick_restrict image,
+  const Quantum a,Quantum *magick_restrict pixel)
+{
+  if (image->channel_map[aPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[aPixelChannel].offset]=a;
+}
+
+static inline void SetPixelAlpha(const Image *magick_restrict image,
+  const Quantum alpha,Quantum *magick_restrict pixel)
+{
+  if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[AlphaPixelChannel].offset]=alpha;
+}
+
+static inline void SetPixelAlphaTraits(Image *image,const PixelTrait traits)
+{
+  image->channel_map[AlphaPixelChannel].traits=traits;
+}
+
+static inline void SetPixelb(const Image *magick_restrict image,
+  const Quantum b,Quantum *magick_restrict pixel)
+{
+  if (image->channel_map[bPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[bPixelChannel].offset]=b;
+}
+
+static inline void SetPixelBackgoundColor(const Image *magick_restrict image,
+  Quantum *magick_restrict pixel)
+{
+  register ssize_t
+    i;
+
+  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+    pixel[i]=(Quantum) 0;
+  pixel[image->channel_map[RedPixelChannel].offset]=
+    ClampToQuantum(image->background_color.red);
+  pixel[image->channel_map[GreenPixelChannel].offset]=
+    ClampToQuantum(image->background_color.green);
+  pixel[image->channel_map[BluePixelChannel].offset]=
+    ClampToQuantum(image->background_color.blue);
+  if (image->channel_map[BlackPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[BlackPixelChannel].offset]=
+      ClampToQuantum(image->background_color.black);
+  if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[AlphaPixelChannel].offset]=
+      image->background_color.alpha_trait == UndefinedPixelTrait ? OpaqueAlpha :
+      ClampToQuantum(image->background_color.alpha);
+}
+
+static inline void SetPixelBlack(const Image *magick_restrict image,
+  const Quantum black,Quantum *magick_restrict pixel)
+{
+  if (image->channel_map[BlackPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[BlackPixelChannel].offset]=black;
+}
+
+static inline void SetPixelBlackTraits(Image *image,const PixelTrait traits)
+{
+  image->channel_map[BlackPixelChannel].traits=traits;
+}
+
+static inline void SetPixelBlue(const Image *magick_restrict image,
+  const Quantum blue,Quantum *magick_restrict pixel)
+{
+  pixel[image->channel_map[BluePixelChannel].offset]=blue;
+}
+
+static inline void SetPixelBlueTraits(Image *image,const PixelTrait traits)
+{
+  image->channel_map[BluePixelChannel].traits=traits;
+}
+
+static inline void SetPixelCb(const Image *magick_restrict image,
+  const Quantum cb,Quantum *magick_restrict pixel)
+{
+  pixel[image->channel_map[CbPixelChannel].offset]=cb;
+}
+
+static inline void SetPixelCbTraits(Image *image,const PixelTrait traits)
+{
+  image->channel_map[CbPixelChannel].traits=traits;
+}
+
+static inline void SetPixelChannel(const Image *magick_restrict image,
+  const PixelChannel channel,const Quantum quantum,
+  Quantum *magick_restrict pixel)
+{
+  if (image->channel_map[channel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[channel].offset]=quantum;
+}
+
+static inline void SetPixelChannelAttributes(
+  const Image *magick_restrict image,const PixelChannel channel,
+  const PixelTrait traits,const ssize_t offset)
+{
+  assert((ssize_t) channel < MaxPixelChannels);
+  assert(offset < MaxPixelChannels);
+  image->channel_map[offset].channel=channel;
+  image->channel_map[channel].offset=offset;
+  image->channel_map[channel].traits=traits;
+}
+
+static inline void SetPixelChannelChannel(const Image *magick_restrict image,
+  const PixelChannel channel,const ssize_t offset)
+{
+  image->channel_map[offset].channel=channel;
+  image->channel_map[channel].offset=offset;
+}
+
+static inline void SetPixelChannels(Image *image,const size_t number_channels)
+{
+  image->number_channels=number_channels;
+}
+
+static inline void SetPixelChannelTraits(Image *image,
+  const PixelChannel channel,const PixelTrait traits)
+{
+  image->channel_map[channel].traits=traits;
+}
+
+static inline void SetPixelCr(const Image *magick_restrict image,
+  const Quantum cr,Quantum *magick_restrict pixel)
+{
+  pixel[image->channel_map[CrPixelChannel].offset]=cr;
+}
+
+static inline void SetPixelCrTraits(Image *image,const PixelTrait traits)
+{
+  image->channel_map[CrPixelChannel].traits=traits;
+}
+
+static inline void SetPixelCyan(const Image *magick_restrict image,
+  const Quantum cyan,Quantum *magick_restrict pixel)
+{
+  pixel[image->channel_map[CyanPixelChannel].offset]=cyan;
+}
+
+static inline void SetPixelGray(const Image *magick_restrict image,
+  const Quantum gray,Quantum *magick_restrict pixel)
+{
+  pixel[image->channel_map[GrayPixelChannel].offset]=gray;
+}
+
+static inline void SetPixelGrayTraits(Image *image,const PixelTrait traits)
+{
+  image->channel_map[GrayPixelChannel].traits=traits;
+}
+
+static inline void SetPixelGreen(const Image *magick_restrict image,
+  const Quantum green,Quantum *magick_restrict pixel)
+{
+  pixel[image->channel_map[GreenPixelChannel].offset]=green;
+}
+
+static inline void SetPixelGreenTraits(Image *image,const PixelTrait traits)
+{
+  image->channel_map[GreenPixelChannel].traits=traits;
+}
+
+static inline void SetPixelIndex(const Image *magick_restrict image,
+  const Quantum index,Quantum *magick_restrict pixel)
+{
+  if (image->channel_map[IndexPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[IndexPixelChannel].offset]=index;
+}
+
+static inline void SetPixelIndexTraits(Image *image,const PixelTrait traits)
+{
+  image->channel_map[IndexPixelChannel].traits=traits;
+}
+
+static inline void SetPixelViaPixelInfo(const Image *magick_restrict image,
+  const PixelInfo *magick_restrict pixel_info,Quantum *magick_restrict pixel)
+{
+  pixel[image->channel_map[RedPixelChannel].offset]=
+    ClampToQuantum(pixel_info->red);
+  pixel[image->channel_map[GreenPixelChannel].offset]=
+    ClampToQuantum(pixel_info->green);
+  pixel[image->channel_map[BluePixelChannel].offset]=
+    ClampToQuantum(pixel_info->blue);
+  if (image->channel_map[BlackPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[BlackPixelChannel].offset]=
+      ClampToQuantum(pixel_info->black);
+  if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[AlphaPixelChannel].offset]=
+      pixel_info->alpha_trait == UndefinedPixelTrait ? OpaqueAlpha :
+      ClampToQuantum(pixel_info->alpha);
+}
+
+static inline void SetPixelL(const Image *magick_restrict image,const Quantum L,
+  Quantum *magick_restrict pixel)
+{
+  if (image->channel_map[LPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[LPixelChannel].offset]=L;
+}
+
+static inline void SetPixelMagenta(const Image *magick_restrict image,
+  const Quantum magenta,Quantum *magick_restrict pixel)
+{
+  pixel[image->channel_map[MagentaPixelChannel].offset]=magenta;
+}
+
+static inline void SetPixelMagentaTraits(Image *image,const PixelTrait traits)
+{
+  image->channel_map[MagentaPixelChannel].traits=traits;
+}
+
+static inline void SetPixelReadMask(const Image *magick_restrict image,
+  const Quantum mask,Quantum *magick_restrict pixel)
+{
+  if (image->channel_map[ReadMaskPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[ReadMaskPixelChannel].offset]=mask;
+}
+
+static inline void SetPixelWriteMask(const Image *magick_restrict image,
+  const Quantum mask,Quantum *magick_restrict pixel)
+{
+  if (image->channel_map[WriteMaskPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[WriteMaskPixelChannel].offset]=mask;
+}
+
+static inline void SetPixelMetacontentExtent(Image *image,const size_t extent)
+{
+  image->metacontent_extent=extent;
+}
+
+static inline void SetPixelOpacity(const Image *magick_restrict image,
+  const Quantum alpha,Quantum *magick_restrict pixel)
+{
+  if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[AlphaPixelChannel].offset]=QuantumRange-alpha;
+}
+
+static inline void SetPixelRed(const Image *magick_restrict image,
+  const Quantum red,Quantum *magick_restrict pixel)
+{
+  pixel[image->channel_map[RedPixelChannel].offset]=red;
+}
+
+static inline void SetPixelRedTraits(Image *image,const PixelTrait traits)
+{
+  image->channel_map[RedPixelChannel].traits=traits;
+}
+
+static inline void SetPixelYellow(const Image *magick_restrict image,
+  const Quantum yellow,Quantum *magick_restrict pixel)
+{
+  pixel[image->channel_map[YellowPixelChannel].offset]=yellow;
+}
+
+static inline void SetPixelYellowTraits(Image *image,const PixelTrait traits)
+{
+  image->channel_map[YellowPixelChannel].traits=traits;
+}
+
+static inline void SetPixelY(const Image *magick_restrict image,
+  const Quantum y,Quantum *magick_restrict pixel)
+{
+  pixel[image->channel_map[YPixelChannel].offset]=y;
+}
+
+static inline void SetPixelYTraits(Image *image,const PixelTrait traits)
+{
+  image->channel_map[YPixelChannel].traits=traits;
+}
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/pixel.h

@@ -0,0 +1,261 @@
+/*
+  Copyright 1999-2017 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://www.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 pixel methods.
+*/
+#ifndef MAGICKCORE_PIXEL_H
+#define MAGICKCORE_PIXEL_H
+
+#include "MagickCore/colorspace.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#define MaxPixelChannels  32
+#undef index
+
+/*
+  Pixel enum declarations.
+*/
+typedef enum
+{
+  UndefinedChannel = 0x0000,
+  RedChannel = 0x0001,
+  GrayChannel = 0x0001,
+  CyanChannel = 0x0001,
+  GreenChannel = 0x0002,
+  MagentaChannel = 0x0002,
+  BlueChannel = 0x0004,
+  YellowChannel = 0x0004,
+  BlackChannel = 0x0008,
+  AlphaChannel = 0x0010,
+  OpacityChannel = 0x0010,
+  IndexChannel = 0x0020,             /* Color Index Table? */
+  ReadMaskChannel = 0x0040,          /* Pixel is Not Readable? */
+  WriteMaskChannel = 0x0080,         /* Pixel is Write Protected? */
+  MetaChannel = 0x0100,              /* ???? */
+  CompositeChannels = 0x001F,
+  AllChannels = 0x7ffffff,
+  /*
+    Special purpose channel types.
+    FUTURE: are these needed any more - they are more like hacks
+    SyncChannels for example is NOT a real channel but a 'flag'
+    It really says -- "User has not defined channels"
+    Though it does have extra meaning in the "-auto-level" operator
+  */
+  TrueAlphaChannel = 0x0100, /* extract actual alpha channel from opacity */
+  RGBChannels = 0x0200,      /* set alpha from grayscale mask in RGB */
+  GrayChannels = 0x0400,
+  SyncChannels = 0x20000,    /* channels modified as a single unit */
+  DefaultChannels = AllChannels
+} ChannelType;  /* must correspond to PixelChannel */
+
+typedef enum
+{
+  UndefinedPixelChannel = 0,
+  RedPixelChannel = 0,
+  CyanPixelChannel = 0,
+  GrayPixelChannel = 0,
+  LPixelChannel = 0,
+  LabelPixelChannel = 0,
+  YPixelChannel = 0,
+  aPixelChannel = 1,
+  GreenPixelChannel = 1,
+  MagentaPixelChannel = 1,
+  CbPixelChannel = 1,
+  bPixelChannel = 2,
+  BluePixelChannel = 2,
+  YellowPixelChannel = 2,
+  CrPixelChannel = 2,
+  BlackPixelChannel = 3,
+  AlphaPixelChannel = 4,
+  IndexPixelChannel = 5,
+  ReadMaskPixelChannel = 6,
+  WriteMaskPixelChannel = 7,
+  MetaPixelChannel = 8,
+  IntensityPixelChannel = MaxPixelChannels,  /* ???? */
+  CompositePixelChannel = MaxPixelChannels,  /* ???? */
+  SyncPixelChannel = MaxPixelChannels+1      /* not a real channel */
+} PixelChannel;  /* must correspond to ChannelType */
+
+typedef enum
+{
+  UndefinedPixelIntensityMethod = 0,
+  AveragePixelIntensityMethod,
+  BrightnessPixelIntensityMethod,
+  LightnessPixelIntensityMethod,
+  MSPixelIntensityMethod,
+  Rec601LumaPixelIntensityMethod,
+  Rec601LuminancePixelIntensityMethod,
+  Rec709LumaPixelIntensityMethod,
+  Rec709LuminancePixelIntensityMethod,
+  RMSPixelIntensityMethod
+} PixelIntensityMethod;
+
+typedef enum
+{
+  UndefinedInterpolatePixel,
+  AverageInterpolatePixel,    /* Average 4 nearest neighbours */
+  Average9InterpolatePixel,   /* Average 9 nearest neighbours */
+  Average16InterpolatePixel,  /* Average 16 nearest neighbours */
+  BackgroundInterpolatePixel, /* Just return background color */
+  BilinearInterpolatePixel,   /* Triangular filter interpolation */
+  BlendInterpolatePixel,      /* blend of nearest 1, 2 or 4 pixels */
+  CatromInterpolatePixel,     /* Catmull-Rom interpolation */
+  IntegerInterpolatePixel,    /* Integer (floor) interpolation */
+  MeshInterpolatePixel,       /* Triangular Mesh interpolation */
+  NearestInterpolatePixel,    /* Nearest Neighbour Only */
+  SplineInterpolatePixel      /* Cubic Spline (blurred) interpolation */
+  /* FilterInterpolatePixel,  ** Use resize filter - (very slow) */
+} PixelInterpolateMethod;
+
+typedef enum
+{
+  UndefinedPixelMask = 0x000000,
+  ReadPixelMask = 0x000001,
+  WritePixelMask = 0x000002
+} PixelMask;
+
+typedef enum
+{
+  UndefinedPixelTrait = 0x000000,
+  CopyPixelTrait = 0x000001,
+  UpdatePixelTrait = 0x000002,
+  BlendPixelTrait = 0x000004
+} PixelTrait;
+
+typedef enum
+{
+  UndefinedPixel,
+  CharPixel,
+  DoublePixel,
+  FloatPixel,
+  LongPixel,
+  LongLongPixel,
+  QuantumPixel,
+  ShortPixel
+} StorageType;
+
+/*
+  Pixel typedef declarations.
+*/
+typedef struct _PixelChannelMap
+{
+  PixelChannel
+    channel;
+
+  PixelTrait
+    traits;
+
+  ssize_t
+    offset;
+} PixelChannelMap;
+
+typedef struct _PixelInfo
+{
+  ClassType
+    storage_class;
+
+  ColorspaceType
+    colorspace;
+
+  PixelTrait
+    alpha_trait;
+
+  double
+    fuzz;
+
+  size_t
+    depth;
+
+  MagickSizeType
+    count;
+
+  MagickRealType
+    red,
+    green,
+    blue,
+    black,
+    alpha,
+    index;
+} PixelInfo;
+
+typedef struct _PixelPacket
+{
+  unsigned int
+    red,
+    green,
+    blue,
+    alpha,
+    black;
+} PixelPacket;
+
+typedef struct _CacheView
+  CacheView_;
+
+/*
+  Pixel method declarations.
+*/
+extern MagickExport ChannelType
+  SetPixelChannelMask(Image *,const ChannelType);
+
+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 *,ExceptionInfo *),
+  InterpolatePixelChannel(const Image *,const CacheView_ *,
+    const PixelChannel,const PixelInterpolateMethod,const double,const double,
+    double *,ExceptionInfo *),
+  InterpolatePixelChannels(const Image *,const CacheView_ *,const Image *,
+    const PixelInterpolateMethod,const double,const double,Quantum *,
+    ExceptionInfo *),
+  InterpolatePixelInfo(const Image *,const CacheView_ *,
+    const PixelInterpolateMethod,const double,const double,PixelInfo *,
+    ExceptionInfo *),
+  IsFuzzyEquivalencePixel(const Image *,const Quantum *,const Image *,
+    const Quantum *),
+  IsFuzzyEquivalencePixelInfo(const PixelInfo *,const PixelInfo *),
+  SetPixelMetaChannels(Image *,const size_t,ExceptionInfo *);
+
+extern MagickExport MagickRealType
+  GetPixelInfoIntensity(const Image *magick_restrict,
+    const PixelInfo *magick_restrict) magick_hot_spot,
+  GetPixelIntensity(const Image *magick_restrict,
+    const Quantum *magick_restrict) magick_hot_spot;
+
+extern MagickExport PixelChannelMap
+  *AcquirePixelChannelMap(void),
+  *ClonePixelChannelMap(PixelChannelMap *),
+  *DestroyPixelChannelMap(PixelChannelMap *);
+
+extern MagickExport PixelInfo
+  *ClonePixelInfo(const PixelInfo *);
+
+extern MagickExport MagickRealType
+  DecodePixelGamma(const MagickRealType) magick_hot_spot,
+  EncodePixelGamma(const MagickRealType) magick_hot_spot;
+
+extern MagickExport void
+  ConformPixelInfo(Image *,const PixelInfo *,PixelInfo *,ExceptionInfo *),
+  GetPixelInfo(const Image *,PixelInfo *),
+  InitializePixelChannelMap(Image *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/policy.h

@@ -0,0 +1,68 @@
+/*
+  Copyright 1999-2017 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://www.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_POLICY_H
+#define MAGICKCORE_POLICY_H
+
+#include "MagickCore/pixel.h"
+#include "MagickCore/exception.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  UndefinedPolicyDomain,
+  CoderPolicyDomain,
+  DelegatePolicyDomain,
+  FilterPolicyDomain,
+  PathPolicyDomain,
+  ResourcePolicyDomain,
+  SystemPolicyDomain,
+  CachePolicyDomain
+} 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 *),
+  **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 *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/prepress.h

@@ -0,0 +1,32 @@
+/*
+  Copyright 1999-2017 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://www.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,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/profile.h

@@ -0,0 +1,61 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/string_.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef struct _ProfileInfo
+  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,ExceptionInfo *),
+  SetImageProfile(Image *,const char *,const StringInfo *,ExceptionInfo *);
+
+extern MagickExport StringInfo
+  *RemoveImageProfile(Image *,const char *);
+
+extern MagickExport void
+  DestroyImageProfiles(Image *),
+  ResetImageProfileIterator(const Image *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif 
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/property.h

@@ -0,0 +1,51 @@
+/*
+  Copyright 1999-2017 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://www.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
+  *InterpretImageProperties(ImageInfo *,Image *,const char *,
+    ExceptionInfo *),
+  *RemoveImageProperty(Image *,const char *);
+
+extern MagickExport const char
+  *GetNextImageProperty(const Image *),
+  *GetImageProperty(const Image *,const char *,ExceptionInfo *),
+  *GetMagickProperty(ImageInfo *,Image *,const char *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  CloneImageProperties(Image *,const Image *),
+  DefineImageProperty(Image *,const char *,ExceptionInfo *),
+  DeleteImageProperty(Image *,const char *),
+  FormatImageProperty(Image *,const char *,const char *,...)
+    magick_attribute((__format__ (__printf__,3,4))),
+  SetImageProperty(Image *,const char *,const char *,ExceptionInfo *);
+
+extern MagickExport void
+  DestroyImageProperties(Image *),
+  ResetImagePropertyIterator(const Image *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/quantize.h

@@ -0,0 +1,77 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/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;     /* desired maximum number of colors */
+
+  size_t
+    tree_depth;
+
+  ColorspaceType
+    colorspace;
+
+  DitherMethod
+    dither_method;
+
+  MagickBooleanType
+    measure_error;
+
+  size_t
+    signature;
+} QuantizeInfo;
+
+extern MagickExport MagickBooleanType
+  CompressImageColormap(Image *,ExceptionInfo *),
+  GetImageQuantizeError(Image *,ExceptionInfo *),
+  PosterizeImage(Image *,const size_t,const DitherMethod,ExceptionInfo *),
+  QuantizeImage(const QuantizeInfo *,Image *,ExceptionInfo *),
+  QuantizeImages(const QuantizeInfo *,Image *,ExceptionInfo *),
+  RemapImage(const QuantizeInfo *,Image *,const Image *,ExceptionInfo *),
+  RemapImages(const QuantizeInfo *,Image *,const Image *,ExceptionInfo *);
+
+extern MagickExport QuantizeInfo
+  *AcquireQuantizeInfo(const ImageInfo *),
+  *CloneQuantizeInfo(const QuantizeInfo *),
+  *DestroyQuantizeInfo(QuantizeInfo *);
+
+extern MagickExport void
+  GetQuantizeInfo(QuantizeInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/quantum.h

@@ -0,0 +1,194 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/image.h"
+#include "MagickCore/semaphore.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum
+{
+  UndefinedEndian,
+  LSBEndian,
+  MSBEndian
+} EndianType;
+
+typedef enum
+{
+  UndefinedQuantumAlpha,
+  AssociatedQuantumAlpha,
+  DisassociatedQuantumAlpha
+} QuantumAlphaType;
+
+typedef enum
+{
+  UndefinedQuantumFormat,
+  FloatingPointQuantumFormat,
+  SignedQuantumFormat,
+  UnsignedQuantumFormat
+} QuantumFormatType;
+
+typedef enum
+{
+  UndefinedQuantum,
+  AlphaQuantum,
+  BGRAQuantum,
+  BGROQuantum,
+  BGRQuantum,
+  BlackQuantum,
+  BlueQuantum,
+  CbYCrAQuantum,
+  CbYCrQuantum,
+  CbYCrYQuantum,
+  CMYKAQuantum,
+  CMYKOQuantum,
+  CMYKQuantum,
+  CyanQuantum,
+  GrayAlphaQuantum,
+  GrayQuantum,
+  GreenQuantum,
+  IndexAlphaQuantum,
+  IndexQuantum,
+  MagentaQuantum,
+  OpacityQuantum,
+  RedQuantum,
+  RGBAQuantum,
+  RGBOQuantum,
+  RGBPadQuantum,
+  RGBQuantum,
+  YellowQuantum
+} QuantumType;
+
+typedef struct _QuantumInfo
+  QuantumInfo;
+
+static inline Quantum ClampToQuantum(const MagickRealType value)
+{
+#if defined(MAGICKCORE_HDRI_SUPPORT)
+  return((Quantum) value);
+#else
+  if (value <= 0.0f)
+    return((Quantum) 0);
+  if (value >= (MagickRealType) QuantumRange)
+    return(QuantumRange);
+  return((Quantum) (value+0.5f));
+#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 (quantum <= 0.0)
+    return(0);
+  if (quantum >= 255.0)
+    return(255);
+  return((unsigned char) (quantum+0.5));
+#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 (quantum <= 0.0)
+    return(0);
+  if ((quantum/257.0) >= 255.0)
+    return(255);
+  return((unsigned char) (quantum/257.0+0.5));
+#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 (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 (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 *,CacheView *,QuantumInfo *,const QuantumType,
+    unsigned char *magick_restrict,ExceptionInfo *),
+  GetQuantumExtent(const Image *,const QuantumInfo *,const QuantumType),
+  ImportQuantumPixels(const Image *,CacheView *,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

bin/7.0.5-5/include/ImageMagick-7/MagickCore/random_.h

@@ -0,0 +1,59 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/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 *);
+
+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
+  SetRandomKey(RandomInfo *,const size_t,unsigned char *),
+  SetRandomSecretKey(const unsigned long),
+  SetRandomTrueRandom(const MagickBooleanType);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/registry.h

@@ -0,0 +1,51 @@
+/*
+  Copyright 1999-2017 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://www.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 *),
+  SetImageRegistry(const RegistryType,const char *,const void *,
+    ExceptionInfo *);
+
+extern MagickExport void
+  *GetImageRegistry(const RegistryType,const char *,ExceptionInfo *),
+  *RemoveImageRegistry(const char *),
+  ResetImageRegistryIterator(void);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/resample.h

@@ -0,0 +1,103 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/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,
+  HannFilter,
+  HammingFilter,
+  BlackmanFilter,
+  GaussianFilter,
+  QuadraticFilter,
+  CubicFilter,
+  CatromFilter,
+  MitchellFilter,
+  JincFilter,
+  SincFilter,
+  SincFastFilter,
+  KaiserFilter,
+  WelchFilter,
+  ParzenFilter,
+  BohmanFilter,
+  BartlettFilter,
+  LagrangeFilter,
+  LanczosFilter,
+  LanczosSharpFilter,
+  Lanczos2Filter,
+  Lanczos2SharpFilter,
+  RobidouxFilter,
+  RobidouxSharpFilter,
+  CosineFilter,
+  SplineFilter,
+  LanczosRadiusFilter,
+  SentinelFilter  /* a count of all the filters, not a real filter */
+} FilterType;
+
+/*
+  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.
+
+  also miss-spellings of common filters
+*/
+#define BesselFilter  JincFilter
+#define WelshFilter   WelchFilter
+#define HanningFilter HannFilter
+
+typedef struct _ResampleFilter
+  ResampleFilter;
+
+extern MagickExport MagickBooleanType
+  ResamplePixelColor(ResampleFilter *,const double,const double,
+    PixelInfo *,ExceptionInfo *),
+  SetResampleFilterInterpolateMethod(ResampleFilter *,
+    const PixelInterpolateMethod),
+  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 FilterType);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/resize.h

@@ -0,0 +1,48 @@
+/*
+  Copyright 1999-2017 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://www.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 PixelInterpolateMethod,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 FilterType,
+    ExceptionInfo *),
+  *ResizeImage(const Image *,const size_t,const size_t,const FilterType,
+    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

bin/7.0.5-5/include/ImageMagick-7/MagickCore/resource_.h

@@ -0,0 +1,63 @@
+/*
+  Copyright 1999-2017 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://www.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,
+  HeightResource,
+  MapResource,
+  MemoryResource,
+  ThreadResource,
+  ThrottleResource,
+  TimeResource,
+  WidthResource
+} ResourceType;
+
+#define MagickResourceInfinity  MagickULLConstant(~0)
+
+extern MagickExport int
+  AcquireUniqueFileResource(char *);
+
+extern MagickExport MagickBooleanType
+  AcquireMagickResource(const ResourceType,const MagickSizeType),
+  GetPathTemplate(char *),
+  ListMagickResourceInfo(FILE *,ExceptionInfo *),
+  RelinquishUniqueFileResource(const char *),
+  SetMagickResourceLimit(const ResourceType,const MagickSizeType);
+
+extern MagickExport MagickSizeType
+  GetMagickResource(const ResourceType),
+  GetMagickResourceLimit(const ResourceType);
+
+extern MagickExport void
+  RelinquishMagickResource(const ResourceType,const MagickSizeType);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/segment.h

@@ -0,0 +1,35 @@
+/*
+  Copyright 1999-2017 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://www.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,
+    PixelInfo *,ExceptionInfo *),
+  SegmentImage(Image *,const ColorspaceType,const MagickBooleanType,
+    const double,const double,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/semaphore.h

@@ -0,0 +1,41 @@
+/*
+  Copyright 1999-2017 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://www.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 SemaphoreInfo
+  *AcquireSemaphoreInfo(void);
+
+extern MagickExport void
+  ActivateSemaphoreInfo(SemaphoreInfo **),
+  LockSemaphoreInfo(SemaphoreInfo *),
+  RelinquishSemaphoreInfo(SemaphoreInfo **),
+  UnlockSemaphoreInfo(SemaphoreInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/shear.h

@@ -0,0 +1,35 @@
+/*
+  Copyright 1999-2017 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://www.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

bin/7.0.5-5/include/ImageMagick-7/MagickCore/signature.h

@@ -0,0 +1,32 @@
+/*
+  Copyright 1999-2017 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://www.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 *,ExceptionInfo *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/splay-tree.h

@@ -0,0 +1,61 @@
+/*
+  Copyright 1999-2017 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://www.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 *),
+  *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

bin/7.0.5-5/include/ImageMagick-7/MagickCore/statistic.h

@@ -0,0 +1,174 @@
+/*
+  Copyright 1999-2017 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://www.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
+
+#define MaximumNumberOfImageMoments  8
+#define MaximumNumberOfPerceptualColorspaces  6
+#define MaximumNumberOfPerceptualHashes  7
+
+typedef struct _ChannelStatistics
+{
+  size_t
+    depth;
+
+  double
+    area,
+    minima,
+    maxima,
+    sum,
+    sum_squared,
+    sum_cubed,
+    sum_fourth_power,
+    mean,
+    variance,
+    standard_deviation,
+    kurtosis,
+    skewness,
+    entropy;
+} ChannelStatistics;
+
+typedef struct _ChannelMoments
+{
+  double
+    invariant[MaximumNumberOfImageMoments+1];
+
+  PointInfo
+    centroid,
+    ellipse_axis;
+
+  double
+    ellipse_angle,
+    ellipse_eccentricity,
+    ellipse_intensity;
+} ChannelMoments;
+
+typedef struct _ChannelPerceptualHash
+{
+  double
+    srgb_hu_phash[MaximumNumberOfImageMoments+1],
+    hclp_hu_phash[MaximumNumberOfImageMoments+1];
+
+  size_t
+    number_colorspaces;
+
+  ColorspaceType
+    colorspace[MaximumNumberOfPerceptualColorspaces+1];
+
+  double
+    phash[MaximumNumberOfPerceptualColorspaces+1][MaximumNumberOfImageMoments+1];
+
+  size_t
+    number_channels;
+} ChannelPerceptualHash;
+
+typedef enum
+{
+  UndefinedEvaluateOperator,
+  AbsEvaluateOperator,
+  AddEvaluateOperator,
+  AddModulusEvaluateOperator,
+  AndEvaluateOperator,
+  CosineEvaluateOperator,
+  DivideEvaluateOperator,
+  ExponentialEvaluateOperator,
+  GaussianNoiseEvaluateOperator,
+  ImpulseNoiseEvaluateOperator,
+  LaplacianNoiseEvaluateOperator,
+  LeftShiftEvaluateOperator,
+  LogEvaluateOperator,
+  MaxEvaluateOperator,
+  MeanEvaluateOperator,
+  MedianEvaluateOperator,
+  MinEvaluateOperator,
+  MultiplicativeNoiseEvaluateOperator,
+  MultiplyEvaluateOperator,
+  OrEvaluateOperator,
+  PoissonNoiseEvaluateOperator,
+  PowEvaluateOperator,
+  RightShiftEvaluateOperator,
+  RootMeanSquareEvaluateOperator,
+  SetEvaluateOperator,
+  SineEvaluateOperator,
+  SubtractEvaluateOperator,
+  SumEvaluateOperator,
+  ThresholdBlackEvaluateOperator,
+  ThresholdEvaluateOperator,
+  ThresholdWhiteEvaluateOperator,
+  UniformNoiseEvaluateOperator,
+  XorEvaluateOperator
+} MagickEvaluateOperator;
+
+typedef enum
+{
+  UndefinedFunction,
+  ArcsinFunction,
+  ArctanFunction,
+  PolynomialFunction,
+  SinusoidFunction
+} MagickFunction;
+
+typedef enum
+{
+  UndefinedStatistic,
+  GradientStatistic,
+  MaximumStatistic,
+  MeanStatistic,
+  MedianStatistic,
+  MinimumStatistic,
+  ModeStatistic,
+  NonpeakStatistic,
+  RootMeanSquareStatistic,
+  StandardDeviationStatistic
+} StatisticType;
+
+extern MagickExport ChannelStatistics
+  *GetImageStatistics(const Image *,ExceptionInfo *);
+
+extern MagickExport ChannelMoments
+  *GetImageMoments(const Image *,ExceptionInfo *);
+
+extern MagickExport ChannelPerceptualHash
+  *GetImagePerceptualHash(const Image *,ExceptionInfo *);
+
+extern MagickExport Image
+  *EvaluateImages(const Image *,const MagickEvaluateOperator,ExceptionInfo *),
+  *PolynomialImage(const Image *,const size_t,const double *,ExceptionInfo *),
+  *StatisticImage(const Image *,const StatisticType,const size_t,const size_t,
+    ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  EvaluateImage(Image *,const MagickEvaluateOperator,const double,
+    ExceptionInfo *),
+  FunctionImage(Image *,const MagickFunction,const size_t,const 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

bin/7.0.5-5/include/ImageMagick-7/MagickCore/stream.h

@@ -0,0 +1,53 @@
+/*
+  Copyright 1999-2017 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://www.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
+
+#include "MagickCore/pixel.h"
+
+typedef struct _StreamInfo
+  StreamInfo;
+
+typedef size_t
+  (*StreamHandler)(const Image *,const void *,const size_t);
+
+extern MagickExport Image
+  *ReadStream(const ImageInfo *,StreamHandler,ExceptionInfo *),
+  *StreamImage(const ImageInfo *,StreamInfo *,ExceptionInfo *);
+
+extern MagickExport MagickBooleanType
+  OpenStream(const ImageInfo *,StreamInfo *,const char *,ExceptionInfo *),
+  WriteStream(const ImageInfo *,Image *,StreamHandler,ExceptionInfo *);
+
+extern MagickExport StreamInfo
+  *AcquireStreamInfo(const ImageInfo *,ExceptionInfo *),
+  *DestroyStreamInfo(StreamInfo *);
+
+extern MagickExport void
+  SetStreamInfoMap(StreamInfo *,const char *),
+  SetStreamInfoStorageType(StreamInfo *,const StorageType);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/string_.h

@@ -0,0 +1,112 @@
+/*
+  Copyright 1999-2017 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://www.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 "MagickCore/exception.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef struct _StringInfo
+{
+  char
+    *path;
+
+  unsigned char
+    *datum;
+
+  size_t
+    length,
+    signature;
+} 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 *);
+
+extern MagickExport const char
+  *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 **,const char *),
+  IsStringTrue(const char *),
+  IsStringFalse(const char *),
+  SubstituteString(char **,const char *,const char *);
+
+extern MagickExport size_t
+  ConcatenateMagickString(char *,const char *,const size_t)
+    magick_attribute((__nonnull__)),
+  CopyMagickString(char *,const char *,const size_t)
+    magick_attribute((__nonnull__)),
+  GetStringInfoLength(const StringInfo *);
+
+extern MagickExport ssize_t
+  FormatMagickSize(const MagickSizeType,const MagickBooleanType,const char *,
+    const size_t,char *),
+  FormatMagickTime(const time_t,const size_t,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),
+  SetStringInfoPath(StringInfo *,const char *),
+  StripString(char *);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif

bin/7.0.5-5/include/ImageMagick-7/MagickCore/studio.h

@@ -0,0 +1,353 @@
+/*
+  Copyright 1999-2017 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://www.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
+#include "MagickCore/magick-config.h"
+# 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 "MagickCore/methods.h"
+#endif
+
+#if !defined(const)
+#  define STDC
+#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>
+# include <direct.h>
+# 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>
+#elif defined(MAGICKCORE_WINDOWS_SUPPORT)
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+#pragma comment (lib, "ws2_32.lib")
+#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__OPENCL)
+#if defined(MAGICKCORE_HAVE_CL_CL_H)
+#  include <CL/cl.h>
+#endif
+#if defined(MAGICKCORE_HAVE_OPENCL_CL_H)
+#  include <OpenCL/cl.h>
+#endif
+#  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 "MagickCore/method-attribute.h"
+
+#if defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(MAGICKCORE_POSIX_SUPPORT)
+# include <sys/types.h>
+# include <sys/stat.h>
+# if defined(MAGICKCORE_HAVE_SYS_TIMEB_H)
+# include <sys/timeb.h>
+# endif
+# 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 "MagickCore/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
+#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 "MagickCore/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 "MagickCore/nt-base.h"
+#endif
+#ifdef __VMS
+# include "MagickCore/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
+# ifdef __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_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(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 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