diff --git a/bin/7.0.5-5/bin/Magick++-config b/bin/7.0.5-5/bin/Magick++-config new file mode 100755 index 0000000..629926c --- /dev/null +++ b/bin/7.0.5-5/bin/Magick++-config @@ -0,0 +1,65 @@ +#!/bin/sh +# +# Configure options script for re-calling Magick+ compilation options +# required to use the Magick++ library. +# +# + +prefix=/Users/johannespichler/Downloads/newTest/build +exec_prefix=${prefix} + +usage='Usage: Magick++-config [--cppflags] [--cxxflags] [--exec-prefix] [--ldflags] [--libs] [--prefix] [--version] + + For example, "magick.cpp" may be compiled to produce "magick" as follows: + + "c++ -o magick magick.cpp `Magick++-config --cppflags --cxxflags --ldflags --libs`"' + +if test $# -eq 0; then + echo "${usage}" 1>&2 + exit 1 +fi + +while test $# -gt 0; do + case "$1" in + -*=*) optarg=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'` ;; + *) optarg= ;; + esac + case $1 in + --prefix=*) + prefix=$optarg + ;; + --prefix) + echo $prefix + ;; + --exec-prefix=*) + exec_prefix=$optarg + ;; + --exec-prefix) + echo $exec_prefix + ;; + --version) + echo '7.0.5 Q16 HDRI' + ;; + --cflags) + pkg-config --cflags Magick++ + ;; + --cxxflags) + pkg-config --cflags Magick++ + ;; + --cppflags) + pkg-config --cflags Magick++ + ;; + --ldflags) + pkg-config --libs Magick++ + ;; + --libs) + pkg-config --libs Magick++ + ;; + *) + echo "${usage}" 1>&2 + exit 1 + ;; + esac + shift +done + diff --git a/bin/7.0.5-5/bin/MagickCore-config b/bin/7.0.5-5/bin/MagickCore-config new file mode 100755 index 0000000..419a62f --- /dev/null +++ b/bin/7.0.5-5/bin/MagickCore-config @@ -0,0 +1,67 @@ +#!/bin/sh +# +# Configure options script for re-calling MagickCore compilation options +# required to use the MagickCore library. +# + +prefix=/Users/johannespichler/Downloads/newTest/build +exec_prefix=${prefix} + +usage="\ +Usage: MagickCore-config [--cflags] [--cppflags] [--exec-prefix] [--ldflags] [--libs] [--prefix] [--version]" + +if test $# -eq 0; then + echo "${usage}" 1>&2 + echo "Example: gcc \`MagickCore-config --cflags --cppflags\` -o core core.c \`Magick-config --ldflags --libs\`" 1>&2 + exit 1 +fi + +while test $# -gt 0; do + case "$1" in + -*=*) optarg=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'` ;; + *) optarg= ;; + esac + case $1 in + --prefix=*) + prefix=$optarg + ;; + --prefix) + echo $prefix + ;; + --exec-prefix=*) + exec_prefix=$optarg + ;; + --exec-prefix) + echo $exec_prefix + ;; + --version) + echo '7.0.5 Q16 HDRI' + ;; + --cflags) + pkg-config --cflags MagickCore + ;; + --cxxflags) + pkg-config --cflags MagickCore + ;; + --cppflags) + pkg-config --cflags MagickCore + ;; + --ldflags) + pkg-config --libs MagickCore + ;; + --libs) + pkg-config --libs MagickCore + ;; + --coder-path) + echo "/Users/johannespichler/Downloads/newTest/build/lib/ImageMagick-7.0.5/modules-Q16HDRI/coders" + ;; + --filter-path) + echo "/Users/johannespichler/Downloads/newTest/build/lib/ImageMagick-7.0.5/modules-Q16HDRI/filters" + ;; + *) + echo "${usage}" 1>&2 + exit 1 + ;; + esac + shift +done diff --git a/bin/7.0.5-5/bin/MagickWand-config b/bin/7.0.5-5/bin/MagickWand-config new file mode 100755 index 0000000..d65d987 --- /dev/null +++ b/bin/7.0.5-5/bin/MagickWand-config @@ -0,0 +1,62 @@ +#!/bin/sh +# +# Configure options script for re-calling MagickWand compilation options +# required to use the MagickWand library. +# + +prefix=/Users/johannespichler/Downloads/newTest/build +exec_prefix=${prefix} + +usage="\ +Usage: MagickWand-config [--cflags] [--cppflags] [--exec-prefix] [--ldflags] [--libs] [--prefix] [--version]" + +if test $# -eq 0; then + echo "${usage}" 1>&2 + echo "Example: gcc \`MagickWand-config --cflags --cppflags\` -o wand wand.c \`MagickWand-config --ldflags --libs\`" 1>&2 + exit 1 +fi + +while test $# -gt 0; do + case "$1" in + -*=*) optarg=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'` ;; + *) optarg= ;; + esac + case $1 in + --prefix=*) + prefix=$optarg + ;; + --prefix) + echo $prefix + ;; + --exec-prefix=*) + exec_prefix=$optarg + ;; + --exec-prefix) + echo $exec_prefix + ;; + --version) + echo '7.0.5 Q16 HDRI' + ;; + --cflags) + pkg-config --cflags MagickWand + ;; + --cxxflags) + pkg-config --cflags MagickWand + ;; + --cppflags) + pkg-config --cflags MagickWand + ;; + --ldflags) + pkg-config --libs MagickWand + ;; + --libs) + pkg-config --libs MagickWand + ;; + *) + echo "${usage}" 1>&2 + exit 1 + ;; + esac + shift +done + diff --git a/bin/7.0.5-5/bin/animate b/bin/7.0.5-5/bin/animate new file mode 120000 index 0000000..2e00264 --- /dev/null +++ b/bin/7.0.5-5/bin/animate @@ -0,0 +1 @@ +magick \ No newline at end of file diff --git a/bin/7.0.5-5/bin/compare b/bin/7.0.5-5/bin/compare new file mode 120000 index 0000000..2e00264 --- /dev/null +++ b/bin/7.0.5-5/bin/compare @@ -0,0 +1 @@ +magick \ No newline at end of file diff --git a/bin/7.0.5-5/bin/composite b/bin/7.0.5-5/bin/composite new file mode 120000 index 0000000..2e00264 --- /dev/null +++ b/bin/7.0.5-5/bin/composite @@ -0,0 +1 @@ +magick \ No newline at end of file diff --git a/bin/7.0.5-5/bin/conjure b/bin/7.0.5-5/bin/conjure new file mode 120000 index 0000000..2e00264 --- /dev/null +++ b/bin/7.0.5-5/bin/conjure @@ -0,0 +1 @@ +magick \ No newline at end of file diff --git a/bin/7.0.5-5/bin/convert b/bin/7.0.5-5/bin/convert new file mode 120000 index 0000000..2e00264 --- /dev/null +++ b/bin/7.0.5-5/bin/convert @@ -0,0 +1 @@ +magick \ No newline at end of file diff --git a/bin/7.0.5-5/bin/display b/bin/7.0.5-5/bin/display new file mode 120000 index 0000000..2e00264 --- /dev/null +++ b/bin/7.0.5-5/bin/display @@ -0,0 +1 @@ +magick \ No newline at end of file diff --git a/bin/7.0.5-5/bin/identify b/bin/7.0.5-5/bin/identify new file mode 120000 index 0000000..2e00264 --- /dev/null +++ b/bin/7.0.5-5/bin/identify @@ -0,0 +1 @@ +magick \ No newline at end of file diff --git a/bin/7.0.5-5/bin/import b/bin/7.0.5-5/bin/import new file mode 120000 index 0000000..2e00264 --- /dev/null +++ b/bin/7.0.5-5/bin/import @@ -0,0 +1 @@ +magick \ No newline at end of file diff --git a/bin/7.0.5-5/bin/magick b/bin/7.0.5-5/bin/magick new file mode 100755 index 0000000..87dcca3 Binary files /dev/null and b/bin/7.0.5-5/bin/magick differ diff --git a/bin/7.0.5-5/bin/magick-script b/bin/7.0.5-5/bin/magick-script new file mode 120000 index 0000000..2e00264 --- /dev/null +++ b/bin/7.0.5-5/bin/magick-script @@ -0,0 +1 @@ +magick \ No newline at end of file diff --git a/bin/7.0.5-5/bin/mogrify b/bin/7.0.5-5/bin/mogrify new file mode 120000 index 0000000..2e00264 --- /dev/null +++ b/bin/7.0.5-5/bin/mogrify @@ -0,0 +1 @@ +magick \ No newline at end of file diff --git a/bin/7.0.5-5/bin/montage b/bin/7.0.5-5/bin/montage new file mode 120000 index 0000000..2e00264 --- /dev/null +++ b/bin/7.0.5-5/bin/montage @@ -0,0 +1 @@ +magick \ No newline at end of file diff --git a/bin/7.0.5-5/bin/stream b/bin/7.0.5-5/bin/stream new file mode 120000 index 0000000..2e00264 --- /dev/null +++ b/bin/7.0.5-5/bin/stream @@ -0,0 +1 @@ +magick \ No newline at end of file diff --git a/bin/7.0.5-5/etc/ImageMagick-7/coder.xml b/bin/7.0.5-5/etc/ImageMagick-7/coder.xml new file mode 100755 index 0000000..5c62cb4 --- /dev/null +++ b/bin/7.0.5-5/etc/ImageMagick-7/coder.xml @@ -0,0 +1,22 @@ + + + + + +]> + + + + + + diff --git a/bin/7.0.5-5/etc/ImageMagick-7/colors.xml b/bin/7.0.5-5/etc/ImageMagick-7/colors.xml new file mode 100755 index 0000000..55bfb5d --- /dev/null +++ b/bin/7.0.5-5/etc/ImageMagick-7/colors.xml @@ -0,0 +1,28 @@ + + + + + + +]> + + + + + + + + + + + + diff --git a/bin/7.0.5-5/etc/ImageMagick-7/delegates.xml b/bin/7.0.5-5/etc/ImageMagick-7/delegates.xml new file mode 100755 index 0000000..1c5f027 --- /dev/null +++ b/bin/7.0.5-5/etc/ImageMagick-7/delegates.xml @@ -0,0 +1,125 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/bin/7.0.5-5/etc/ImageMagick-7/log.xml b/bin/7.0.5-5/etc/ImageMagick-7/log.xml new file mode 100755 index 0000000..cdacdab --- /dev/null +++ b/bin/7.0.5-5/etc/ImageMagick-7/log.xml @@ -0,0 +1,40 @@ + + + + + + + + + +]> + + + + + + + + + diff --git a/bin/7.0.5-5/etc/ImageMagick-7/magic.xml b/bin/7.0.5-5/etc/ImageMagick-7/magic.xml new file mode 100755 index 0000000..7f17731 --- /dev/null +++ b/bin/7.0.5-5/etc/ImageMagick-7/magic.xml @@ -0,0 +1,23 @@ + + + + + + +]> + + + + + + + diff --git a/bin/7.0.5-5/etc/ImageMagick-7/mime.xml b/bin/7.0.5-5/etc/ImageMagick-7/mime.xml new file mode 100755 index 0000000..c1b61f4 --- /dev/null +++ b/bin/7.0.5-5/etc/ImageMagick-7/mime.xml @@ -0,0 +1,1142 @@ + + + + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/bin/7.0.5-5/etc/ImageMagick-7/policy.xml b/bin/7.0.5-5/etc/ImageMagick-7/policy.xml new file mode 100755 index 0000000..99cd252 --- /dev/null +++ b/bin/7.0.5-5/etc/ImageMagick-7/policy.xml @@ -0,0 +1,86 @@ + + + + + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/bin/7.0.5-5/etc/ImageMagick-7/quantization-table.xml b/bin/7.0.5-5/etc/ImageMagick-7/quantization-table.xml new file mode 100755 index 0000000..a05552b --- /dev/null +++ b/bin/7.0.5-5/etc/ImageMagick-7/quantization-table.xml @@ -0,0 +1,62 @@ + + + + + + + + + +]> + + + + Luma Quantization Table + + 16, 16, 16, 18, 25, 37, 56, 85, + 16, 17, 20, 27, 34, 40, 53, 75, + 16, 20, 24, 31, 43, 62, 91, 135, + 18, 27, 31, 40, 53, 74, 106, 156, + 25, 34, 43, 53, 69, 94, 131, 189, + 37, 40, 62, 74, 94, 124, 169, 238, + 56, 53, 91, 106, 131, 169, 226, 311, + 85, 75, 135, 156, 189, 238, 311, 418 + +
+ + + diff --git a/bin/7.0.5-5/etc/ImageMagick-7/thresholds.xml b/bin/7.0.5-5/etc/ImageMagick-7/thresholds.xml new file mode 100755 index 0000000..2ca2dab --- /dev/null +++ b/bin/7.0.5-5/etc/ImageMagick-7/thresholds.xml @@ -0,0 +1,334 @@ + + + + + + + + + +]> + + + + + + Threshold 1x1 (non-dither) + + 1 + + + + + Checkerboard 2x1 (dither) + + 1 2 + 2 1 + + + + + + Ordered 2x2 (dispersed) + + 1 3 + 4 2 + + + + + Ordered 3x3 (dispersed) + + 3 7 4 + 6 1 9 + 2 8 5 + + + + + + Ordered 4x4 (dispersed) + + 1 9 3 11 + 13 5 15 7 + 4 12 2 10 + 16 8 14 6 + + + + + + Ordered 8x8 (dispersed) + + 1 49 13 61 4 52 16 64 + 33 17 45 29 36 20 48 32 + 9 57 5 53 12 60 8 56 + 41 25 37 21 44 28 40 24 + 3 51 15 63 2 50 14 62 + 35 19 47 31 34 18 46 30 + 11 59 7 55 10 58 6 54 + 43 27 39 23 42 26 38 22 + + + + + + Halftone 4x4 (angled) + + 4 2 7 5 + 3 1 8 6 + 7 5 4 2 + 8 6 3 1 + + + + + Halftone 6x6 (angled) + + 14 13 10 8 2 3 + 16 18 12 7 1 4 + 15 17 11 9 6 5 + 8 2 3 14 13 10 + 7 1 4 16 18 12 + 9 6 5 15 17 11 + + + + + Halftone 8x8 (angled) + + 13 7 8 14 17 21 22 18 + 6 1 3 9 28 31 29 23 + 5 2 4 10 27 32 30 24 + 16 12 11 15 20 26 25 19 + 17 21 22 18 13 7 8 14 + 28 31 29 23 6 1 3 9 + 27 32 30 24 5 2 4 10 + 20 26 25 19 16 12 11 15 + + + + + + Halftone 4x4 (orthogonal) + + 7 13 11 4 + 12 16 14 8 + 10 15 6 2 + 5 9 3 1 + + + + + Halftone 6x6 (orthogonal) + + 7 17 27 14 9 4 + 21 29 33 31 18 11 + 24 32 36 34 25 22 + 19 30 35 28 20 10 + 8 15 26 16 6 2 + 5 13 23 12 3 1 + + + + + Halftone 8x8 (orthogonal) + + 7 21 33 43 36 19 9 4 + 16 27 51 55 49 29 14 11 + 31 47 57 61 59 45 35 23 + 41 53 60 64 62 52 40 38 + 37 44 58 63 56 46 30 22 + 15 28 48 54 50 26 17 10 + 8 18 34 42 32 20 6 2 + 5 13 25 39 24 12 3 1 + + + + + + Halftone 16x16 (orthogonal) + + 4 12 24 44 72 100 136 152 150 134 98 70 42 23 11 3 + 7 16 32 52 76 104 144 160 158 142 102 74 50 31 15 6 + 19 27 40 60 92 132 168 180 178 166 130 90 58 39 26 18 + 36 48 56 80 124 176 188 204 203 187 175 122 79 55 47 35 + 64 68 84 116 164 200 212 224 223 211 199 162 114 83 67 63 + 88 96 112 156 192 216 232 240 239 231 214 190 154 111 95 87 + 108 120 148 184 208 228 244 252 251 243 226 206 182 147 119 107 + 128 140 172 196 219 235 247 256 255 246 234 218 194 171 139 127 + 126 138 170 195 220 236 248 253 254 245 233 217 193 169 137 125 + 106 118 146 183 207 227 242 249 250 241 225 205 181 145 117 105 + 86 94 110 155 191 215 229 238 237 230 213 189 153 109 93 85 + 62 66 82 115 163 198 210 221 222 209 197 161 113 81 65 61 + 34 46 54 78 123 174 186 202 201 185 173 121 77 53 45 33 + 20 28 37 59 91 131 167 179 177 165 129 89 57 38 25 17 + 8 13 29 51 75 103 143 159 157 141 101 73 49 30 14 5 + 1 9 21 43 71 99 135 151 149 133 97 69 41 22 10 2 + + + + + + + Circles 5x5 (black) + + 1 21 16 15 4 + 5 17 20 19 14 + 6 21 25 24 12 + 7 18 22 23 11 + 2 8 9 10 3 + + + + + + Circles 5x5 (white) + + 25 21 10 11 22 + 20 9 6 7 12 + 19 5 1 2 13 + 18 8 4 3 14 + 24 17 16 15 23 + + + + + Circles 6x6 (black) + + 1 5 14 13 12 4 + 6 22 28 27 21 11 + 15 29 35 34 26 20 + 16 30 36 33 25 19 + 7 23 31 32 24 10 + 2 8 17 18 9 3 + + + + + Circles 6x6 (white) + + 36 32 23 24 25 33 + 31 15 9 10 16 26 + 22 8 2 3 11 17 + 21 7 1 4 12 18 + 30 14 6 5 13 27 + 35 29 20 19 28 34 + + + + + Circles 7x7 (black) + + 3 9 18 28 17 8 2 + 10 24 33 39 32 23 7 + 19 34 44 48 43 31 16 + 25 40 45 49 47 38 27 + 20 35 41 46 42 29 15 + 11 21 36 37 28 22 6 + 4 12 13 26 14 5 1 + + + + + + Circles 7x7 (white) + + 47 41 32 22 33 42 48 + 40 26 17 11 18 27 43 + 31 16 6 2 7 19 34 + 25 10 5 1 3 12 23 + 30 15 9 4 8 20 35 + 39 29 14 13 21 28 44 + 46 38 37 24 36 45 49 + + + + + + + diff --git a/bin/7.0.5-5/etc/ImageMagick-7/type-apple.xml b/bin/7.0.5-5/etc/ImageMagick-7/type-apple.xml new file mode 100755 index 0000000..8a92d4a --- /dev/null +++ b/bin/7.0.5-5/etc/ImageMagick-7/type-apple.xml @@ -0,0 +1,1371 @@ + + + + + + + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/bin/7.0.5-5/etc/ImageMagick-7/type-dejavu.xml b/bin/7.0.5-5/etc/ImageMagick-7/type-dejavu.xml new file mode 100755 index 0000000..0db1fc8 --- /dev/null +++ b/bin/7.0.5-5/etc/ImageMagick-7/type-dejavu.xml @@ -0,0 +1,62 @@ + + + + + + + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/bin/7.0.5-5/etc/ImageMagick-7/type-ghostscript.xml b/bin/7.0.5-5/etc/ImageMagick-7/type-ghostscript.xml new file mode 100755 index 0000000..4eadfc4 --- /dev/null +++ b/bin/7.0.5-5/etc/ImageMagick-7/type-ghostscript.xml @@ -0,0 +1,54 @@ + + + + + + + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/bin/7.0.5-5/etc/ImageMagick-7/type-windows.xml b/bin/7.0.5-5/etc/ImageMagick-7/type-windows.xml new file mode 100755 index 0000000..d6735e0 --- /dev/null +++ b/bin/7.0.5-5/etc/ImageMagick-7/type-windows.xml @@ -0,0 +1,102 @@ + + + + + + + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/bin/7.0.5-5/etc/ImageMagick-7/type.xml b/bin/7.0.5-5/etc/ImageMagick-7/type.xml new file mode 100755 index 0000000..052bbbd --- /dev/null +++ b/bin/7.0.5-5/etc/ImageMagick-7/type.xml @@ -0,0 +1,21 @@ + + + + + + + + + + + + + + + + +]> + + + diff --git a/bin/7.0.5-5/include/ImageMagick-7/Magick++.h b/bin/7.0.5-5/include/ImageMagick-7/Magick++.h new file mode 100755 index 0000000..40f24db --- /dev/null +++ b/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 +#include +#include +#include +#include +#include + +// 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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/Magick++/Blob.h b/bin/7.0.5-5/include/ImageMagick-7/Magick++/Blob.h new file mode 100755 index 0000000..68b54a8 --- /dev/null +++ b/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 + +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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/Magick++/CoderInfo.h b/bin/7.0.5-5/include/ImageMagick-7/Magick++/CoderInfo.h new file mode 100755 index 0000000..f860020 --- /dev/null +++ b/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 + +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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/Magick++/Color.h b/bin/7.0.5-5/include/ImageMagick-7/Magick++/Color.h new file mode 100755 index 0000000..c6b4446 --- /dev/null +++ b/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 + +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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/Magick++/Drawable.h b/bin/7.0.5-5/include/ImageMagick-7/Magick++/Drawable.h new file mode 100755 index 0000000..34e80d6 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/Magick++/Drawable.h @@ -0,0 +1,3138 @@ +// This may look like C code, but it is really -*- C++ -*- +// +// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002 +// Copyright Dirk Lemstra 2014-2017 +// +// Definition of Drawable (Graphic objects) +// +// The technique used for instantiating classes which derive from STL +// templates is described in Microsoft MSDN Article ID: Q168958 +// "HOWTO: Exporting STL Components Inside & Outside of a Class". +// "http://support.microsoft.com/kb/168958" +// +// Note that version 3.0 of this article says that that only STL +// container template which supports DLL export is and we are +// not using as part of the Drawable implementation. +// + +#if !defined(Magick_Drawable_header) +#define Magick_Drawable_header + +#include "Magick++/Include.h" + +#include +#include +#include +#include +#include "Magick++/Color.h" +#include "Magick++/Geometry.h" + +#if defined(MagickDLLExplicitTemplate) +# if defined(MAGICK_PLUSPLUS_IMPLEMENTATION) +# define MagickDrawableExtern +# else +# pragma warning( disable: 4231 ) // Disable warning regarding using extern +# define MagickDrawableExtern extern +# endif // MAGICK_PLUSPLUS_IMPLEMENTATION +#else +# define MagickDrawableExtern +#endif // MagickDLLExplicitTemplate + +namespace Magick +{ + // + // Representation of an x,y coordinate + // + class MagickPPExport Coordinate + { + public: + + Coordinate(void) + : _x(0), + _y(0) {} + + Coordinate(double x_,double y_) + : _x(x_), + _y(y_) {} + + virtual ~Coordinate() {} + + void x(double x_) { _x=x_; } + double x(void) const { return _x; } + + void y(double y_) { _y=y_; } + double y(void) const { return _y; } + + private: + double _x; + double _y; + }; + + typedef std::vector CoordinateList; + +#if defined(MagickDLLExplicitTemplate) + + MagickDrawableExtern template class MagickPPExport + std::allocator; + +#endif // MagickDLLExplicitTemplate + + // Compare two Coordinate objects regardless of LHS/RHS + extern MagickPPExport int operator == + (const Coordinate& left_,const Coordinate& right_); + extern MagickPPExport int operator != + (const Coordinate& left_, const Coordinate& right_); + extern MagickPPExport int operator > + (const Coordinate& left_, const Coordinate& right_); + extern MagickPPExport int operator < + (const Coordinate& left_, const Coordinate& right_); + extern MagickPPExport int operator >= + (const Coordinate& left_, const Coordinate& right_); + extern MagickPPExport int operator <= + (const Coordinate& left_, const Coordinate& right_); + + // + // Base class for all drawable objects + // + class MagickPPExport DrawableBase + { + public: + + // Default constructor + DrawableBase(void); + + // Destructor + virtual ~DrawableBase(void); + + // Operator to invoke equivalent draw API call + virtual void operator()(MagickCore::DrawingWand *) const; + + // Return polymorphic copy of object + virtual DrawableBase* copy() const; + }; + + // + // Representation of a drawable surrogate object to manage drawable objects + // + #undef Drawable // Conflict with + class MagickPPExport Drawable + { + public: + + // Default constructor + Drawable(void); + + // Construct from DrawableBase + Drawable(const DrawableBase& original_); + + // Destructor + ~Drawable(void); + + // Copy constructor + Drawable(const Drawable& original_); + + // Assignment operator + Drawable& operator=(const Drawable& original_); + + // Operator to invoke contained object + void operator()(MagickCore::DrawingWand *) const; + + private: + DrawableBase* dp; + }; + + typedef std::vector DrawableList; + +#if defined(MagickDLLExplicitTemplate) + + MagickDrawableExtern template class MagickPPExport + std::allocator; + +#endif // MagickDLLExplicitTemplate + +// +// Base class for all drawable path elements for use with +// DrawablePath +// +class MagickPPExport VPathBase +{ +public: + // Constructor + VPathBase ( void ) + { } + + // Destructor + virtual ~VPathBase ( void ); + + // Assignment operator + // const VPathBase& operator= (const VPathBase& original_ ); + + // Operator to invoke equivalent draw API call + virtual void operator()( MagickCore::DrawingWand *context_ ) const = 0; + + // Return polymorphic copy of object + virtual VPathBase* copy() const = 0; +}; + +// +// Representation of a drawable path element surrogate object to +// manage drawable path elements so they may be passed as a list to +// DrawablePath. +// +class MagickPPExport VPath +{ +public: + // Constructor + VPath ( void ); + + // Construct from VPathBase + VPath ( const VPathBase& original_ ); + + // Destructor + virtual ~VPath ( void ); + + // Copy constructor + VPath ( const VPath& original_ ); + + // Assignment operator + VPath& operator= (const VPath& original_ ); + + // Operator to invoke contained object + void operator()( MagickCore::DrawingWand *context_ ) const; + +private: + VPathBase* dp; +}; + +typedef std::vector VPathList; + +#if defined(MagickDLLExplicitTemplate) + +MagickDrawableExtern template class MagickPPExport +std::allocator; + +// MagickDrawableExtern template class MagickPPExport +// std::vector >; + +#endif // MagickDLLExplicitTemplate + +// +// Drawable Objects +// + +// Affine (scaling, rotation, and translation) +class MagickPPExport DrawableAffine : public DrawableBase +{ +public: + DrawableAffine ( double sx_, double sy_, + double rx_, double ry_, + double tx_, double ty_ ); + + DrawableAffine ( void ); + + /*virtual*/ ~DrawableAffine( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ + DrawableBase* copy() const; + + void sx( const double sx_ ) + { + _affine.sx = sx_; + } + double sx( void ) const + { + return _affine.sx; + } + + void sy( const double sy_ ) + { + _affine.sy = sy_; + } + double sy( void ) const + { + return _affine.sy; + } + + void rx( const double rx_ ) + { + _affine.rx = rx_; + } + double rx( void ) const + { + return _affine.rx; + } + + void ry( const double ry_ ) + { + _affine.ry = ry_; + } + double ry( void ) const + { + return _affine.ry; + } + + void tx( const double tx_ ) + { + _affine.tx = tx_; + } + double tx( void ) const + { + return _affine.tx; + } + + void ty( const double ty_ ) + { + _affine.ty = ty_; + } + double ty( void ) const + { + return _affine.ty; + } + +private: + MagickCore::AffineMatrix _affine; +}; + +// Change pixel alpha value to transparent using PaintMethod +class MagickPPExport DrawableAlpha : public DrawableBase +{ +public: + + DrawableAlpha(double x_, double y_,PaintMethod paintMethod_) + : _x(x_), + _y(y_), + _paintMethod(paintMethod_) + { + } + + ~DrawableAlpha(void); + + // Operator to invoke equivalent draw API call + void operator()(MagickCore::DrawingWand *context_) const; + + // Return polymorphic copy of object + DrawableBase* copy() const; + + void x(double x_) + { + _x=x_; + } + + double x(void) const + { + return(_x); + } + + void y(double y_) + { + _y=y_; + } + + double y(void) const + { + return(_y); + } + + void paintMethod(PaintMethod paintMethod_) + { + _paintMethod=paintMethod_; + } + + PaintMethod paintMethod(void) const + { + return(_paintMethod); + } + + private: + + double _x; + double _y; + PaintMethod _paintMethod; +}; + +// Arc +class MagickPPExport DrawableArc : public DrawableBase +{ +public: + DrawableArc ( double startX_, double startY_, + double endX_, double endY_, + double startDegrees_, double endDegrees_ ) + : _startX(startX_), + _startY(startY_), + _endX(endX_), + _endY(endY_), + _startDegrees(startDegrees_), + _endDegrees(endDegrees_) + { } + + /*virtual*/ ~DrawableArc( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void startX( double startX_ ) + { + _startX = startX_; + } + double startX( void ) const + { + return _startX; + } + + void startY( double startY_ ) + { + _startY = startY_; + } + double startY( void ) const + { + return _startY; + } + + void endX( double endX_ ) + { + _endX = endX_; + } + double endX( void ) const + { + return _endX; + } + + void endY( double endY_ ) + { + _endY = endY_; + } + double endY( void ) const + { + return _endY; + } + + void startDegrees( double startDegrees_ ) + { + _startDegrees = startDegrees_; + } + double startDegrees( void ) const + { + return _startDegrees; + } + + void endDegrees( double endDegrees_ ) + { + _endDegrees = endDegrees_; + } + double endDegrees( void ) const + { + return _endDegrees; + } + +private: + double _startX; + double _startY; + double _endX; + double _endY; + double _startDegrees; + double _endDegrees; +}; + +// Bezier curve (Coordinate list must contain at least three members) +class MagickPPExport DrawableBezier : public DrawableBase +{ +public: + // Construct from coordinates + DrawableBezier ( const CoordinateList &coordinates_ ); + + // Copy constructor + DrawableBezier ( const DrawableBezier& original_ ); + + // Destructor + /*virtual*/ ~DrawableBezier ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + +private: + CoordinateList _coordinates; +}; + + // Sets the border color to be used for drawing bordered objects. + class MagickPPExport DrawableBorderColor : public DrawableBase + { + public: + + DrawableBorderColor(const Color &color_); + + DrawableBorderColor(const DrawableBorderColor &original_); + + ~DrawableBorderColor(void); + + // Operator to invoke equivalent draw API call + void operator()(MagickCore::DrawingWand *context_) const; + + void color(const Color &color_); + Color color(void) const; + + // Return polymorphic copy of object + DrawableBase* copy() const; + + private: + Color _color; + }; + + // Sets the polygon fill rule to be used by the clipping path. + class MagickPPExport DrawableClipRule : public DrawableBase + { + public: + + DrawableClipRule(const FillRule fillRule_); + + ~DrawableClipRule(void); + + // Operator to invoke equivalent draw API call + void operator()(MagickCore::DrawingWand *context_) const; + + void fillRule(const FillRule fillRule_); + FillRule fillRule(void) const; + + // Return polymorphic copy of object + DrawableBase* copy() const; + + private: + FillRule _fillRule; + }; + + // Sets the interpretation of clip path units. + class MagickPPExport DrawableClipUnits : public DrawableBase + { + public: + + DrawableClipUnits(const ClipPathUnits units_); + + ~DrawableClipUnits(void); + + // Operator to invoke equivalent draw API call + void operator()(MagickCore::DrawingWand *context_) const; + + void units(const ClipPathUnits units_); + ClipPathUnits units(void) const; + + // Return polymorphic copy of object + DrawableBase* copy() const; + + private: + ClipPathUnits _units; + }; + +// Pop (terminate) clip path definition +class MagickPPExport DrawablePopClipPath : public DrawableBase +{ +public: + DrawablePopClipPath ( void ) + : _dummy(0) + { + } + + /*virtual*/ ~DrawablePopClipPath ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + +private: + ::ssize_t _dummy; +}; + +// Push (create) Clip path definition +class MagickPPExport DrawablePushClipPath : public DrawableBase +{ +public: + DrawablePushClipPath ( const std::string &id_); + + DrawablePushClipPath ( const DrawablePushClipPath& original_ ); + + /*virtual*/ ~DrawablePushClipPath ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + +private: + std::string _id; +}; + +// Named Clip Path +class MagickPPExport DrawableClipPath : public DrawableBase +{ +public: + DrawableClipPath ( const std::string &id_ ); + DrawableClipPath ( const DrawableClipPath& original_ ); + + /*virtual*/ ~DrawableClipPath ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void clip_path( const std::string &id_ ) + { + _id = id_.c_str(); //multithread safe + } + std::string clip_path( void ) const + { + return _id; + } + +private: + std::string _id; +}; + +// Circle +class MagickPPExport DrawableCircle : public DrawableBase +{ +public: + DrawableCircle ( double originX_, double originY_, + double perimX_, double perimY_ ) + : _originX(originX_), + _originY(originY_), + _perimX(perimX_), + _perimY(perimY_) + { + } + + /*virtual*/ ~DrawableCircle ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void originX( double originX_ ) + { + _originX = originX_; + } + double originX( void ) const + { + return _originX; + } + + void originY( double originY_ ) + { + _originY = originY_; + } + double originY( void ) const + { + return _originY; + } + + void perimX( double perimX_ ) + { + _perimX = perimX_; + } + double perimX( void ) const + { + return _perimX; + } + + void perimY( double perimY_ ) + { + _perimY = perimY_; + } + double perimY( void ) const + { + return _perimY; + } + +private: + double _originX; + double _originY; + double _perimX; + double _perimY; +}; + +// Colorize at point using PaintMethod +class MagickPPExport DrawableColor : public DrawableBase +{ +public: + DrawableColor ( double x_, double y_, + PaintMethod paintMethod_ ) + : _x(x_), + _y(y_), + _paintMethod(paintMethod_) + { } + + /*virtual*/ ~DrawableColor ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void x( double x_ ) + { + _x = x_; + } + double x( void ) const + { + return _x; + } + + void y( double y_ ) + { + _y = y_; + } + double y( void ) const + { + return _y; + } + + void paintMethod( PaintMethod paintMethod_ ) + { + _paintMethod = paintMethod_; + } + PaintMethod paintMethod( void ) const + { + return _paintMethod; + } + +private: + double _x; + double _y; + PaintMethod _paintMethod; +}; + +// Draw image at point, scaled to size specified by width and height +class MagickPPExport Image; +class MagickPPExport DrawableCompositeImage : public DrawableBase +{ +public: + DrawableCompositeImage ( double x_, double y_, + const std::string &filename_ ); + + DrawableCompositeImage ( double x_, double y_, + const Image &image_ ); + + DrawableCompositeImage ( double x_, double y_, + double width_, double height_, + const std::string &filename_ ); + + DrawableCompositeImage ( double x_, double y_, + double width_, double height_, + const Image &image_ ); + + DrawableCompositeImage ( double x_, double y_, + double width_, double height_, + const std::string &filename_, + CompositeOperator composition_ ); + + DrawableCompositeImage ( double x_, double y_, + double width_, double height_, + const Image &image_, + CompositeOperator composition_ ); + + // Copy constructor + DrawableCompositeImage ( const DrawableCompositeImage& original_ ); + + // Destructor + /*virtual*/ ~DrawableCompositeImage( void ); + + // Assignment operator + DrawableCompositeImage& operator= + (const DrawableCompositeImage& original_ ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void composition( CompositeOperator composition_ ) + { + _composition = composition_; + } + CompositeOperator composition( void ) const + { + return _composition; + } + + void filename( const std::string &image_ ); + std::string filename( void ) const; + + void x( double x_ ) + { + _x = x_; + } + double x( void ) const + { + return _x; + } + + void y( double y_ ) + { + _y = y_; + } + double y( void ) const + { + return _y; + } + + void width( double width_ ) + { + _width = width_; + } + double width( void ) const + { + return _width; + } + + void height( double height_ ) + { + _height = height_; + } + double height( void ) const + { + return _height; + } + + void image( const Image &image_ ); + Magick::Image image( void ) const; + + // Specify image format used to output Base64 inlined image data. + void magick( std::string magick_ ); + std::string magick( void ); + +private: + CompositeOperator _composition; + double _x; + double _y; + double _width; + double _height; + Image* _image; +}; + +// Density +class MagickPPExport DrawableDensity : public DrawableBase +{ +public: + + DrawableDensity(const Point &density_); + + DrawableDensity(const std::string &density_); + + ~DrawableDensity(void); + + void operator()(MagickCore::DrawingWand *context_) const; + + DrawableBase* copy() const; + +private: + std::string _density; +}; + +// Ellipse +class MagickPPExport DrawableEllipse : public DrawableBase +{ +public: + DrawableEllipse ( double originX_, double originY_, + double radiusX_, double radiusY_, + double arcStart_, double arcEnd_ ) + : _originX(originX_), + _originY(originY_), + _radiusX(radiusX_), + _radiusY(radiusY_), + _arcStart(arcStart_), + _arcEnd(arcEnd_) + { } + + /*virtual*/ ~DrawableEllipse( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void originX( double originX_ ) + { + _originX = originX_; + } + double originX( void ) const + { + return _originX; + } + + void originY( double originY_ ) + { + _originY = originY_; + } + double originY( void ) const + { + return _originY; + } + + void radiusX( double radiusX_ ) + { + _radiusX = radiusX_; + } + double radiusX( void ) const + { + return _radiusX; + } + + void radiusY( double radiusY_ ) + { + _radiusY = radiusY_; + } + double radiusY( void ) const + { + return _radiusY; + } + + void arcStart( double arcStart_ ) + { + _arcStart = arcStart_; + } + double arcStart( void ) const + { + return _arcStart; + } + + void arcEnd( double arcEnd_ ) + { + _arcEnd = arcEnd_; + } + double arcEnd( void ) const + { + return _arcEnd; + } + +private: + double _originX; + double _originY; + double _radiusX; + double _radiusY; + double _arcStart; + double _arcEnd; +}; + +// Specify drawing fill color +class MagickPPExport DrawableFillColor : public DrawableBase +{ +public: + DrawableFillColor ( const Color &color_ ); + + DrawableFillColor ( const DrawableFillColor& original_ ); + + /*virtual*/ ~DrawableFillColor( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void color( const Color &color_ ) + { + _color = color_; + } + Color color( void ) const + { + return _color; + } + +private: + Color _color; +}; + + // Sets the URL to use as a fill pattern for filling objects. Only local + // URLs("#identifier") are supported at this time. These local URLs are + // normally created by defining a named fill pattern with + // DrawablePushPattern/DrawablePopPattern. + class MagickPPExport DrawableFillPatternUrl : public DrawableBase + { + public: + + DrawableFillPatternUrl(const std::string &url_); + + ~DrawableFillPatternUrl(void); + + DrawableFillPatternUrl(const DrawableFillPatternUrl& original_); + + // Operator to invoke equivalent draw API call + void operator()(MagickCore::DrawingWand *context_) const; + + void url(const std::string &url_); + std::string url(void) const; + + // Return polymorphic copy of object + DrawableBase* copy() const; + + private: + std::string _url; + }; + +// Specify fill rule (fill-rule) +class MagickPPExport DrawableFillRule : public DrawableBase +{ +public: + DrawableFillRule ( const FillRule fillRule_ ) + : _fillRule(fillRule_) + { + } + + /*virtual*/ ~DrawableFillRule ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void fillRule( const FillRule fillRule_ ) + { + _fillRule = fillRule_; + } + FillRule fillRule( void ) const + { + return _fillRule; + } + +private: + FillRule _fillRule; +}; + +// Specify drawing fill alpha +class MagickPPExport DrawableFillOpacity : public DrawableBase +{ +public: + + DrawableFillOpacity(double opacity_) + : _opacity(opacity_) + { + } + + ~DrawableFillOpacity ( void ); + + // Operator to invoke equivalent draw API call + void operator()(MagickCore::DrawingWand *context_) const; + + // Return polymorphic copy of object + DrawableBase* copy() const; + + void opacity(double opacity_) + { + _opacity=opacity_; + } + + double opacity(void) const + { + return(_opacity); + } + +private: + double _opacity; +}; + +// Specify text font +class MagickPPExport DrawableFont : public DrawableBase +{ +public: + DrawableFont ( const std::string &font_ ); + + DrawableFont ( const std::string &family_, + StyleType style_, + const unsigned int weight_, + StretchType stretch_ ); + DrawableFont ( const DrawableFont& original_ ); + + /*virtual*/ ~DrawableFont ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void font( const std::string &font_ ) + { + _font = font_; + } + std::string font( void ) const + { + return _font; + } + +private: + std::string _font; + std::string _family; + StyleType _style; + unsigned int _weight; + StretchType _stretch; +}; + +// Specify text positioning gravity +class MagickPPExport DrawableGravity : public DrawableBase +{ +public: + DrawableGravity ( GravityType gravity_ ) + : _gravity(gravity_) + { + } + + /*virtual*/ ~DrawableGravity ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void gravity( GravityType gravity_ ) + { + _gravity = gravity_; + } + GravityType gravity( void ) const + { + return _gravity; + } + +private: + GravityType _gravity; +}; + +// Line +class MagickPPExport DrawableLine : public DrawableBase +{ +public: + DrawableLine ( double startX_, double startY_, + double endX_, double endY_ ) + : _startX(startX_), + _startY(startY_), + _endX(endX_), + _endY(endY_) + { } + + /*virtual*/ ~DrawableLine ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void startX( double startX_ ) + { + _startX = startX_; + } + double startX( void ) const + { + return _startX; + } + + void startY( double startY_ ) + { + _startY = startY_; + } + double startY( void ) const + { + return _startY; + } + + void endX( double endX_ ) + { + _endX = endX_; + } + double endX( void ) const + { + return _endX; + } + + void endY( double endY_ ) + { + _endY = endY_; + } + double endY( void ) const + { + return _endY; + } + +private: + double _startX; + double _startY; + double _endX; + double _endY; +}; + +// Drawable Path +class MagickPPExport DrawablePath : public DrawableBase +{ +public: + DrawablePath ( const VPathList &path_ ); + + DrawablePath ( const DrawablePath& original_ ); + + /*virtual*/ ~DrawablePath ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + +private: + VPathList _path; +}; + +// Point +class MagickPPExport DrawablePoint : public DrawableBase +{ +public: + DrawablePoint ( double x_, double y_ ) + : _x(x_), + _y(y_) + { } + + /*virtual*/ ~DrawablePoint ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void x( double x_ ) + { + _x = x_; + } + double x( void ) const + { + return _x; + } + + void y( double y_ ) + { + _y = y_; + } + double y( void ) const + { + return _y; + } + +private: + double _x; + double _y; +}; + +// Text pointsize +class MagickPPExport DrawablePointSize : public DrawableBase +{ +public: + DrawablePointSize ( double pointSize_ ) + : _pointSize(pointSize_) + { } + + /*virtual*/ ~DrawablePointSize ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void pointSize( double pointSize_ ) + { + _pointSize = pointSize_; + } + double pointSize( void ) const + { + return _pointSize; + } + +private: + double _pointSize; +}; + +// Polygon (Coordinate list must contain at least three members) +class MagickPPExport DrawablePolygon : public DrawableBase +{ +public: + DrawablePolygon ( const CoordinateList &coordinates_ ); + + DrawablePolygon ( const DrawablePolygon& original_ ); + + /*virtual*/ ~DrawablePolygon ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + +private: + CoordinateList _coordinates; +}; + +// Polyline (Coordinate list must contain at least three members) +class MagickPPExport DrawablePolyline : public DrawableBase +{ +public: + DrawablePolyline ( const CoordinateList &coordinates_ ); + + DrawablePolyline ( const DrawablePolyline& original_ ); + + /*virtual*/ ~DrawablePolyline ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + +private: + CoordinateList _coordinates; +}; + +// Pop Graphic Context +class MagickPPExport DrawablePopGraphicContext : public DrawableBase +{ +public: + DrawablePopGraphicContext ( void ) + : _dummy(0) + { + } + + /*virtual*/ ~DrawablePopGraphicContext ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + +private: + ::ssize_t _dummy; +}; + +// Push Graphic Context +class MagickPPExport DrawablePushGraphicContext : public DrawableBase +{ +public: + DrawablePushGraphicContext ( void ) + : _dummy(0) + { + } + + /*virtual*/ ~DrawablePushGraphicContext ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + +private: + ::ssize_t _dummy; +}; + +// Pop (terminate) Pattern definition +class MagickPPExport DrawablePopPattern : public DrawableBase +{ +public: + DrawablePopPattern ( void ) + : _dummy(0) + { + } + + /*virtual*/ ~DrawablePopPattern ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + +private: + ::ssize_t _dummy; +}; + +// Push (create) Pattern definition +class MagickPPExport DrawablePushPattern : public DrawableBase +{ +public: + DrawablePushPattern ( const std::string &id_, ::ssize_t x_, ::ssize_t y_, + size_t width_, size_t height_ ); + + DrawablePushPattern ( const DrawablePushPattern& original_ ); + + /*virtual*/ ~DrawablePushPattern ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + +private: + std::string _id; + ::ssize_t _x; + ::ssize_t _y; + size_t _width; + size_t _height; +}; + +// Rectangle +class MagickPPExport DrawableRectangle : public DrawableBase +{ +public: + DrawableRectangle ( double upperLeftX_, double upperLeftY_, + double lowerRightX_, double lowerRightY_ ) + : _upperLeftX(upperLeftX_), + _upperLeftY(upperLeftY_), + _lowerRightX(lowerRightX_), + _lowerRightY(lowerRightY_) + { } + + /*virtual*/ ~DrawableRectangle ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void upperLeftX( double upperLeftX_ ) + { + _upperLeftX = upperLeftX_; + } + double upperLeftX( void ) const + { + return _upperLeftX; + } + + void upperLeftY( double upperLeftY_ ) + { + _upperLeftY = upperLeftY_; + } + double upperLeftY( void ) const + { + return _upperLeftY; + } + + void lowerRightX( double lowerRightX_ ) + { + _lowerRightX = lowerRightX_; + } + double lowerRightX( void ) const + { + return _lowerRightX; + } + + void lowerRightY( double lowerRightY_ ) + { + _lowerRightY = lowerRightY_; + } + double lowerRightY( void ) const + { + return _lowerRightY; + } + +private: + double _upperLeftX; + double _upperLeftY; + double _lowerRightX; + double _lowerRightY; +}; + +// Apply Rotation +class MagickPPExport DrawableRotation : public DrawableBase +{ +public: + DrawableRotation ( double angle_ ) + : _angle( angle_ ) + { } + + /*virtual*/ ~DrawableRotation ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void angle( double angle_ ) + { + _angle = angle_; + } + double angle( void ) const + { + return _angle; + } + +private: + double _angle; +}; + +// Round Rectangle +class MagickPPExport DrawableRoundRectangle : public DrawableBase +{ +public: + DrawableRoundRectangle ( double upperLeftX_, double upperLeftY_, + double lowerRightX_, double lowerRightY_, + double cornerWidth_, double cornerHeight_ ) + : _upperLeftX(upperLeftX_), + _upperLeftY(upperLeftY_), + _lowerRightX(lowerRightX_), + _lowerRightY(lowerRightY_), + _cornerWidth(cornerWidth_), + _cornerHeight(cornerHeight_) + { } + + /*virtual*/ ~DrawableRoundRectangle ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + +#if !defined(MAGICKCORE_EXCLUDE_DEPRECATED) + + void centerX( double centerX_ ) + { + _upperLeftX = centerX_; + } + double centerX( void ) const + { + return _upperLeftX; + } + + void centerY( double centerY_ ) + { + _upperLeftY = centerY_; + } + double centerY( void ) const + { + return _upperLeftY; + } + + void width( double width_ ) + { + _lowerRightX = width_; + } + double width( void ) const + { + return _lowerRightX; + } + + void hight( double hight_ ) + { + _lowerRightY = hight_; + } + double hight( void ) const + { + return _lowerRightY; + } + +#endif + + void upperLeftX( double upperLeftX_ ) + { + _upperLeftX = upperLeftX_; + } + double upperLeftX( void ) const + { + return _upperLeftX; + } + + void upperLeftY( double upperLeftY_ ) + { + _upperLeftY = upperLeftY_; + } + double upperLeftY( void ) const + { + return _upperLeftY; + } + + void lowerRightX( double lowerRightX_ ) + { + _lowerRightX = lowerRightX_; + } + double lowerRightX( void ) const + { + return _lowerRightX; + } + + void lowerRightY( double lowerRightY_ ) + { + _lowerRightY = lowerRightY_; + } + double lowerRightY( void ) const + { + return _lowerRightY; + } + + void cornerWidth( double cornerWidth_ ) + { + _cornerWidth = cornerWidth_; + } + double cornerWidth( void ) const + { + return _cornerWidth; + } + + void cornerHeight( double cornerHeight_ ) + { + _cornerHeight = cornerHeight_; + } + double cornerHeight( void ) const + { + return _cornerHeight; + } + +private: + double _upperLeftX; + double _upperLeftY; + double _lowerRightX; + double _lowerRightY; + double _cornerWidth; + double _cornerHeight; +}; + +// Apply Scaling +class MagickPPExport DrawableScaling : public DrawableBase +{ +public: + DrawableScaling ( double x_, double y_ ) + : _x(x_), + _y(y_) + { } + + /*virtual*/ ~DrawableScaling ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void x( double x_ ) + { + _x = x_; + } + double x( void ) const + { + return _x; + } + + void y( double y_ ) + { + _y = y_; + } + double y( void ) const + { + return _y; + } + +private: + double _x; + double _y; +}; + +// Apply Skew in X direction +class MagickPPExport DrawableSkewX : public DrawableBase +{ +public: + DrawableSkewX ( double angle_ ) + : _angle(angle_) + { } + + /*virtual*/ ~DrawableSkewX ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void angle( double angle_ ) + { + _angle = angle_; + } + double angle( void ) const + { + return _angle; + } + +private: + double _angle; +}; + +// Apply Skew in Y direction +class MagickPPExport DrawableSkewY : public DrawableBase +{ +public: + DrawableSkewY ( double angle_ ) + : _angle(angle_) + { } + + /*virtual*/ ~DrawableSkewY ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void angle( double angle_ ) + { + _angle = angle_; + } + double angle( void ) const + { + return _angle; + } + +private: + double _angle; +}; + + // Stroke dasharray + // + // dasharray_ is an allocated array terminated by value 0.0 or 0. + // The array is copied so the original does not need to be preserved. + // Pass a null pointer to clear an existing dash array setting. + class MagickPPExport DrawableStrokeDashArray : public DrawableBase + { + public: + + DrawableStrokeDashArray(const double* dasharray_); + + DrawableStrokeDashArray(const Magick::DrawableStrokeDashArray &original_); + + ~DrawableStrokeDashArray(void); + + // Operator to invoke equivalent draw API call + void operator()(MagickCore::DrawingWand *context_) const; + + // Return polymorphic copy of object + DrawableBase* copy() const; + + void dasharray(const double* dasharray_); + const double* dasharray(void) const; + + DrawableStrokeDashArray& operator=( + const Magick::DrawableStrokeDashArray &original_); + + private: + size_t _size; + double *_dasharray; + }; + + // Stroke dashoffset + class MagickPPExport DrawableStrokeDashOffset : public DrawableBase + { + public: + DrawableStrokeDashOffset(const double offset_) + : _offset(offset_) + { } + + ~DrawableStrokeDashOffset(void); + + // Operator to invoke equivalent draw API call + void operator()(MagickCore::DrawingWand *context_) const; + + // Return polymorphic copy of object + DrawableBase* copy() const; + + void offset(const double offset_); + double offset(void) const; + + private: + double _offset; + }; + +// Stroke linecap +class MagickPPExport DrawableStrokeLineCap : public DrawableBase +{ +public: + DrawableStrokeLineCap ( LineCap linecap_ ) + : _linecap(linecap_) + { } + + /*virtual*/ ~DrawableStrokeLineCap ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void linecap( LineCap linecap_ ) + { + _linecap = linecap_; + } + LineCap linecap( void ) const + { + return _linecap; + } + +private: + LineCap _linecap; +}; + +// Stroke linejoin +class MagickPPExport DrawableStrokeLineJoin : public DrawableBase +{ +public: + DrawableStrokeLineJoin ( LineJoin linejoin_ ) + : _linejoin(linejoin_) + { } + + /*virtual*/ ~DrawableStrokeLineJoin ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void linejoin( LineJoin linejoin_ ) + { + _linejoin = linejoin_; + } + LineJoin linejoin( void ) const + { + return _linejoin; + } + +private: + LineJoin _linejoin; +}; + +// Stroke miterlimit +class MagickPPExport DrawableMiterLimit : public DrawableBase +{ +public: + DrawableMiterLimit ( size_t miterlimit_ ) + : _miterlimit(miterlimit_) + { } + + /*virtual*/ ~DrawableMiterLimit ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void miterlimit( size_t miterlimit_ ) + { + _miterlimit = miterlimit_; + } + size_t miterlimit( void ) const + { + return _miterlimit; + } + +private: + size_t _miterlimit; +}; + +// Sets the pattern used for stroking object outlines. +class MagickPPExport DrawableStrokePatternUrl : public DrawableBase +{ +public: + + DrawableStrokePatternUrl(const std::string &url_); + + ~DrawableStrokePatternUrl(void); + + DrawableStrokePatternUrl(const DrawableStrokePatternUrl& original_); + + // Operator to invoke equivalent draw API call + void operator()(MagickCore::DrawingWand *context_) const; + + void url(const std::string &url_); + std::string url(void) const; + + // Return polymorphic copy of object + DrawableBase* copy() const; + +private: + std::string _url; +}; + +// Stroke antialias +class MagickPPExport DrawableStrokeAntialias : public DrawableBase +{ +public: + DrawableStrokeAntialias ( bool flag_ ) + : _flag(flag_) + { } + + /*virtual*/ ~DrawableStrokeAntialias ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void flag( bool flag_ ) + { + _flag = flag_; + } + bool flag( void ) const + { + return _flag; + } + +private: + bool _flag; +}; + +// Stroke color +class MagickPPExport DrawableStrokeColor : public DrawableBase +{ +public: + DrawableStrokeColor ( const Color &color_ ); + + DrawableStrokeColor ( const DrawableStrokeColor& original_ ); + + /*virtual*/ ~DrawableStrokeColor ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void color( const Color& color_ ) + { + _color = color_; + } + Color color( void ) const + { + return _color; + } + +private: + Color _color; +}; + +// Stroke opacity +class MagickPPExport DrawableStrokeOpacity : public DrawableBase +{ +public: + + DrawableStrokeOpacity(double opacity_) + : _opacity(opacity_) + { + } + + ~DrawableStrokeOpacity(void); + + // Operator to invoke equivalent draw API call + void operator()(MagickCore::DrawingWand *context_) const; + + // Return polymorphic copy of object + DrawableBase* copy() const; + + void opacity(double opacity_) + { + _opacity=opacity_; + } + + double opacity(void) const + { + return(_opacity); + } + +private: + double _opacity; +}; + +// Stroke width +class MagickPPExport DrawableStrokeWidth : public DrawableBase +{ +public: + DrawableStrokeWidth ( double width_ ) + : _width(width_) + { } + + /*virtual*/ ~DrawableStrokeWidth ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void width( double width_ ) + { + _width = width_; + } + double width( void ) const + { + return _width; + } + +private: + double _width; +}; + +// Draw text at point +class MagickPPExport DrawableText : public DrawableBase +{ +public: + DrawableText ( const double x_, const double y_, + const std::string &text_ ); + DrawableText ( const double x_, const double y_, + const std::string &text_, const std::string &encoding_); + + DrawableText ( const DrawableText& original_ ); + + /*virtual*/ ~DrawableText ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void encoding(const std::string &encoding_) + { + _encoding = encoding_; + } + + void x( double x_ ) + { + _x = x_; + } + double x( void ) const + { + return _x; + } + + void y( double y_ ) + { + _y = y_; + } + double y( void ) const + { + return _y; + } + + void text( const std::string &text_ ) + { + _text = text_; + } + std::string text( void ) const + { + return _text; + } + +private: + double _x; + double _y; + std::string _text; + std::string _encoding; +}; + +// Text alignment +class MagickPPExport DrawableTextAlignment : public DrawableBase +{ +public: + + DrawableTextAlignment(AlignType alignment_); + + DrawableTextAlignment(const DrawableTextAlignment& original_); + + ~DrawableTextAlignment(void); + + // Operator to invoke equivalent draw API call + void operator()(MagickCore::DrawingWand *context_) const; + + void alignment(AlignType alignment_); + AlignType alignment(void) const; + + // Return polymorphic copy of object + DrawableBase* copy() const; + +private: + AlignType _alignment; +}; + +// Text antialias +class MagickPPExport DrawableTextAntialias : public DrawableBase +{ +public: + DrawableTextAntialias ( bool flag_ ); + + DrawableTextAntialias( const DrawableTextAntialias &original_ ); + + /*virtual*/ ~DrawableTextAntialias ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void flag( bool flag_ ) + { + _flag = flag_; + } + bool flag( void ) const + { + return _flag; + } + +private: + bool _flag; +}; + +// Decoration (text decoration) +class MagickPPExport DrawableTextDecoration : public DrawableBase +{ +public: + DrawableTextDecoration ( DecorationType decoration_ ); + + DrawableTextDecoration ( const DrawableTextDecoration& original_ ); + + /*virtual*/ ~DrawableTextDecoration( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void decoration( DecorationType decoration_ ) + { + _decoration = decoration_; + } + DecorationType decoration( void ) const + { + return _decoration; + } + +private: + DecorationType _decoration; +}; + + // Render text right-to-left or left-to-right. + class MagickPPExport DrawableTextDirection : public DrawableBase + { + public: + + DrawableTextDirection(DirectionType direction_); + + ~DrawableTextDirection(void); + + void operator()(MagickCore::DrawingWand *context_) const; + + void direction(DirectionType direction_); + DirectionType direction(void) const; + + DrawableBase* copy() const; + + private: + DirectionType _direction; + }; + + // Specify text inter-line spacing + class MagickPPExport DrawableTextInterlineSpacing : public DrawableBase + { + public: + + DrawableTextInterlineSpacing(double spacing_); + + ~DrawableTextInterlineSpacing(void); + + void operator()(MagickCore::DrawingWand *context_) const; + + void spacing(double spacing_); + double spacing(void) const; + + DrawableBase* copy() const; + + private: + double _spacing; + }; + + // Specify text inter-word spacing + class MagickPPExport DrawableTextInterwordSpacing : public DrawableBase + { + public: + + DrawableTextInterwordSpacing(double spacing_); + + ~DrawableTextInterwordSpacing(void); + + void operator()(MagickCore::DrawingWand *context_) const; + + void spacing(double spacing_); + double spacing(void) const; + + DrawableBase *copy() const; + + private: + double _spacing; + }; + + // Specify text kerning + class MagickPPExport DrawableTextKerning : public DrawableBase + { + public: + + DrawableTextKerning(double kerning_); + + ~DrawableTextKerning(void); + + void operator()(MagickCore::DrawingWand *context_) const; + + void kerning(double kerning_); + double kerning(void) const; + + DrawableBase *copy() const; + + private: + double _kerning; + }; + +// Text undercolor box +class MagickPPExport DrawableTextUnderColor : public DrawableBase +{ +public: + DrawableTextUnderColor ( const Color &color_ ); + + DrawableTextUnderColor ( const DrawableTextUnderColor& original_ ); + + /*virtual*/ ~DrawableTextUnderColor ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void color( const Color& color_ ) + { + _color = color_; + } + Color color( void ) const + { + return _color; + } + +private: + Color _color; +}; + +// Apply Translation +class MagickPPExport DrawableTranslation : public DrawableBase +{ +public: + DrawableTranslation ( double x_, double y_ ) + : _x(x_), + _y(y_) + { } + + /*virtual*/ ~DrawableTranslation ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ DrawableBase* copy() const; + + void x( double x_ ) + { + _x = x_; + } + double x( void ) const + { + return _x; + } + + void y( double y_ ) + { + _y = y_; + } + double y( void ) const + { + return _y; + } + +private: + double _x; + double _y; +}; + +// Set the size of the viewbox +class MagickPPExport DrawableViewbox : public DrawableBase +{ +public: + DrawableViewbox(::ssize_t x1_, ::ssize_t y1_, + ::ssize_t x2_, ::ssize_t y2_) + : _x1(x1_), + _y1(y1_), + _x2(x2_), + _y2(y2_) { } + + /*virtual*/ ~DrawableViewbox ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ + DrawableBase* copy() const; + + void x1( ::ssize_t x1_ ) + { + _x1 = x1_; + } + ::ssize_t x1( void ) const + { + return _x1; + } + + void y1( ::ssize_t y1_ ) + { + _y1 = y1_; + } + ::ssize_t y1( void ) const + { + return _y1; + } + + void x2( ::ssize_t x2_ ) + { + _x2 = x2_; + } + ::ssize_t x2( void ) const + { + return _x2; + } + + void y2( ::ssize_t y2_ ) + { + _y2 = y2_; + } + ::ssize_t y2( void ) const + { + return _y2; + } + +private: + ::ssize_t _x1; + ::ssize_t _y1; + ::ssize_t _x2; + ::ssize_t _y2; +}; + +// +// Path Element Classes To Support DrawablePath +// +class MagickPPExport PathArcArgs +{ +public: + PathArcArgs( void ); + + PathArcArgs( double radiusX_, double radiusY_, + double xAxisRotation_, bool largeArcFlag_, + bool sweepFlag_, double x_, double y_ ); + + PathArcArgs( const PathArcArgs &original_ ); + + ~PathArcArgs ( void ); + + void radiusX( double radiusX_ ) + { + _radiusX = radiusX_; + } + double radiusX( void ) const + { + return _radiusX; + } + + void radiusY( double radiusY_ ) + { + _radiusY = radiusY_; + } + double radiusY( void ) const + { + return _radiusY; + } + + void xAxisRotation( double xAxisRotation_ ) + { + _xAxisRotation = xAxisRotation_; + } + double xAxisRotation( void ) const + { + return _xAxisRotation; + } + + void largeArcFlag( bool largeArcFlag_ ) + { + _largeArcFlag = largeArcFlag_; + } + bool largeArcFlag( void ) const + { + return _largeArcFlag; + } + + void sweepFlag( bool sweepFlag_ ) + { + _sweepFlag = sweepFlag_; + } + bool sweepFlag( void ) const + { + return _sweepFlag; + } + + void x( double x_ ) + { + _x = x_; + } + double x( void ) const + { + return _x; + } + + void y( double y_ ) + { + _y = y_; + } + double y( void ) const + { + return _y; + } + +private: + double _radiusX; // X radius + double _radiusY; // Y radius + double _xAxisRotation; // Rotation relative to X axis + bool _largeArcFlag; // Draw longer of the two matching arcs + bool _sweepFlag; // Draw arc matching clock-wise rotation + double _x; // End-point X + double _y; // End-point Y +}; + +// Compare two PathArcArgs objects regardless of LHS/RHS +extern MagickPPExport int operator == ( const PathArcArgs& left_, + const PathArcArgs& right_ ); +extern MagickPPExport int operator != ( const PathArcArgs& left_, + const PathArcArgs& right_ ); +extern MagickPPExport int operator > ( const PathArcArgs& left_, + const PathArcArgs& right_ ); +extern MagickPPExport int operator < ( const PathArcArgs& left_, + const PathArcArgs& right_ ); +extern MagickPPExport int operator >= ( const PathArcArgs& left_, + const PathArcArgs& right_ ); +extern MagickPPExport int operator <= ( const PathArcArgs& left_, + const PathArcArgs& right_ ); + +typedef std::vector PathArcArgsList; + +#if defined(MagickDLLExplicitTemplate) + +MagickDrawableExtern template class MagickPPExport +std::allocator; + +// MagickDrawableExtern template class MagickPPExport +// std::vector >; + +#endif // MagickDLLExplicitTemplate + +// Path Arc (Elliptical Arc) +class MagickPPExport PathArcAbs : public VPathBase +{ +public: + // Draw a single arc segment + PathArcAbs ( const PathArcArgs &coordinates_ ); + + // Draw multiple arc segments + PathArcAbs ( const PathArcArgsList &coordinates_ ); + + // Copy constructor + PathArcAbs ( const PathArcAbs& original_ ); + + // Destructor + /*virtual*/ ~PathArcAbs ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ VPathBase* copy() const; + +private: + PathArcArgsList _coordinates; +}; +class MagickPPExport PathArcRel : public VPathBase +{ +public: + // Draw a single arc segment + PathArcRel ( const PathArcArgs &coordinates_ ); + + // Draw multiple arc segments + PathArcRel ( const PathArcArgsList &coordinates_ ); + + PathArcRel ( const PathArcRel& original_ ); + + /*virtual*/ ~PathArcRel ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ VPathBase* copy() const; + +private: + PathArcArgsList _coordinates; +}; + +// Path Closepath +class MagickPPExport PathClosePath : public VPathBase +{ +public: + PathClosePath ( void ) + : _dummy(0) + { + } + + /*virtual*/ ~PathClosePath ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ VPathBase* copy() const; + +private: + ::ssize_t _dummy; +}; + +// +// Curveto (Cubic Bezier) +// +class MagickPPExport PathCurvetoArgs +{ +public: + PathCurvetoArgs( void ); + + PathCurvetoArgs( double x1_, double y1_, + double x2_, double y2_, + double x_, double y_ ); + + PathCurvetoArgs( const PathCurvetoArgs &original_ ); + + ~PathCurvetoArgs ( void ); + + void x1( double x1_ ) + { + _x1 = x1_; + } +double x1( void ) const +{ + return _x1; +} + +void y1( double y1_ ) +{ + _y1 = y1_; +} +double y1( void ) const +{ + return _y1; +} + +void x2( double x2_ ) +{ + _x2 = x2_; +} +double x2( void ) const +{ + return _x2; +} + +void y2( double y2_ ) +{ + _y2 = y2_; +} +double y2( void ) const +{ + return _y2; +} + +void x( double x_ ) +{ + _x = x_; +} +double x( void ) const +{ + return _x; +} + +void y( double y_ ) +{ + _y = y_; +} +double y( void ) const +{ + return _y; +} + +private: +double _x1; +double _y1; +double _x2; +double _y2; +double _x; +double _y; +}; + +// Compare two PathCurvetoArgs objects regardless of LHS/RHS +extern MagickPPExport int operator == ( const PathCurvetoArgs& left_, + const PathCurvetoArgs& right_ ); +extern MagickPPExport int operator != ( const PathCurvetoArgs& left_, + const PathCurvetoArgs& right_ ); +extern MagickPPExport int operator > ( const PathCurvetoArgs& left_, + const PathCurvetoArgs& right_ ); +extern MagickPPExport int operator < ( const PathCurvetoArgs& left_, + const PathCurvetoArgs& right_ ); +extern MagickPPExport int operator >= ( const PathCurvetoArgs& left_, + const PathCurvetoArgs& right_ ); +extern MagickPPExport int operator <= ( const PathCurvetoArgs& left_, + const PathCurvetoArgs& right_ ); + +typedef std::vector PathCurveToArgsList; + +#if defined(MagickDLLExplicitTemplate) + +MagickDrawableExtern template class MagickPPExport +std::allocator; + +// MagickDrawableExtern template class MagickPPExport +// std::vector >; + +#endif // MagickDLLExplicitTemplate + +class MagickPPExport PathCurvetoAbs : public VPathBase +{ +public: + // Draw a single curve + PathCurvetoAbs ( const PathCurvetoArgs &args_ ); + + // Draw multiple curves + PathCurvetoAbs ( const PathCurveToArgsList &args_ ); + + // Copy constructor + PathCurvetoAbs ( const PathCurvetoAbs& original_ ); + + // Destructor + /*virtual*/ ~PathCurvetoAbs ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ VPathBase* copy() const; + +private: + PathCurveToArgsList _args; +}; +class MagickPPExport PathCurvetoRel : public VPathBase +{ +public: + // Draw a single curve + PathCurvetoRel ( const PathCurvetoArgs &args_ ); + + // Draw multiple curves + PathCurvetoRel ( const PathCurveToArgsList &args_ ); + + // Copy constructor + PathCurvetoRel ( const PathCurvetoRel& original_ ); + + /*virtual*/ ~PathCurvetoRel ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ VPathBase* copy() const; + +private: + PathCurveToArgsList _args; +}; +class MagickPPExport PathSmoothCurvetoAbs : public VPathBase +{ +public: + // Draw a single curve + PathSmoothCurvetoAbs ( const Magick::Coordinate &coordinates_ ); + + // Draw multiple curves + PathSmoothCurvetoAbs ( const CoordinateList &coordinates_ ); + + // Copy constructor + PathSmoothCurvetoAbs ( const PathSmoothCurvetoAbs& original_ ); + + /*virtual*/ ~PathSmoothCurvetoAbs ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ + VPathBase* copy() const; + +private: + CoordinateList _coordinates; +}; +class MagickPPExport PathSmoothCurvetoRel : public VPathBase +{ +public: + // Draw a single curve + PathSmoothCurvetoRel ( const Coordinate &coordinates_ ); + + // Draw multiple curves + PathSmoothCurvetoRel ( const CoordinateList &coordinates_ ); + + // Copy constructor + PathSmoothCurvetoRel ( const PathSmoothCurvetoRel& original_ ); + + // Destructor + /*virtual*/ ~PathSmoothCurvetoRel ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ + VPathBase* copy() const; + +private: + CoordinateList _coordinates; +}; + +// +// Quadratic Curveto (Quadratic Bezier) +// +class MagickPPExport PathQuadraticCurvetoArgs +{ +public: + PathQuadraticCurvetoArgs( void ); + + PathQuadraticCurvetoArgs( double x1_, double y1_, + double x_, double y_ ); + + PathQuadraticCurvetoArgs( const PathQuadraticCurvetoArgs &original_ ); + + ~PathQuadraticCurvetoArgs ( void ); + + void x1( double x1_ ) + { + _x1 = x1_; + } + double x1( void ) const + { + return _x1; + } + + void y1( double y1_ ) + { + _y1 = y1_; + } + double y1( void ) const + { + return _y1; + } + + void x( double x_ ) + { + _x = x_; + } + double x( void ) const + { + return _x; + } + + void y( double y_ ) + { + _y = y_; + } + double y( void ) const + { + return _y; + } + +private: + double _x1; + double _y1; + double _x; + double _y; +}; + +// Compare two PathQuadraticCurvetoArgs objects regardless of LHS/RHS +extern MagickPPExport int operator == ( const PathQuadraticCurvetoArgs& left_, + const PathQuadraticCurvetoArgs& right_ ); +extern MagickPPExport int operator != ( const PathQuadraticCurvetoArgs& left_, + const PathQuadraticCurvetoArgs& right_); +extern MagickPPExport int operator > ( const PathQuadraticCurvetoArgs& left_, + const PathQuadraticCurvetoArgs& right_); +extern MagickPPExport int operator < ( const PathQuadraticCurvetoArgs& left_, + const PathQuadraticCurvetoArgs& right_); +extern MagickPPExport int operator >= ( const PathQuadraticCurvetoArgs& left_, + const PathQuadraticCurvetoArgs& right_ ); +extern MagickPPExport int operator <= ( const PathQuadraticCurvetoArgs& left_, + const PathQuadraticCurvetoArgs& right_ ); + +typedef std::vector PathQuadraticCurvetoArgsList; + +#if defined(MagickDLLExplicitTemplate) + +MagickDrawableExtern template class MagickPPExport +std::allocator; + +// MagickDrawableExtern template class MagickPPExport +// std::vector >; + +#endif // MagickDLLExplicitTemplate + +class MagickPPExport PathQuadraticCurvetoAbs : public VPathBase +{ +public: + // Draw a single curve + PathQuadraticCurvetoAbs ( const Magick::PathQuadraticCurvetoArgs &args_ ); + + // Draw multiple curves + PathQuadraticCurvetoAbs ( const PathQuadraticCurvetoArgsList &args_ ); + + // Copy constructor + PathQuadraticCurvetoAbs ( const PathQuadraticCurvetoAbs& original_ ); + + // Destructor + /*virtual*/ ~PathQuadraticCurvetoAbs ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ VPathBase* copy() const; + +private: + PathQuadraticCurvetoArgsList _args; +}; +class MagickPPExport PathQuadraticCurvetoRel : public VPathBase +{ +public: + // Draw a single curve + PathQuadraticCurvetoRel ( const Magick::PathQuadraticCurvetoArgs &args_ ); + + // Draw multiple curves + PathQuadraticCurvetoRel ( const PathQuadraticCurvetoArgsList &args_ ); + + // Copy constructor + PathQuadraticCurvetoRel ( const PathQuadraticCurvetoRel& original_ ); + + // Destructor + /*virtual*/ ~PathQuadraticCurvetoRel ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ VPathBase* copy() const; + +private: + PathQuadraticCurvetoArgsList _args; +}; +class MagickPPExport PathSmoothQuadraticCurvetoAbs : public VPathBase +{ +public: + // Draw a single curve + PathSmoothQuadraticCurvetoAbs ( const Magick::Coordinate &coordinate_ ); + + // Draw multiple curves + PathSmoothQuadraticCurvetoAbs ( const CoordinateList &coordinates_ ); + + // Copy constructor + PathSmoothQuadraticCurvetoAbs ( const PathSmoothQuadraticCurvetoAbs& original_ ); + + // Destructor + /*virtual*/ ~PathSmoothQuadraticCurvetoAbs ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ VPathBase* copy() const; + +private: + CoordinateList _coordinates; +}; +class MagickPPExport PathSmoothQuadraticCurvetoRel : public VPathBase +{ +public: + // Draw a single curve + PathSmoothQuadraticCurvetoRel ( const Magick::Coordinate &coordinate_ ); + + // Draw multiple curves + PathSmoothQuadraticCurvetoRel ( const CoordinateList &coordinates_ ); + + // Copy constructor + PathSmoothQuadraticCurvetoRel ( const PathSmoothQuadraticCurvetoRel& original_ ); + + // Destructor + /*virtual*/ ~PathSmoothQuadraticCurvetoRel ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ VPathBase* copy() const; + +private: + CoordinateList _coordinates; +}; + +// +// Path Lineto +// +class MagickPPExport PathLinetoAbs : public VPathBase +{ +public: + // Draw to a single point + PathLinetoAbs ( const Magick::Coordinate& coordinate_ ); + + // Draw to multiple points + PathLinetoAbs ( const CoordinateList &coordinates_ ); + + // Copy constructor + PathLinetoAbs ( const PathLinetoAbs& original_ ); + + // Destructor + /*virtual*/ ~PathLinetoAbs ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ VPathBase* copy() const; + +private: + CoordinateList _coordinates; +}; +class MagickPPExport PathLinetoRel : public VPathBase +{ +public: + // Draw to a single point + PathLinetoRel ( const Magick::Coordinate& coordinate_ ); + + // Draw to multiple points + PathLinetoRel ( const CoordinateList &coordinates_ ); + + // Copy constructor + PathLinetoRel ( const PathLinetoRel& original_ ); + + // Destructor + /*virtual*/ ~PathLinetoRel ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ VPathBase* copy() const; + +private: + CoordinateList _coordinates; +}; + +// Path Horizontal Lineto +class MagickPPExport PathLinetoHorizontalAbs : public VPathBase +{ +public: + PathLinetoHorizontalAbs ( double x_ ) + : _x(x_) + { + } + + /*virtual*/ ~PathLinetoHorizontalAbs ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ VPathBase* copy() const; + + void x( double x_ ) + { + _x = x_; + } + double x( void ) const + { + return _x; + } + +private: + double _x; +}; +class MagickPPExport PathLinetoHorizontalRel : public VPathBase +{ +public: + PathLinetoHorizontalRel ( double x_ ) + : _x(x_) + { + } + + /*virtual*/ ~PathLinetoHorizontalRel ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ VPathBase* copy() const; + + void x( double x_ ) + { + _x = x_; + } + double x( void ) const + { + return _x; + } + +private: + double _x; +}; + +// Path Vertical Lineto +class MagickPPExport PathLinetoVerticalAbs : public VPathBase +{ +public: + PathLinetoVerticalAbs ( double y_ ) + : _y(y_) + { + } + + /*virtual*/ ~PathLinetoVerticalAbs ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ VPathBase* copy() const; + + void y( double y_ ) + { + _y = y_; + } + double y( void ) const + { + return _y; + } + +private: + double _y; +}; +class MagickPPExport PathLinetoVerticalRel : public VPathBase +{ +public: + PathLinetoVerticalRel ( double y_ ) + : _y(y_) + { + } + + /*virtual*/ ~PathLinetoVerticalRel ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ VPathBase* copy() const; + + void y( double y_ ) + { + _y = y_; + } + double y( void ) const + { + return _y; + } + +private: + double _y; +}; + +// Path Moveto +class MagickPPExport PathMovetoAbs : public VPathBase +{ +public: + // Simple moveto + PathMovetoAbs ( const Magick::Coordinate &coordinate_ ); + + // Moveto followed by implicit linetos + PathMovetoAbs ( const CoordinateList &coordinates_ ); + + // Copy constructor + PathMovetoAbs ( const PathMovetoAbs& original_ ); + + // Destructor + /*virtual*/ ~PathMovetoAbs ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ VPathBase* copy() const; + +private: + CoordinateList _coordinates; +}; +class MagickPPExport PathMovetoRel : public VPathBase +{ +public: + // Simple moveto + PathMovetoRel ( const Magick::Coordinate &coordinate_ ); + + // Moveto followed by implicit linetos + PathMovetoRel ( const CoordinateList &coordinates_ ); + + // Copy constructor + PathMovetoRel ( const PathMovetoRel& original_ ); + + // Destructor + /*virtual*/ ~PathMovetoRel ( void ); + + // Operator to invoke equivalent draw API call + /*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const; + + // Return polymorphic copy of object + /*virtual*/ VPathBase* copy() const; + +private: + CoordinateList _coordinates; +}; + +} // namespace Magick + +#endif // Magick_Drawable_header diff --git a/bin/7.0.5-5/include/ImageMagick-7/Magick++/Exception.h b/bin/7.0.5-5/include/ImageMagick-7/Magick++/Exception.h new file mode 100755 index 0000000..eb77f40 --- /dev/null +++ b/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 +#include + +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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/Magick++/Functions.h b/bin/7.0.5-5/include/ImageMagick-7/Magick++/Functions.h new file mode 100755 index 0000000..863cab1 --- /dev/null +++ b/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 + +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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/Magick++/Geometry.h b/bin/7.0.5-5/include/ImageMagick-7/Magick++/Geometry.h new file mode 100755 index 0000000..6fa31cf --- /dev/null +++ b/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 + +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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/Magick++/Image.h b/bin/7.0.5-5/include/ImageMagick-7/Magick++/Image.h new file mode 100755 index 0000000..efa1b98 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/Magick++/Image.h @@ -0,0 +1,1541 @@ +// This may look like C code, but it is really -*- C++ -*- +// +// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003 +// Copyright Dirk Lemstra 2013-2016 +// +// Definition of Image, the representation of a single image in Magick++ +// + +#if !defined(Magick_Image_header) +#define Magick_Image_header + +#include "Magick++/Include.h" +#include +#include +#include "Magick++/Blob.h" +#include "Magick++/Color.h" +#include "Magick++/Drawable.h" +#include "Magick++/Exception.h" +#include "Magick++/Geometry.h" +#include "Magick++/Statistic.h" +#include "Magick++/TypeMetric.h" + +namespace Magick +{ + // Forward declarations + class Options; + class ImageRef; + + extern MagickPPExport const char *borderGeometryDefault; + extern MagickPPExport const char *frameGeometryDefault; + extern MagickPPExport const char *raiseGeometryDefault; + + // Compare two Image objects regardless of LHS/RHS + // Image sizes and signatures are used as basis of comparison + MagickPPExport int operator == + (const Magick::Image &left_,const Magick::Image &right_); + MagickPPExport int operator != + (const Magick::Image &left_,const Magick::Image &right_); + MagickPPExport int operator > + (const Magick::Image &left_,const Magick::Image &right_); + MagickPPExport int operator < + (const Magick::Image &left_,const Magick::Image &right_); + MagickPPExport int operator >= + (const Magick::Image &left_,const Magick::Image &right_); + MagickPPExport int operator <= + (const Magick::Image &left_,const Magick::Image &right_); + + // + // Image is the representation of an image. In reality, it actually + // a handle object which contains a pointer to a shared reference + // object (ImageRef). As such, this object is extremely space efficient. + // + class MagickPPExport Image + { + public: + + // Default constructor + Image(void); + + // Construct Image from in-memory BLOB + Image(const Blob &blob_); + + // Construct Image of specified size from in-memory BLOB + Image(const Blob &blob_,const Geometry &size_); + + // Construct Image of specified size and depth from in-memory BLOB + Image(const Blob &blob_,const Geometry &size_,const size_t depth_); + + // Construct Image of specified size, depth, and format from + // in-memory BLOB + Image(const Blob &blob_,const Geometry &size_,const size_t depth_, + const std::string &magick_); + + // Construct Image of specified size, and format from in-memory BLOB + Image(const Blob &blob_,const Geometry &size_,const std::string &magick_); + + // Construct a blank image canvas of specified size and color + Image(const Geometry &size_,const Color &color_); + + // Copy constructor + Image(const Image &image_); + + // Copy constructor to copy part of the image + Image(const Image &image_,const Geometry &geometry_); + + // Construct an image based on an array of raw pixels, of + // specified type and mapping, in memory + Image(const size_t width_,const size_t height_,const std::string &map_, + const StorageType type_,const void *pixels_); + + // Construct from image file or image specification + Image(const std::string &imageSpec_); + + // Destructor + virtual ~Image(); + + // Assignment operator + Image& operator=(const Image &image_); + + // Join images into a single multi-image file + void adjoin(const bool flag_); + bool adjoin(void) const; + + // Image supports transparency (alpha channel) + void alpha(const bool alphaFlag_); + bool alpha(void) const; + + // Transparent color + void matteColor(const Color &matteColor_); + Color matteColor(void) const; + + // Time in 1/100ths of a second which must expire before + // displaying the next image in an animated sequence. + void animationDelay(const size_t delay_); + size_t animationDelay(void) const; + + // Lessen (or intensify) when adding noise to an image. + void attenuate(const double attenuate_); + + // Number of iterations to loop an animation (e.g. Netscape loop + // extension) for. + void animationIterations(const size_t iterations_); + size_t animationIterations(void) const; + + // Image background color + void backgroundColor(const Color &color_); + Color backgroundColor(void) const; + + // Name of texture image to tile onto the image background + void backgroundTexture(const std::string &backgroundTexture_); + std::string backgroundTexture(void) const; + + // Base image width (before transformations) + size_t baseColumns(void) const; + + // Base image filename (before transformations) + std::string baseFilename(void) const; + + // Base image height (before transformations) + size_t baseRows(void) const; + + // Use black point compensation. + void blackPointCompensation(const bool flag_); + bool blackPointCompensation(void) const; + + // Image border color + void borderColor(const Color &color_); + Color borderColor(void) const; + + // Return smallest bounding box enclosing non-border pixels. The + // current fuzz value is used when discriminating between pixels. + // This is the crop bounding box used by crop(Geometry(0,0)); + Geometry boundingBox(void) const; + + // Text bounding-box base color (default none) + void boxColor(const Color &boxColor_); + Color boxColor(void) const; + + // Set or obtain modulus channel depth + void channelDepth(const ChannelType channel_,const size_t depth_); + size_t channelDepth(const ChannelType channel_); + + // Returns the number of channels in this image. + size_t channels() const; + + // Image class (DirectClass or PseudoClass) + // NOTE: setting a DirectClass image to PseudoClass will result in + // the loss of color information if the number of colors in the + // image is greater than the maximum palette size (either 256 or + // 65536 entries depending on the value of MAGICKCORE_QUANTUM_DEPTH when + // ImageMagick was built). + void classType(const ClassType class_); + ClassType classType(void) const; + + // Colors within this distance are considered equal + void colorFuzz(const double fuzz_); + double colorFuzz(void) const; + + // Colormap size (number of colormap entries) + void colorMapSize(const size_t entries_); + size_t colorMapSize(void) const; + + // Image Color Space + void colorSpace(const ColorspaceType colorSpace_); + ColorspaceType colorSpace(void) const; + + void colorSpaceType(const ColorspaceType colorSpace_); + ColorspaceType colorSpaceType(void) const; + + // Image width + size_t columns(void) const; + + // Comment image (add comment string to image) + void comment(const std::string &comment_); + std::string comment(void) const; + + // Composition operator to be used when composition is implicitly + // used (such as for image flattening). + void compose(const CompositeOperator compose_); + CompositeOperator compose(void) const; + + // Compression type + void compressType(const CompressionType compressType_); + CompressionType compressType(void) const; + + // Enable printing of debug messages from ImageMagick + void debug(const bool flag_); + bool debug(void) const; + + // Vertical and horizontal resolution in pixels of the image + void density(const Point &density_); + Point density(void) const; + + // Image depth (bits allocated to red/green/blue components) + void depth(const size_t depth_); + size_t depth(void) const; + + // Tile names from within an image montage + std::string directory(void) const; + + // Endianness (little like Intel or big like SPARC) for image + // formats which support endian-specific options. + void endian(const EndianType endian_); + EndianType endian(void) const; + + // Exif profile (BLOB) + void exifProfile(const Blob &exifProfile_); + Blob exifProfile(void) const; + + // Image file name + void fileName(const std::string &fileName_); + std::string fileName(void) const; + + // Number of bytes of the image on disk + MagickSizeType fileSize(void) const; + + // Color to use when filling drawn objects + void fillColor(const Color &fillColor_); + Color fillColor(void) const; + + // Rule to use when filling drawn objects + void fillRule(const FillRule &fillRule_); + FillRule fillRule(void) const; + + // Pattern to use while filling drawn objects. + void fillPattern(const Image &fillPattern_); + Image fillPattern(void) const; + + // Filter to use when resizing image + void filterType(const FilterType filterType_); + FilterType filterType(void) const; + + // Text rendering font + void font(const std::string &font_); + std::string font(void) const; + + // Font family + void fontFamily(const std::string &family_); + std::string fontFamily(void) const; + + // Font point size + void fontPointsize(const double pointSize_); + double fontPointsize(void) const; + + // Font style + void fontStyle(const StyleType style_); + StyleType fontStyle(void) const; + + // Font weight + void fontWeight(const size_t weight_); + size_t fontWeight(void) const; + + // Long image format description + std::string format(void) const; + + // Formats the specified expression + // More info here: http://www.imagemagick.org/script/escape.php + std::string formatExpression(const std::string expression); + + // Gamma level of the image + double gamma(void) const; + + // Preferred size of the image when encoding + Geometry geometry(void) const; + + // GIF disposal method + void gifDisposeMethod(const DisposeType disposeMethod_); + DisposeType gifDisposeMethod(void) const; + + bool hasChannel(const PixelChannel channel) const; + + // When comparing images, emphasize pixel differences with this color. + void highlightColor(const Color color_); + + // ICC color profile (BLOB) + void iccColorProfile(const Blob &colorProfile_); + Blob iccColorProfile(void) const; + + // Type of interlacing to use + void interlaceType(const InterlaceType interlace_); + InterlaceType interlaceType(void) const; + + // Pixel color interpolation method to use + void interpolate(const PixelInterpolateMethod interpolate_); + PixelInterpolateMethod interpolate(void) const; + + // IPTC profile (BLOB) + void iptcProfile(const Blob &iptcProfile_); + Blob iptcProfile(void) const; + + // Returns true if none of the pixels in the image have an alpha value + // other than OpaqueAlpha (QuantumRange). + bool isOpaque(void) const; + + // Does object contain valid image? + void isValid(const bool isValid_); + bool isValid(void) const; + + // Image label + void label(const std::string &label_); + std::string label(void) const; + + // When comparing images, de-emphasize pixel differences with this color. + void lowlightColor(const Color color_); + + // File type magick identifier (.e.g "GIF") + void magick(const std::string &magick_); + std::string magick(void) const; + + // The mean error per pixel computed when an image is color reduced + double meanErrorPerPixel(void) const; + + // Image modulus depth (minimum number of bits required to support + // red/green/blue components without loss of accuracy) + void modulusDepth(const size_t modulusDepth_); + size_t modulusDepth(void) const; + + // Transform image to black and white + void monochrome(const bool monochromeFlag_); + bool monochrome(void) const; + + // Tile size and offset within an image montage + Geometry montageGeometry(void) const; + + // The normalized max error per pixel computed when an image is + // color reduced. + double normalizedMaxError(void) const; + + // The normalized mean error per pixel computed when an image is + // color reduced. + double normalizedMeanError(void) const; + + // Image orientation + void orientation(const OrientationType orientation_); + OrientationType orientation(void) const; + + // Preferred size and location of an image canvas. + void page(const Geometry &pageSize_); + Geometry page(void) const; + + // JPEG/MIFF/PNG compression level (default 75). + void quality(const size_t quality_); + size_t quality(void) const; + + // Maximum number of colors to quantize to + void quantizeColors(const size_t colors_); + size_t quantizeColors(void) const; + + // Colorspace to quantize in. + void quantizeColorSpace(const ColorspaceType colorSpace_); + ColorspaceType quantizeColorSpace(void) const; + + // Dither image during quantization (default true). + void quantizeDither(const bool ditherFlag_); + bool quantizeDither(void) const; + + // Dither method + void quantizeDitherMethod(const DitherMethod ditherMethod_); + DitherMethod quantizeDitherMethod(void) const; + + // Quantization tree-depth + void quantizeTreeDepth(const size_t treeDepth_); + size_t quantizeTreeDepth(void) const; + + // Suppress all warning messages. Error messages are still reported. + void quiet(const bool quiet_); + bool quiet(void) const; + + // The type of rendering intent + void renderingIntent(const RenderingIntent renderingIntent_); + RenderingIntent renderingIntent(void) const; + + // Units of image resolution + void resolutionUnits(const ResolutionType resolutionUnits_); + ResolutionType resolutionUnits(void) const; + + // The number of pixel rows in the image + size_t rows(void) const; + + // Image scene number + void scene(const size_t scene_); + size_t scene(void) const; + + // Width and height of a raw image + void size(const Geometry &geometry_); + Geometry size(void) const; + + // enabled/disable stroke anti-aliasing + void strokeAntiAlias(const bool flag_); + bool strokeAntiAlias(void) const; + + // Color to use when drawing object outlines + void strokeColor(const Color &strokeColor_); + Color strokeColor(void) const; + + // Specify the pattern of dashes and gaps used to stroke + // paths. The strokeDashArray represents a zero-terminated array + // of numbers that specify the lengths of alternating dashes and + // gaps in pixels. If an odd number of values is provided, then + // the list of values is repeated to yield an even number of + // values. A typical strokeDashArray_ array might contain the + // members 5 3 2 0, where the zero value indicates the end of the + // pattern array. + void strokeDashArray(const double *strokeDashArray_); + const double *strokeDashArray(void) const; + + // While drawing using a dash pattern, specify distance into the + // dash pattern to start the dash (default 0). + void strokeDashOffset(const double strokeDashOffset_); + double strokeDashOffset(void) const; + + // Specify the shape to be used at the end of open subpaths when + // they are stroked. Values of LineCap are UndefinedCap, ButtCap, + // RoundCap, and SquareCap. + void strokeLineCap(const LineCap lineCap_); + LineCap strokeLineCap(void) const; + + // Specify the shape to be used at the corners of paths (or other + // vector shapes) when they are stroked. Values of LineJoin are + // UndefinedJoin, MiterJoin, RoundJoin, and BevelJoin. + void strokeLineJoin(const LineJoin lineJoin_); + LineJoin strokeLineJoin(void) const; + + // Specify miter limit. When two line segments meet at a sharp + // angle and miter joins have been specified for 'lineJoin', it is + // possible for the miter to extend far beyond the thickness of + // the line stroking the path. The miterLimit' imposes a limit on + // the ratio of the miter length to the 'lineWidth'. The default + // value of this parameter is 4. + void strokeMiterLimit(const size_t miterLimit_); + size_t strokeMiterLimit(void) const; + + // Pattern image to use while stroking object outlines. + void strokePattern(const Image &strokePattern_); + Image strokePattern(void) const; + + // Stroke width for drawing vector objects (default one) + void strokeWidth(const double strokeWidth_); + double strokeWidth(void) const; + + // Subimage of an image sequence + void subImage(const size_t subImage_); + size_t subImage(void) const; + + // Number of images relative to the base image + void subRange(const size_t subRange_); + size_t subRange(void) const; + + // Anti-alias Postscript and TrueType fonts (default true) + void textAntiAlias(const bool flag_); + bool textAntiAlias(void) const; + + // Render text right-to-left or left-to-right. + void textDirection(DirectionType direction_); + DirectionType textDirection() const; + + // Annotation text encoding (e.g. "UTF-16") + void textEncoding(const std::string &encoding_); + std::string textEncoding(void) const; + + // Text gravity. + void textGravity(GravityType gravity_); + GravityType textGravity() const; + + // Text inter-line spacing + void textInterlineSpacing(double spacing_); + double textInterlineSpacing(void) const; + + // Text inter-word spacing + void textInterwordSpacing(double spacing_); + double textInterwordSpacing(void) const; + + // Text inter-character kerning + void textKerning(double kerning_); + double textKerning(void) const; + + // Text undercolor box + void textUnderColor(const Color &underColor_); + Color textUnderColor(void) const; + + // Number of colors in the image + size_t totalColors(void) const; + + // Rotation to use when annotating with text or drawing + void transformRotation(const double angle_); + + // Skew to use in X axis when annotating with text or drawing + void transformSkewX(const double skewx_); + + // Skew to use in Y axis when annotating with text or drawing + void transformSkewY(const double skewy_); + + // Image representation type (also see type operation) + // Available types: + // Bilevel Grayscale GrayscaleMatte + // Palette PaletteMatte TrueColor + // TrueColorMatte ColorSeparation ColorSeparationMatte + void type(const ImageType type_); + ImageType type(void) const; + + // Print detailed information about the image + void verbose(const bool verboseFlag_); + bool verbose(void) const; + + // Virtual pixel method + void virtualPixelMethod(const VirtualPixelMethod virtualPixelMethod_); + VirtualPixelMethod virtualPixelMethod(void) const; + + // X11 display to display to, obtain fonts from, or to capture + // image from + void x11Display(const std::string &display_); + std::string x11Display(void) const; + + // x resolution of the image + double xResolution(void) const; + + // y resolution of the image + double yResolution(void) const; + + // Adaptive-blur image with specified blur factor + // The radius_ parameter specifies the radius of the Gaussian, in + // pixels, not counting the center pixel. The sigma_ parameter + // specifies the standard deviation of the Laplacian, in pixels. + void adaptiveBlur(const double radius_=0.0,const double sigma_=1.0); + + // This is shortcut function for a fast interpolative resize using mesh + // interpolation. It works well for small resizes of less than +/- 50% + // of the original image size. For larger resizing on images a full + // filtered and slower resize function should be used instead. + void adaptiveResize(const Geometry &geometry_); + + // Adaptively sharpens the image by sharpening more intensely near image + // edges and less intensely far from edges. We sharpen the image with a + // Gaussian operator of the given radius and standard deviation (sigma). + // For reasonable results, radius should be larger than sigma. + void adaptiveSharpen(const double radius_=0.0,const double sigma_=1.0); + void adaptiveSharpenChannel(const ChannelType channel_, + const double radius_=0.0,const double sigma_=1.0); + + // Local adaptive threshold image + // http://www.dai.ed.ac.uk/HIPR2/adpthrsh.htm + // Width x height define the size of the pixel neighborhood + // bias = constant to subtract from pixel neighborhood mean + void adaptiveThreshold(const size_t width_,const size_t height_, + const double bias_=0.0); + + // Add noise to image with specified noise type + void addNoise(const NoiseType noiseType_); + void addNoiseChannel(const ChannelType channel_, + const NoiseType noiseType_); + + // Transform image by specified affine (or free transform) matrix. + void affineTransform(const DrawableAffine &affine); + + // Set or attenuate the alpha channel in the image. If the image + // pixels are opaque then they are set to the specified alpha + // value, otherwise they are blended with the supplied alpha + // value. The value of alpha_ ranges from 0 (completely opaque) + // to QuantumRange. The defines OpaqueAlpha and TransparentAlpha are + // available to specify completely opaque or completely + // transparent, respectively. + void alpha(const unsigned int alpha_); + + // AlphaChannel() activates, deactivates, resets, or sets the alpha + // channel. + void alphaChannel(AlphaChannelOption alphaOption_); + + // + // Annotate image (draw text on image) + // + // Gravity effects text placement in bounding area according to rules: + // NorthWestGravity text bottom-left corner placed at top-left + // NorthGravity text bottom-center placed at top-center + // NorthEastGravity text bottom-right corner placed at top-right + // WestGravity text left-center placed at left-center + // CenterGravity text center placed at center + // EastGravity text right-center placed at right-center + // SouthWestGravity text top-left placed at bottom-left + // SouthGravity text top-center placed at bottom-center + // SouthEastGravity text top-right placed at bottom-right + + // Annotate using specified text, and placement location + void annotate(const std::string &text_,const Geometry &location_); + + // Annotate using specified text, bounding area, and placement + // gravity + void annotate(const std::string &text_,const Geometry &boundingArea_, + const GravityType gravity_); + + // Annotate with text using specified text, bounding area, + // placement gravity, and rotation. + void annotate(const std::string &text_,const Geometry &boundingArea_, + const GravityType gravity_,const double degrees_); + + // Annotate with text (bounding area is entire image) and placement + // gravity. + void annotate(const std::string &text_,const GravityType gravity_); + + // Inserts the artifact with the specified name and value into + // the artifact tree of the image. + void artifact(const std::string &name_,const std::string &value_); + + // Returns the value of the artifact with the specified name. + std::string artifact(const std::string &name_) const; + + // Access/Update a named image attribute + void attribute(const std::string name_,const char *value_); + void attribute(const std::string name_,const std::string value_); + std::string attribute(const std::string name_) const; + + // Extracts the 'mean' from the image and adjust the image to try + // make set its gamma appropriatally. + void autoGamma(void); + void autoGammaChannel(const ChannelType channel_); + + // Adjusts the levels of a particular image channel by scaling the + // minimum and maximum values to the full quantum range. + void autoLevel(void); + void autoLevelChannel(const ChannelType channel_); + + // Adjusts an image so that its orientation is suitable for viewing. + void autoOrient(void); + + // Forces all pixels below the threshold into black while leaving all + // pixels at or above the threshold unchanged. + void blackThreshold(const std::string &threshold_); + void blackThresholdChannel(const ChannelType channel_, + const std::string &threshold_); + + // Simulate a scene at nighttime in the moonlight. + void blueShift(const double factor_=1.5); + + // Blur image with specified blur factor + // The radius_ parameter specifies the radius of the Gaussian, in + // pixels, not counting the center pixel. The sigma_ parameter + // specifies the standard deviation of the Laplacian, in pixels. + void blur(const double radius_=0.0,const double sigma_=1.0); + void blurChannel(const ChannelType channel_,const double radius_=0.0, + const double sigma_=1.0); + + // Border image (add border to image) + void border(const Geometry &geometry_=borderGeometryDefault); + + // Changes the brightness and/or contrast of an image. It converts the + // brightness and contrast parameters into slope and intercept and calls + // a polynomical function to apply to the image. + void brightnessContrast(const double brightness_=0.0, + const double contrast_=0.0); + void brightnessContrastChannel(const ChannelType channel_, + const double brightness_=0.0,const double contrast_=0.0); + + // Uses a multi-stage algorithm to detect a wide range of edges in images. + void cannyEdge(const double radius_=0.0,const double sigma_=1.0, + const double lowerPercent_=0.1,const double upperPercent_=0.3); + + // Accepts a lightweight Color Correction Collection + // (CCC) file which solely contains one or more color corrections and + // applies the correction to the image. + void cdl(const std::string &cdl_); + + // Extract channel from image + void channel(const ChannelType channel_); + + // Charcoal effect image (looks like charcoal sketch) + // The radius_ parameter specifies the radius of the Gaussian, in + // pixels, not counting the center pixel. The sigma_ parameter + // specifies the standard deviation of the Laplacian, in pixels. + void charcoal(const double radius_=0.0,const double sigma_=1.0); + + // Chop image (remove vertical or horizontal subregion of image) + // FIXME: describe how geometry argument is used to select either + // horizontal or vertical subregion of image. + void chop(const Geometry &geometry_); + + // Chromaticity blue primary point. + void chromaBluePrimary(const double x_,const double y_,const double z_); + void chromaBluePrimary(double *x_,double *y_,double *z_) const; + + // Chromaticity green primary point. + void chromaGreenPrimary(const double x_,const double y_,const double z_); + void chromaGreenPrimary(double *x_,double *y_,double *z_) const; + + // Chromaticity red primary point. + void chromaRedPrimary(const double x_,const double y_,const double z_); + void chromaRedPrimary(double *x_,double *y_,double *z_) const; + + // Chromaticity white point. + void chromaWhitePoint(const double x_,const double y_,const double z_); + void chromaWhitePoint(double *x_,double *y_,double *z_) const; + + // Set each pixel whose value is below zero to zero and any the + // pixel whose value is above the quantum range to the quantum range (e.g. + // 65535) otherwise the pixel value remains unchanged. + void clamp(void); + void clampChannel(const ChannelType channel_); + + // Sets the image clip mask based on any clipping path information + // if it exists. + void clip(void); + void clipPath(const std::string pathname_,const bool inside_); + + // Apply a color lookup table (CLUT) to the image. + void clut(const Image &clutImage_,const PixelInterpolateMethod method); + void clutChannel(const ChannelType channel_,const Image &clutImage_, + const PixelInterpolateMethod method); + + // Colorize image with pen color, using specified percent alpha. + void colorize(const unsigned int alpha_,const Color &penColor_); + + // Colorize image with pen color, using specified percent alpha + // for red, green, and blue quantums + void colorize(const unsigned int alphaRed_,const unsigned int alphaGreen_, + const unsigned int alphaBlue_,const Color &penColor_); + + // Color at colormap position index_ + void colorMap(const size_t index_,const Color &color_); + Color colorMap(const size_t index_) const; + + // Apply a color matrix to the image channels. The user supplied + // matrix may be of order 1 to 5 (1x1 through 5x5). + void colorMatrix(const size_t order_,const double *color_matrix_); + + // Compare current image with another image + // False is returned if the images are not identical. + bool compare(const Image &reference_) const; + + // Compare current image with another image + // Returns the distortion based on the specified metric. + double compare(const Image &reference_,const MetricType metric_); + double compareChannel(const ChannelType channel_, + const Image &reference_, + const MetricType metric_ ); + + // Compare current image with another image + // Sets the distortion and returns the difference image. + Image compare(const Image &reference_,const MetricType metric_, + double *distortion); + Image compareChannel(const ChannelType channel_,const Image &reference_, + const MetricType metric_,double *distortion); + + // Compose an image onto another at specified offset and using + // specified algorithm + void composite(const Image &compositeImage_,const Geometry &offset_, + const CompositeOperator compose_=InCompositeOp); + void composite(const Image &compositeImage_,const GravityType gravity_, + const CompositeOperator compose_=InCompositeOp); + void composite(const Image &compositeImage_,const ::ssize_t xOffset_, + const ::ssize_t yOffset_,const CompositeOperator compose_=InCompositeOp); + + // Determines the connected-components of the image + void connectedComponents(const size_t connectivity_); + + // Contrast image (enhance intensity differences in image) + void contrast(const bool sharpen_); + + // A simple image enhancement technique that attempts to improve the + // contrast in an image by 'stretching' the range of intensity values + // it contains to span a desired range of values. It differs from the + // more sophisticated histogram equalization in that it can only apply a + // linear scaling function to the image pixel values. As a result the + // 'enhancement' is less harsh. + void contrastStretch(const double blackPoint_,const double whitePoint_); + void contrastStretchChannel(const ChannelType channel_, + const double blackPoint_,const double whitePoint_); + + // Convolve image. Applies a user-specified convolution to the image. + // order_ represents the number of columns and rows in the filter kernel. + // kernel_ is an array of doubles representing the convolution kernel. + void convolve(const size_t order_,const double *kernel_); + + // Copies pixels from the source image as defined by the geometry the + // destination image at the specified offset. + void copyPixels(const Image &source_,const Geometry &geometry_, + const Offset &offset_); + + // Crop image (subregion of original image) + void crop(const Geometry &geometry_); + + // Cycle image colormap + void cycleColormap(const ::ssize_t amount_); + + // Converts cipher pixels to plain pixels. + void decipher(const std::string &passphrase_); + + // Tagged image format define. Similar to the defineValue() method + // except that passing the flag_ value 'true' creates a value-less + // define with that format and key. Passing the flag_ value 'false' + // removes any existing matching definition. The method returns 'true' + // if a matching key exists, and 'false' if no matching key exists. + void defineSet(const std::string &magick_,const std::string &key_, + bool flag_); + bool defineSet(const std::string &magick_,const std::string &key_) const; + + // Tagged image format define (set/access coder-specific option) The + // magick_ option specifies the coder the define applies to. The key_ + // option provides the key specific to that coder. The value_ option + // provides the value to set (if any). See the defineSet() method if the + // key must be removed entirely. + void defineValue(const std::string &magick_,const std::string &key_, + const std::string &value_); + std::string defineValue(const std::string &magick_, + const std::string &key_) const; + + // Removes skew from the image. Skew is an artifact that occurs in scanned + // images because of the camera being misaligned, imperfections in the + // scanning or surface, or simply because the paper was not placed + // completely flat when scanned. The value of threshold_ ranges from 0 + // to QuantumRange. + void deskew(const double threshold_); + + // Despeckle image (reduce speckle noise) + void despeckle(void); + + // Display image on screen + void display(void); + + // Distort image. distorts an image using various distortion methods, by + // mapping color lookups of the source image to a new destination image + // usally of the same size as the source image, unless 'bestfit' is set to + // true. + void distort(const DistortMethod method_, + const size_t numberArguments_,const double *arguments_, + const bool bestfit_=false); + + // Draw on image using a single drawable + void draw(const Drawable &drawable_); + + // Draw on image using a drawable list + void draw(const std::vector &drawable_); + + // Edge image (hilight edges in image) + void edge(const double radius_=0.0); + + // Emboss image (hilight edges with 3D effect) + // The radius_ parameter specifies the radius of the Gaussian, in + // pixels, not counting the center pixel. The sigma_ parameter + // specifies the standard deviation of the Laplacian, in pixels. + void emboss(const double radius_=0.0,const double sigma_=1.0); + + // Converts pixels to cipher-pixels. + void encipher(const std::string &passphrase_); + + // Enhance image (minimize noise) + void enhance(void); + + // Equalize image (histogram equalization) + void equalize(void); + + // Erase image to current "background color" + void erase(void); + + // Apply a value with an arithmetic, relational, or logical operator. + void evaluate(const ChannelType channel_, + const MagickEvaluateOperator operator_,double rvalue_); + + // Apply a value with an arithmetic, relational, or logical operator. + void evaluate(const ChannelType channel_,const MagickFunction function_, + const size_t number_parameters_,const double *parameters_); + + // Apply a value with an arithmetic, relational, or logical operator. + void evaluate(const ChannelType channel_,const ::ssize_t x_, + const ::ssize_t y_,const size_t columns_,const size_t rows_, + const MagickEvaluateOperator operator_,const double rvalue_); + + // Extend the image as defined by the geometry. + void extent(const Geometry &geometry_); + void extent(const Geometry &geometry_,const Color &backgroundColor); + void extent(const Geometry &geometry_,const Color &backgroundColor, + const GravityType gravity_); + void extent(const Geometry &geometry_,const GravityType gravity_); + + // Flip image (reflect each scanline in the vertical direction) + void flip(void); + + // Floodfill pixels matching color (within fuzz factor) of target + // pixel(x,y) with replacement alpha value. + void floodFillAlpha(const ::ssize_t x_,const ::ssize_t y_, + const unsigned int alpha_,const bool invert_=false); + + // Floodfill designated area with replacement alpha value + void floodFillAlpha(const ssize_t x_,const ssize_t y_, + const unsigned int alpha_,const Color &target_,const bool invert_=false); + + // Flood-fill color across pixels that match the color of the + // target pixel and are neighbors of the target pixel. + // Uses current fuzz setting when determining color match. + void floodFillColor(const Geometry &point_,const Color &fillColor_, + const bool invert_=false); + void floodFillColor(const ::ssize_t x_,const ::ssize_t y_, + const Color &fillColor_,const bool invert_=false); + + // Flood-fill color across pixels starting at target-pixel and + // stopping at pixels matching specified border color. + // Uses current fuzz setting when determining color match. + void floodFillColor(const Geometry &point_,const Color &fillColor_, + const Color &borderColor_,const bool invert_=false); + void floodFillColor(const ::ssize_t x_,const ::ssize_t y_, + const Color &fillColor_,const Color &borderColor_, + const bool invert_=false); + + // Flood-fill texture across pixels that match the color of the + // target pixel and are neighbors of the target pixel. + // Uses current fuzz setting when determining color match. + void floodFillTexture(const Geometry &point_,const Image &texture_, + const bool invert_=false); + void floodFillTexture(const ::ssize_t x_,const ::ssize_t y_, + const Image &texture_,const bool invert_=false); + + // Flood-fill texture across pixels starting at target-pixel and + // stopping at pixels matching specified border color. + // Uses current fuzz setting when determining color match. + void floodFillTexture(const Geometry &point_,const Image &texture_, + const Color &borderColor_,const bool invert_=false); + void floodFillTexture(const ::ssize_t x_,const ::ssize_t y_, + const Image &texture_,const Color &borderColor_, + const bool invert_=false); + + // Flop image (reflect each scanline in the horizontal direction) + void flop(void); + + // Obtain font metrics for text string given current font, + // pointsize, and density settings. + void fontTypeMetrics(const std::string &text_,TypeMetric *metrics); + + // Obtain multi line font metrics for text string given current font, + // pointsize, and density settings. + void fontTypeMetricsMultiline(const std::string &text_, + TypeMetric *metrics); + + // Frame image + void frame(const Geometry &geometry_=frameGeometryDefault); + void frame(const size_t width_,const size_t height_, + const ::ssize_t innerBevel_=6,const ::ssize_t outerBevel_=6); + + // Applies a mathematical expression to the image. + void fx(const std::string expression_); + void fx(const std::string expression_,const Magick::ChannelType channel_); + + // Gamma correct image + void gamma(const double gamma_); + void gamma(const double gammaRed_,const double gammaGreen_, + const double gammaBlue_); + + // Gaussian blur image + // The number of neighbor pixels to be included in the convolution + // mask is specified by 'radius_'. The standard deviation of the + // gaussian bell curve is specified by 'sigma_'. + void gaussianBlur(const double radius_,const double sigma_); + void gaussianBlurChannel(const ChannelType channel_,const double radius_, + const double sigma_); + + // Transfers read-only pixels from the image to the pixel cache as + // defined by the specified region + const Quantum *getConstPixels(const ::ssize_t x_, const ::ssize_t y_, + const size_t columns_,const size_t rows_) const; + + // Obtain immutable image pixel metacontent (valid for PseudoClass images) + const void *getConstMetacontent(void) const; + + // Obtain mutable image pixel metacontent (valid for PseudoClass images) + void *getMetacontent(void); + + // Transfers pixels from the image to the pixel cache as defined + // by the specified region. Modified pixels may be subsequently + // transferred back to the image via syncPixels. This method is + // valid for DirectClass images. + Quantum *getPixels(const ::ssize_t x_,const ::ssize_t y_, + const size_t columns_,const size_t rows_); + + // Converts the colors in the image to gray. + void grayscale(const PixelIntensityMethod method_); + + // Apply a color lookup table (Hald CLUT) to the image. + void haldClut(const Image &clutImage_); + + // Identifies lines in the image. + void houghLine(const size_t width_,const size_t height_, + const size_t threshold_=40); + + // Identifies the potential color type of the image. This method can be + // used to detect if the type can be changed to GrayScale. + ImageType identifyType(void) const; + + // Implode image (special effect) + void implode(const double factor_); + + // Implements the inverse discrete Fourier transform (DFT) of the image + // either as a magnitude / phase or real / imaginary image pair. + void inverseFourierTransform(const Image &phase_); + void inverseFourierTransform(const Image &phase_,const bool magnitude_); + + // An edge preserving noise reduction filter. + void kuwahara(const double radius_=0.0,const double sigma_=1.0); + void kuwaharaChannel(const ChannelType channel_,const double radius_=0.0, + const double sigma_=1.0); + + // Level image. Adjust the levels of the image by scaling the + // colors falling between specified white and black points to the + // full available quantum range. The parameters provided represent + // the black, mid (gamma), and white points. The black point + // specifies the darkest color in the image. Colors darker than + // the black point are set to zero. Mid point (gamma) specifies a + // gamma correction to apply to the image. White point specifies + // the lightest color in the image. Colors brighter than the + // white point are set to the maximum quantum value. The black and + // white point have the valid range 0 to QuantumRange while mid (gamma) + // has a useful range of 0 to ten. + void level(const double blackPoint_,const double whitePoint_, + const double gamma_=1.0); + void levelChannel(const ChannelType channel_,const double blackPoint_, + const double whitePoint_,const double gamma_=1.0); + + // Maps the given color to "black" and "white" values, linearly spreading + // out the colors, and level values on a channel by channel bases, as + // per level(). The given colors allows you to specify different level + // ranges for each of the color channels separately. + void levelColors(const Color &blackColor_,const Color &whiteColor_, + const bool invert_=true); + void levelColorsChannel(const ChannelType channel_, + const Color &blackColor_,const Color &whiteColor_, + const bool invert_=true); + + // Levelize applies the reversed level operation to just the specific + // channels specified.It compresses the full range of color values, so + // that they lie between the given black and white points. Gamma is + // applied before the values are mapped. + void levelize(const double blackPoint_,const double whitePoint_, + const double gamma_=1.0); + void levelizeChannel(const ChannelType channel_,const double blackPoint_, + const double whitePoint_,const double gamma_=1.0); + + // Discards any pixels below the black point and above the white point and + // levels the remaining pixels. + void linearStretch(const double blackPoint_,const double whitePoint_); + + // Rescales image with seam carving. + void liquidRescale(const Geometry &geometry_); + + // Local contrast enhancement + void localContrast(const double radius_,const double strength_); + + // Magnify image by integral size + void magnify(void); + + // Remap image colors with closest color from reference image + void map(const Image &mapImage_,const bool dither_=false); + + // Filter image by replacing each pixel component with the median + // color in a circular neighborhood + void medianFilter(const double radius_=0.0); + + // Reduce image by integral size + void minify(void); + + // Modulate percent hue, saturation, and brightness of an image + void modulate(const double brightness_,const double saturation_, + const double hue_); + + // Returns the normalized moments of one or more image channels. + ImageMoments moments(void) const; + + // Applies a kernel to the image according to the given mophology method. + void morphology(const MorphologyMethod method_,const std::string kernel_, + const ssize_t iterations_=1); + void morphology(const MorphologyMethod method_, + const KernelInfoType kernel_,const std::string arguments_, + const ssize_t iterations_=1); + void morphologyChannel(const ChannelType channel_, + const MorphologyMethod method_,const std::string kernel_, + const ssize_t iterations_=1); + void morphologyChannel(const ChannelType channel_, + const MorphologyMethod method_,const KernelInfoType kernel_, + const std::string arguments_,const ssize_t iterations_=1); + + // Motion blur image with specified blur factor + // The radius_ parameter specifies the radius of the Gaussian, in + // pixels, not counting the center pixel. The sigma_ parameter + // specifies the standard deviation of the Laplacian, in pixels. + // The angle_ parameter specifies the angle the object appears + // to be comming from (zero degrees is from the right). + void motionBlur(const double radius_,const double sigma_, + const double angle_); + + // Negate colors in image. Set grayscale to only negate grayscale + // values in image. + void negate(const bool grayscale_=false); + void negateChannel(const ChannelType channel_,const bool grayscale_=false); + + // Normalize image (increase contrast by normalizing the pixel + // values to span the full range of color values) + void normalize(void); + + // Oilpaint image (image looks like oil painting) + void oilPaint(const double radius_=0.0,const double sigma=1.0); + + // Change color of opaque pixel to specified pen color. + void opaque(const Color &opaqueColor_,const Color &penColor_, + const bool invert_=false); + + // Perform a ordered dither based on a number of pre-defined dithering + // threshold maps, but over multiple intensity levels. + void orderedDither(std::string thresholdMap_); + void orderedDitherChannel(const ChannelType channel_, + std::string thresholdMap_); + + // Set each pixel whose value is less than epsilon to epsilon or + // -epsilon (whichever is closer) otherwise the pixel value remains + // unchanged. + void perceptible(const double epsilon_); + void perceptibleChannel(const ChannelType channel_,const double epsilon_); + + // Returns the perceptual hash for this image. + Magick::ImagePerceptualHash perceptualHash() const; + + // Ping is similar to read except only enough of the image is read + // to determine the image columns, rows, and filesize. Access the + // columns(), rows(), and fileSize() attributes after invoking + // ping. The image data is not valid after calling ping. + void ping(const std::string &imageSpec_); + + // Ping is similar to read except only enough of the image is read + // to determine the image columns, rows, and filesize. Access the + // columns(), rows(), and fileSize() attributes after invoking + // ping. The image data is not valid after calling ping. + void ping(const Blob &blob_); + + // Get/set pixel color at location x & y. + void pixelColor(const ::ssize_t x_,const ::ssize_t y_,const Color &color_); + Color pixelColor(const ::ssize_t x_,const ::ssize_t y_ ) const; + + // Simulates a Polaroid picture. + void polaroid(const std::string &caption_,const double angle_, + const PixelInterpolateMethod method_); + + // Reduces the image to a limited number of colors for a "poster" effect. + void posterize(const size_t levels_,const DitherMethod method_); + void posterizeChannel(const ChannelType channel_,const size_t levels_, + const DitherMethod method_); + + // Execute a named process module using an argc/argv syntax similar to + // that accepted by a C 'main' routine. An exception is thrown if the + // requested process module doesn't exist, fails to load, or fails during + // execution. + void process(std::string name_,const ::ssize_t argc_,const char **argv_); + + // Add or remove a named profile to/from the image. Remove the + // profile by passing an empty Blob (e.g. Blob()). Valid names are + // "*", "8BIM", "ICM", "IPTC", or a user/format-defined profile name. + void profile(const std::string name_,const Blob &colorProfile_); + + // Retrieve a named profile from the image. Valid names are: + // "8BIM", "8BIMTEXT", "APP1", "APP1JPEG", "ICC", "ICM", & "IPTC" + // or an existing user/format-defined profile name. + Blob profile(const std::string name_) const; + + // Quantize image (reduce number of colors) + void quantize(const bool measureError_=false); + + // Raise image (lighten or darken the edges of an image to give a + // 3-D raised or lowered effect) + void raise(const Geometry &geometry_=raiseGeometryDefault, + const bool raisedFlag_=false); + + // Random threshold image. + // + // Changes the value of individual pixels based on the intensity + // of each pixel compared to a random threshold. The result is a + // low-contrast, two color image. + void randomThreshold(const double low_,const double high_); + void randomThresholdChannel(const ChannelType channel_,const double low_, + const double high_); + + // Read single image frame from in-memory BLOB + void read(const Blob &blob_); + + // Read single image frame of specified size from in-memory BLOB + void read(const Blob &blob_,const Geometry &size_); + + // Read single image frame of specified size and depth from + // in-memory BLOB + void read(const Blob &blob_,const Geometry &size_,const size_t depth_); + + // Read single image frame of specified size, depth, and format + // from in-memory BLOB + void read(const Blob &blob_,const Geometry &size_,const size_t depth_, + const std::string &magick_); + + // Read single image frame of specified size, and format from + // in-memory BLOB + void read(const Blob &blob_,const Geometry &size_, + const std::string &magick_); + + // Read single image frame of specified size into current object + void read(const Geometry &size_,const std::string &imageSpec_); + + // Read single image frame from an array of raw pixels, with + // specified storage type (ConstituteImage), e.g. + // image.read( 640, 480, "RGB", 0, pixels ); + void read(const size_t width_,const size_t height_,const std::string &map_, + const StorageType type_,const void *pixels_); + + // Read single image frame into current object + void read(const std::string &imageSpec_); + + // Associate a mask with the image. The mask must be the same dimensions + // as the image. Pass an invalid image to unset an existing mask. + void readMask(const Image &mask_); + Image readMask(void) const; + + // Transfers one or more pixel components from a buffer or file + // into the image pixel cache of an image. + // Used to support image decoders. + void readPixels(const QuantumType quantum_,const unsigned char *source_); + + // Reduce noise in image using a noise peak elimination filter + void reduceNoise(void); + void reduceNoise(const size_t order_); + + // Resets the image page canvas and position. + void repage(); + + // Resize image in terms of its pixel size. + void resample(const Point &density_); + + // Resize image to specified size. + void resize(const Geometry &geometry_); + + // Roll image (rolls image vertically and horizontally) by specified + // number of columnms and rows) + void roll(const Geometry &roll_); + void roll(const size_t columns_,const size_t rows_); + + // Rotate image clockwise by specified number of degrees. Specify a + // negative number for degrees to rotate counter-clockwise. + void rotate(const double degrees_); + + // Rotational blur image. + void rotationalBlur(const double angle_); + void rotationalBlurChannel(const ChannelType channel_,const double angle_); + + // Resize image by using pixel sampling algorithm + void sample(const Geometry &geometry_); + + // Resize image by using simple ratio algorithm + void scale(const Geometry &geometry_); + + // Segment (coalesce similar image components) by analyzing the + // histograms of the color components and identifying units that + // are homogeneous with the fuzzy c-means technique. Also uses + // QuantizeColorSpace and Verbose image attributes + void segment(const double clusterThreshold_=1.0, + const double smoothingThreshold_=1.5); + + // Selectively blur pixels within a contrast threshold. It is similar to + // the unsharpen mask that sharpens everything with contrast above a + // certain threshold. + void selectiveBlur(const double radius_,const double sigma_, + const double threshold_); + void selectiveBlurChannel(const ChannelType channel_,const double radius_, + const double sigma_,const double threshold_); + + // Separates a channel from the image and returns it as a grayscale image. + Image separate(const ChannelType channel_) const; + + // Applies a special effect to the image, similar to the effect achieved in + // a photo darkroom by sepia toning. Threshold ranges from 0 to + // QuantumRange and is a measure of the extent of the sepia toning. + // A threshold of 80% is a good starting point for a reasonable tone. + void sepiaTone(const double threshold_); + + // Sets meanErrorPerPixel, normalizedMaxError, and normalizedMeanError + // in the current image. False is returned if the images are not identical. + bool setColorMetric(const Image &reference_); + + // Allocates a pixel cache region to store image pixels as defined + // by the region rectangle. This area is subsequently transferred + // from the pixel cache to the image via syncPixels. + Quantum *setPixels(const ::ssize_t x_, const ::ssize_t y_, + const size_t columns_,const size_t rows_); + + // Shade image using distant light source + void shade(const double azimuth_=30,const double elevation_=30, + const bool colorShading_=false); + + // Simulate an image shadow + void shadow(const double percentAlpha_=80.0,const double sigma_=0.5, + const ssize_t x_=5,const ssize_t y_=5); + + // Sharpen pixels in image + // The radius_ parameter specifies the radius of the Gaussian, in + // pixels, not counting the center pixel. The sigma_ parameter + // specifies the standard deviation of the Laplacian, in pixels. + void sharpen(const double radius_=0.0,const double sigma_=1.0); + void sharpenChannel(const ChannelType channel_,const double radius_=0.0, + const double sigma_=1.0); + + // Shave pixels from image edges. + void shave(const Geometry &geometry_); + + // Shear image (create parallelogram by sliding image by X or Y axis) + void shear(const double xShearAngle_,const double yShearAngle_); + + // adjust the image contrast with a non-linear sigmoidal contrast algorithm + void sigmoidalContrast(const bool sharpen_,const double contrast, + const double midpoint=QuantumRange/2.0); + + // Image signature. Set force_ to true in order to re-calculate + // the signature regardless of whether the image data has been + // modified. + std::string signature(const bool force_=false) const; + + // Simulates a pencil sketch. We convolve the image with a Gaussian + // operator of the given radius and standard deviation (sigma). For + // reasonable results, radius should be larger than sigma. Use a + // radius of 0 and SketchImage() selects a suitable radius for you. + void sketch(const double radius_=0.0,const double sigma_=1.0, + const double angle_=0.0); + + // Solarize image (similar to effect seen when exposing a + // photographic film to light during the development process) + void solarize(const double factor_=50.0); + + // Sparse color image, given a set of coordinates, interpolates the colors + // found at those coordinates, across the whole image, using various + // methods. + void sparseColor(const ChannelType channel_, + const SparseColorMethod method_,const size_t numberArguments_, + const double *arguments_); + + // Splice the background color into the image. + void splice(const Geometry &geometry_); + void splice(const Geometry &geometry_,const Color &backgroundColor_); + void splice(const Geometry &geometry_,const Color &backgroundColor_, + const GravityType gravity_); + + // Spread pixels randomly within image by specified ammount + void spread(const double amount_=3.0); + + // Returns the statistics for this image. + Magick::ImageStatistics statistics() const; + + // Add a digital watermark to the image (based on second image) + void stegano(const Image &watermark_); + + // Create an image which appears in stereo when viewed with + // red-blue glasses (Red image on left, blue on right) + void stereo(const Image &rightImage_); + + // Strip strips an image of all profiles and comments. + void strip(void); + + // Search for the specified image at EVERY possible location in this image. + // This is slow! very very slow.. It returns a similarity image such that + // an exact match location is completely white and if none of the pixels + // match, black, otherwise some gray level in-between. + Image subImageSearch(const Image &reference_,const MetricType metric_, + Geometry *offset_,double *similarityMetric_, + const double similarityThreshold=(-1.0)); + + // Swirl image (image pixels are rotated by degrees) + void swirl(const double degrees_); + + // Transfers the image cache pixels to the image. + void syncPixels(void); + + // Channel a texture on image background + void texture(const Image &texture_); + + // Threshold image + void threshold(const double threshold_); + + // Resize image to thumbnail size + void thumbnail(const Geometry &geometry_); + + // Applies a color vector to each pixel in the image. The length of the + // vector is 0 for black and white and at its maximum for the midtones. + // The vector weighting function is f(x)=(1-(4.0*((x-0.5)*(x-0.5)))) + void tint(const std::string opacity_); + + // Origin of coordinate system to use when annotating with text or drawing + void transformOrigin(const double x_,const double y_); + + // Reset transformation parameters to default + void transformReset(void); + + // Scale to use when annotating with text or drawing + void transformScale(const double sx_,const double sy_); + + // Add matte image to image, setting pixels matching color to + // transparent + void transparent(const Color &color_,const bool inverse_=false); + + // Add matte image to image, for all the pixels that lies in between + // the given two color + void transparentChroma(const Color &colorLow_,const Color &colorHigh_); + + // Creates a horizontal mirror image by reflecting the pixels around the + // central y-axis while rotating them by 90 degrees. + void transpose(void); + + // Creates a vertical mirror image by reflecting the pixels around the + // central x-axis while rotating them by 270 degrees. + void transverse(void); + + // Trim edges that are the background color from the image + void trim(void); + + // Returns the unique colors of an image. + Image uniqueColors(void) const; + + // Replace image with a sharpened version of the original image + // using the unsharp mask algorithm. + // radius_ + // the radius of the Gaussian, in pixels, not counting the + // center pixel. + // sigma_ + // the standard deviation of the Gaussian, in pixels. + // amount_ + // the percentage of the difference between the original and + // the blur image that is added back into the original. + // threshold_ + // the threshold in pixels needed to apply the diffence amount. + void unsharpmask(const double radius_,const double sigma_, + const double amount_,const double threshold_); + void unsharpmaskChannel(const ChannelType channel_,const double radius_, + const double sigma_,const double amount_,const double threshold_); + + // Softens the edges of the image in vignette style. + void vignette(const double radius_=0.0,const double sigma_=1.0, + const ssize_t x_=0,const ssize_t y_=0); + + // Map image pixels to a sine wave + void wave(const double amplitude_=25.0,const double wavelength_=150.0); + + // Removes noise from the image using a wavelet transform. + void waveletDenoise(const double threshold_,const double softness_); + + // Forces all pixels above the threshold into white while leaving all + // pixels at or below the threshold unchanged. + void whiteThreshold(const std::string &threshold_); + void whiteThresholdChannel(const ChannelType channel_, + const std::string &threshold_); + + // Write single image frame to in-memory BLOB, with optional + // format and adjoin parameters. + void write(Blob *blob_); + void write(Blob *blob_,const std::string &magick_); + void write(Blob *blob_,const std::string &magick_,const size_t depth_); + + // Write single image frame to an array of pixels with storage + // type specified by user (DispatchImage), e.g. + // image.write( 0, 0, 640, 1, "RGB", 0, pixels ); + void write(const ::ssize_t x_,const ::ssize_t y_,const size_t columns_, + const size_t rows_,const std::string &map_,const StorageType type_, + void *pixels_); + + // Write single image frame to a file + void write(const std::string &imageSpec_); + + // Associate a mask with the image. The mask must be the same dimensions + // as the image. Pass an invalid image to unset an existing mask. + void writeMask(const Image &mask_); + Image writeMask(void) const; + + // Transfers one or more pixel components from the image pixel + // cache to a buffer or file. + // Used to support image encoders. + void writePixels(const QuantumType quantum_,unsigned char *destination_); + + // Zoom image to specified size. + void zoom(const Geometry &geometry_); + + ////////////////////////////////////////////////////////////////////// + // + // No user-serviceable parts beyond this point + // + ////////////////////////////////////////////////////////////////////// + + // Construct with MagickCore::Image and default options + Image(MagickCore::Image *image_); + + // Retrieve Image* + MagickCore::Image *&image(void); + const MagickCore::Image *constImage(void) const; + + // Retrieve ImageInfo* + MagickCore::ImageInfo *imageInfo(void); + const MagickCore::ImageInfo *constImageInfo(void) const; + + // Retrieve Options* + Options *options(void); + const Options *constOptions(void) const; + + // Retrieve QuantizeInfo* + MagickCore::QuantizeInfo *quantizeInfo(void); + const MagickCore::QuantizeInfo *constQuantizeInfo(void) const; + + // Prepare to update image (copy if reference > 1) + void modifyImage(void); + + // Replace current image (reference counted) + MagickCore::Image *replaceImage(MagickCore::Image *replacement_); + + private: + + void floodFill(const ssize_t x_,const ssize_t y_, + const Magick::Image *fillPattern_,const Color &fill_, + const PixelInfo *target,const bool invert_); + + void mask(const Image &mask_,const PixelMask); + Image mask(const PixelMask) const; + + void read(MagickCore::Image *image, + MagickCore::ExceptionInfo *exceptionInfo); + + ImageRef *_imgRef; + }; + +} // end of namespace Magick + +#endif // Magick_Image_header diff --git a/bin/7.0.5-5/include/ImageMagick-7/Magick++/Include.h b/bin/7.0.5-5/include/ImageMagick-7/Magick++/Include.h new file mode 100755 index 0000000..d55bd8e --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/Magick++/Include.h @@ -0,0 +1,1523 @@ +// This may look like C code, but it is really -*- C++ -*- +// +// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002 +// Copyright Dirk Lemstra 2013-2015 +// +// Inclusion of ImageMagick headers (with namespace magic) + +#ifndef Magick_Include_header +#define Magick_Include_header + +#if !defined(_MAGICK_CONFIG_H) +# define _MAGICK_CONFIG_H +# if !defined(vms) && !defined(macintosh) +# include "MagickCore/magick-config.h" +# else +# include "magick-config.h" +# endif +# undef inline // Remove possible definition from config.h +# undef class +#endif + +// Needed for stdio FILE +#include +#include +#include +#include +#include +#include + +#if defined(__BORLANDC__) +# include /* Borland C++ Builder 4.0 requirement */ +#endif // defined(__BORLANDC__) + +// +// Include ImageMagick headers into namespace "MagickCore". If +// MAGICKCORE_IMPLEMENTATION is defined, include ImageMagick development +// headers. This scheme minimizes the possibility of conflict with +// user code. +// +namespace MagickCore +{ +#include +#include +#undef inline // Remove possible definition from config.h + +#undef class +} + +// +// Provide appropriate DLL imports/exports for Visual C++, +// Borland C++Builder and MinGW builds. +// +#if defined(WIN32) && !defined(__CYGWIN__) && !defined(__MINGW32__) +# define MagickCplusPlusDLLSupported +#endif +#if defined(MagickCplusPlusDLLSupported) +# if defined(_MT) && defined(_DLL) && !defined(_LIB) && !defined(STATIC_MAGICK) +// +// In a native Windows build, the following defines are used: +// +// _MT = Multithreaded +// _DLL = Using code is part of a DLL +// _LIB = Using code is being built as a library. +// _MAGICKMOD_ = Build uses loadable modules (Magick++ does not care about this) +// +// In the case where ImageMagick is built as a static library but the +// using code is dynamic, STATIC_MAGICK may be defined in the project to +// override triggering dynamic library behavior. +// +# if defined(_VISUALC_) +# define MagickDLLExplicitTemplate +# pragma warning( disable: 4275 ) +# pragma warning( disable: 4273 ) /* Disable the stupid dll linkage warnings */ +# pragma warning( disable: 4251 ) +# endif +# if !defined(MAGICKCORE_IMPLEMENTATION) +# if defined(__GNUC__) +# define MagickPPExport __attribute__ ((dllimport)) +# else +# define MagickPPExport __declspec(dllimport) +# endif +# define MagickPPPrivate extern __declspec(dllimport) +# if defined(_VISUALC_) +# pragma message( "Magick++ lib DLL import" ) +# endif +# else +# if defined(__BORLANDC__) || defined(__MINGW32__) +# define MagickPPExport __declspec(dllexport) +# define MagickPPPrivate __declspec(dllexport) +# if defined(__BORLANDC__) +# pragma message( "BCBMagick++ lib DLL export" ) +# endif +# else +# if defined(__GNUC__) +# define MagickPPExport __attribute__ ((dllexport)) +# else +# define MagickPPExport __declspec(dllexport) +# endif +# define MagickPPPrivate extern __declspec(dllexport) +# endif +# if defined(_VISUALC_) +# pragma message( "Magick++ lib DLL export" ) +# endif +# endif +# else +# define MagickPPExport +# define MagickPPPrivate +# if defined(_VISUALC_) +# pragma message( "Magick++ lib static interface" ) +# endif +# if defined(_MSC_VER) && defined(STATIC_MAGICK) && !defined(NOAUTOLINK_MAGICK) +# if defined(_DEBUG) +# if defined(MAGICKCORE_BZLIB_DELEGATE) +# pragma comment(lib, "CORE_DB_bzlib_.lib") +# endif +# pragma comment(lib, "CORE_DB_coders_.lib") +# if defined(MAGICKCORE_OPENEXR_DELEGATE) +# pragma comment(lib, "CORE_DB_exr_.lib") +# endif +# if defined(MAGICKCORE_LQR_DELEGATE) +# pragma comment(lib, "CORE_DB_ffi_.lib") +# endif +# pragma comment(lib, "CORE_DB_filters_.lib") +# if defined(MAGICKCORE_FLIF_DELEGATE) +# pragma comment(lib, "CORE_DB_flif_.lib") +# endif +# if defined(MAGICKCORE_LQR_DELEGATE) +# pragma comment(lib, "CORE_DB_glib_.lib") +# pragma comment(lib, "winmm.lib") +# endif +# if defined(MAGICKCORE_JBIG_DELEGATE) +# pragma comment(lib, "CORE_DB_jbig_.lib") +# endif +# if defined(MAGICKCORE_JP2_DELEGATE) +# pragma comment(lib, "CORE_DB_jp2_.lib") +# endif +# if defined(MAGICKCORE_JPEG_DELEGATE) +# pragma comment(lib, "CORE_DB_jpeg_.lib") +# endif +# if defined(MAGICKCORE_LCMS_DELEGATE) +# pragma comment(lib, "CORE_DB_lcms_.lib") +# endif +# if defined(MAGICKCORE_LIBOPENJP2_DELEGATE) +# pragma comment(lib, "CORE_DB_openjpeg_.lib") +# endif +# pragma comment(lib, "CORE_DB_libxml_.lib") +# if defined(MAGICKCORE_LQR_DELEGATE) +# pragma comment(lib, "CORE_DB_lqr_.lib") +# endif +# pragma comment(lib, "CORE_DB_Magick++_.lib") +# pragma comment(lib, "CORE_DB_MagickCore_.lib") +# pragma comment(lib, "CORE_DB_MagickWand_.lib") +# if defined(MAGICKCORE_PANGOCAIRO_DELEGATE) +# pragma comment(lib, "CORE_DB_cairo_.lib") +# pragma comment(lib, "CORE_DB_pango_.lib") +# pragma comment(lib, "CORE_DB_pixman_.lib") +# endif +# if defined(MAGICKCORE_PNG_DELEGATE) +# pragma comment(lib, "CORE_DB_png_.lib") +# endif +# if defined(MAGICKCORE_RSVG_DELEGATE) +# pragma comment(lib, "CORE_DB_croco_.lib") +# pragma comment(lib, "CORE_DB_librsvg_.lib") +# endif +# if defined(MAGICKCORE_TIFF_DELEGATE) +# pragma comment(lib, "CORE_DB_tiff_.lib") +# endif +# if defined(MAGICKCORE_FREETYPE_DELEGATE) +# pragma comment(lib, "CORE_DB_ttf_.lib") +# endif +# if defined(MAGICKCORE_WEBP_DELEGATE) +# pragma comment(lib, "CORE_DB_webp_.lib") +# endif +# if defined(MAGICKCORE_X11_DELEGATE) +# pragma comment(lib, "CORE_DB_xlib_.lib") +# endif +# if defined(MAGICKCORE_ZLIB_DELEGATE) +# pragma comment(lib, "CORE_DB_zlib_.lib") +# endif +# else +# if defined(MAGICKCORE_BZLIB_DELEGATE) +# pragma comment(lib, "CORE_RL_bzlib_.lib") +# endif +# pragma comment(lib, "CORE_RL_coders_.lib") +# if defined(MAGICKCORE_OPENEXR_DELEGATE) +# pragma comment(lib, "CORE_RL_exr_.lib") +# endif +# if defined(MAGICKCORE_LQR_DELEGATE) +# pragma comment(lib, "CORE_RL_ffi_.lib") +# endif +# pragma comment(lib, "CORE_RL_filters_.lib") +# if defined(MAGICKCORE_FLIF_DELEGATE) +# pragma comment(lib, "CORE_RL_flif_.lib") +# endif +# if defined(MAGICKCORE_LQR_DELEGATE) +# pragma comment(lib, "CORE_RL_glib_.lib") +# pragma comment(lib, "winmm.lib") +# endif +# if defined(MAGICKCORE_JBIG_DELEGATE) +# pragma comment(lib, "CORE_RL_jbig_.lib") +# endif +# if defined(MAGICKCORE_JP2_DELEGATE) +# pragma comment(lib, "CORE_RL_jp2_.lib") +# endif +# if defined(MAGICKCORE_JPEG_DELEGATE) +# pragma comment(lib, "CORE_RL_jpeg_.lib") +# endif +# if defined(MAGICKCORE_LCMS_DELEGATE) +# pragma comment(lib, "CORE_RL_lcms_.lib") +# endif +# if defined(MAGICKCORE_LIBOPENJP2_DELEGATE) +# pragma comment(lib, "CORE_RL_openjpeg_.lib") +# endif +# pragma comment(lib, "CORE_RL_libxml_.lib") +# if defined(MAGICKCORE_LQR_DELEGATE) +# pragma comment(lib, "CORE_RL_lqr_.lib") +# endif +# pragma comment(lib, "CORE_RL_Magick++_.lib") +# pragma comment(lib, "CORE_RL_MagickCore_.lib") +# pragma comment(lib, "CORE_RL_MagickWand_.lib") +# if defined(MAGICKCORE_PANGOCAIRO_DELEGATE) +# pragma comment(lib, "CORE_RL_cairo_.lib") +# pragma comment(lib, "CORE_RL_pango_.lib") +# pragma comment(lib, "CORE_RL_pixman_.lib") +# endif +# if defined(MAGICKCORE_PNG_DELEGATE) +# pragma comment(lib, "CORE_RL_png_.lib") +# endif +# if defined(MAGICKCORE_RSVG_DELEGATE) +# pragma comment(lib, "CORE_RL_croco_.lib") +# pragma comment(lib, "CORE_RL_librsvg_.lib") +# endif +# if defined(MAGICKCORE_TIFF_DELEGATE) +# pragma comment(lib, "CORE_RL_tiff_.lib") +# endif +# if defined(MAGICKCORE_FREETYPE_DELEGATE) +# pragma comment(lib, "CORE_RL_ttf_.lib") +# endif +# if defined(MAGICKCORE_WEBP_DELEGATE) +# pragma comment(lib, "CORE_RL_webp_.lib") +# endif +# if defined(MAGICKCORE_X11_DELEGATE) +# pragma comment(lib, "CORE_RL_xlib_.lib") +# endif +# if defined(MAGICKCORE_ZLIB_DELEGATE) +# pragma comment(lib, "CORE_RL_zlib_.lib") +# endif +# endif +# if defined(_WIN32_WCE) +# pragma comment(lib, "wsock32.lib") +# else +# pragma comment(lib, "ws2_32.lib") +# endif +# pragma comment(lib, "urlmon.lib") +# endif +# endif +#else +# if __GNUC__ >= 4 +# define MagickPPExport __attribute__ ((visibility ("default"))) +# define MagickPPPrivate __attribute__ ((visibility ("hidden"))) +# else +# define MagickPPExport +# define MagickPPPrivate +# endif +#endif + +#if (defined(WIN32) || defined(WIN64)) && defined(_VISUALC_) +# pragma warning(disable : 4996) /* function deprecation warnings */ +#endif + +// +// Import ImageMagick symbols and types which are used as part of the +// Magick++ API definition into namespace "Magick". +// +namespace Magick +{ + // The datatype for an RGB component + using MagickCore::Quantum; + using MagickCore::MagickRealType; + using MagickCore::MagickSizeType; + using MagickCore::MagickStatusType; + + // Structures + using MagickCore::AffineMatrix; + using MagickCore::CacheView; + using MagickCore::CCObjectInfo; + using MagickCore::DrawInfo; + using MagickCore::DrawingWand; + using MagickCore::ExceptionInfo; + using MagickCore::FrameInfo; + using MagickCore::ImageInfo; + using MagickCore::KernelInfo; + using MagickCore::LinkedListInfo; + using MagickCore::MagickInfo; + using MagickCore::MagickWand; + using MagickCore::MontageInfo; + using MagickCore::OffsetInfo; + using MagickCore::PixelInfo; + using MagickCore::PixelWand; + using MagickCore::PointInfo; + using MagickCore::ProfileInfo; + using MagickCore::QuantizeInfo; + using MagickCore::QuantumInfo; + using MagickCore::RectangleInfo; + using MagickCore::StringInfo; + + // Alignment types. + using MagickCore::AlignType; + using MagickCore::UndefinedAlign; + using MagickCore::LeftAlign; + using MagickCore::CenterAlign; + using MagickCore::RightAlign; + + // Alpha channel options + using MagickCore::AlphaChannelOption; + using MagickCore::UndefinedAlphaChannel; + using MagickCore::ActivateAlphaChannel; + using MagickCore::AssociateAlphaChannel; + using MagickCore::BackgroundAlphaChannel; + using MagickCore::CopyAlphaChannel; + using MagickCore::DeactivateAlphaChannel; + using MagickCore::DiscreteAlphaChannel; + using MagickCore::DisassociateAlphaChannel; + using MagickCore::ExtractAlphaChannel; + using MagickCore::OffAlphaChannel; + using MagickCore::OnAlphaChannel; + using MagickCore::OpaqueAlphaChannel; + using MagickCore::RemoveAlphaChannel; + using MagickCore::SetAlphaChannel; + using MagickCore::ShapeAlphaChannel; + using MagickCore::TransparentAlphaChannel; + + // Channel types + using MagickCore::ChannelType; + using MagickCore::UndefinedChannel; + using MagickCore::RedChannel; + using MagickCore::GrayChannel; + using MagickCore::CyanChannel; + using MagickCore::GreenChannel; + using MagickCore::MagentaChannel; + using MagickCore::BlueChannel; + using MagickCore::YellowChannel; + using MagickCore::BlackChannel; + using MagickCore::AlphaChannel; + using MagickCore::OpacityChannel; + using MagickCore::IndexChannel; + using MagickCore::ReadMaskChannel; + using MagickCore::WriteMaskChannel; + using MagickCore::MetaChannel; + using MagickCore::CompositeChannels; + using MagickCore::AllChannels; + using MagickCore::TrueAlphaChannel; + using MagickCore::RGBChannels; + using MagickCore::GrayChannels; + using MagickCore::SyncChannels; + using MagickCore::DefaultChannels; + + // Image class types + using MagickCore::ClassType; + using MagickCore::UndefinedClass; + using MagickCore::DirectClass; + using MagickCore::PseudoClass; + + // Clip path units + using MagickCore::ClipPathUnits; + using MagickCore::UndefinedPathUnits; + using MagickCore::UserSpace; + using MagickCore::UserSpaceOnUse; + using MagickCore::ObjectBoundingBox; + + // Color-space types + using MagickCore::ColorspaceType; + using MagickCore::UndefinedColorspace; + using MagickCore::CMYColorspace; + using MagickCore::CMYKColorspace; + using MagickCore::GRAYColorspace; + using MagickCore::HCLColorspace; + using MagickCore::HCLpColorspace; + using MagickCore::HSBColorspace; + using MagickCore::HSIColorspace; + using MagickCore::HSLColorspace; + using MagickCore::HSVColorspace; + using MagickCore::HWBColorspace; + using MagickCore::LabColorspace; + using MagickCore::LCHColorspace; + using MagickCore::LCHabColorspace; + using MagickCore::LCHuvColorspace; + using MagickCore::LogColorspace; + using MagickCore::LMSColorspace; + using MagickCore::LuvColorspace; + using MagickCore::OHTAColorspace; + using MagickCore::Rec601YCbCrColorspace; + using MagickCore::Rec709YCbCrColorspace; + using MagickCore::RGBColorspace; + using MagickCore::scRGBColorspace; + using MagickCore::sRGBColorspace; + using MagickCore::TransparentColorspace; + using MagickCore::xyYColorspace; + using MagickCore::XYZColorspace; + using MagickCore::YCbCrColorspace; + using MagickCore::YCCColorspace; + using MagickCore::YDbDrColorspace; + using MagickCore::YIQColorspace; + using MagickCore::YPbPrColorspace; + using MagickCore::YUVColorspace; + + // Command options + using MagickCore::CommandOption; + using MagickCore::MagickDirectionOptions; + using MagickCore::MagickGravityOptions; + using MagickCore::MagickKernelOptions; + using MagickCore::MagickStyleOptions; + + // Compliance types + using MagickCore::ComplianceType; + using MagickCore::AllCompliance; + + // Composition operations + using MagickCore::CompositeOperator; + using MagickCore::AlphaCompositeOp; + using MagickCore::AtopCompositeOp; + using MagickCore::BlendCompositeOp; + using MagickCore::BlurCompositeOp; + using MagickCore::BumpmapCompositeOp; + using MagickCore::ChangeMaskCompositeOp; + using MagickCore::ClearCompositeOp; + using MagickCore::ColorBurnCompositeOp; + using MagickCore::ColorDodgeCompositeOp; + using MagickCore::ColorizeCompositeOp; + using MagickCore::CopyBlackCompositeOp; + using MagickCore::CopyBlueCompositeOp; + using MagickCore::CopyCompositeOp; + using MagickCore::CopyCyanCompositeOp; + using MagickCore::CopyGreenCompositeOp; + using MagickCore::CopyMagentaCompositeOp; + using MagickCore::CopyAlphaCompositeOp; + using MagickCore::CopyRedCompositeOp; + using MagickCore::CopyYellowCompositeOp; + using MagickCore::DarkenCompositeOp; + using MagickCore::DarkenIntensityCompositeOp; + using MagickCore::DifferenceCompositeOp; + using MagickCore::DisplaceCompositeOp; + using MagickCore::DissolveCompositeOp; + using MagickCore::DistortCompositeOp; + using MagickCore::DivideDstCompositeOp; + using MagickCore::DivideSrcCompositeOp; + using MagickCore::DstAtopCompositeOp; + using MagickCore::DstCompositeOp; + using MagickCore::DstInCompositeOp; + using MagickCore::DstOutCompositeOp; + using MagickCore::DstOverCompositeOp; + using MagickCore::ExclusionCompositeOp; + using MagickCore::HardLightCompositeOp; + using MagickCore::HardMixCompositeOp; + using MagickCore::HueCompositeOp; + using MagickCore::InCompositeOp; + using MagickCore::IntensityCompositeOp; + using MagickCore::LightenCompositeOp; + using MagickCore::LightenIntensityCompositeOp; + using MagickCore::LinearBurnCompositeOp; + using MagickCore::LinearDodgeCompositeOp; + using MagickCore::LinearLightCompositeOp; + using MagickCore::LuminizeCompositeOp; + using MagickCore::MathematicsCompositeOp; + using MagickCore::MinusDstCompositeOp; + using MagickCore::MinusSrcCompositeOp; + using MagickCore::ModulateCompositeOp; + using MagickCore::ModulusAddCompositeOp; + using MagickCore::ModulusSubtractCompositeOp; + using MagickCore::MultiplyCompositeOp; + using MagickCore::NoCompositeOp; + using MagickCore::OutCompositeOp; + using MagickCore::OverCompositeOp; + using MagickCore::OverlayCompositeOp; + using MagickCore::PegtopLightCompositeOp; + using MagickCore::PinLightCompositeOp; + using MagickCore::PlusCompositeOp; + using MagickCore::ReplaceCompositeOp; + using MagickCore::SaturateCompositeOp; + using MagickCore::ScreenCompositeOp; + using MagickCore::SoftLightCompositeOp; + using MagickCore::SrcAtopCompositeOp; + using MagickCore::SrcCompositeOp; + using MagickCore::SrcInCompositeOp; + using MagickCore::SrcOutCompositeOp; + using MagickCore::SrcOverCompositeOp; + using MagickCore::ThresholdCompositeOp; + using MagickCore::UndefinedCompositeOp; + using MagickCore::VividLightCompositeOp; + using MagickCore::XorCompositeOp; + + // Compression algorithms + using MagickCore::CompressionType; + using MagickCore::UndefinedCompression; + using MagickCore::B44ACompression; + using MagickCore::B44Compression; + using MagickCore::BZipCompression; + using MagickCore::DXT1Compression; + using MagickCore::DXT3Compression; + using MagickCore::DXT5Compression; + using MagickCore::FaxCompression; + using MagickCore::Group4Compression; + using MagickCore::JBIG1Compression; + using MagickCore::JBIG2Compression; + using MagickCore::JPEG2000Compression; + using MagickCore::JPEGCompression; + using MagickCore::LosslessJPEGCompression; + using MagickCore::LZMACompression; + using MagickCore::LZWCompression; + using MagickCore::NoCompression; + using MagickCore::PizCompression; + using MagickCore::Pxr24Compression; + using MagickCore::RLECompression; + using MagickCore::ZipCompression; + using MagickCore::ZipSCompression; + + // Decoration types + using MagickCore::DecorationType; + using MagickCore::UndefinedDecoration; + using MagickCore::NoDecoration; + using MagickCore::UnderlineDecoration; + using MagickCore::OverlineDecoration; + using MagickCore::LineThroughDecoration; + + // Direction types + using MagickCore::DirectionType; + using MagickCore::UndefinedDirection; + using MagickCore::RightToLeftDirection; + using MagickCore::LeftToRightDirection; + + // Dispose methods + using MagickCore::DisposeType; + using MagickCore::UndefinedDispose; + using MagickCore::NoneDispose; + using MagickCore::BackgroundDispose; + using MagickCore::PreviousDispose; + + // Distort methods + using MagickCore::DistortMethod; + using MagickCore::UndefinedDistortion; + using MagickCore::AffineDistortion; + using MagickCore::AffineProjectionDistortion; + using MagickCore::ScaleRotateTranslateDistortion; + using MagickCore::PerspectiveDistortion; + using MagickCore::PerspectiveProjectionDistortion; + using MagickCore::BilinearForwardDistortion; + using MagickCore::BilinearDistortion; + using MagickCore::BilinearReverseDistortion; + using MagickCore::PolynomialDistortion; + using MagickCore::ArcDistortion; + using MagickCore::PolarDistortion; + using MagickCore::DePolarDistortion; + using MagickCore::Cylinder2PlaneDistortion; + using MagickCore::Plane2CylinderDistortion; + using MagickCore::BarrelDistortion; + using MagickCore::BarrelInverseDistortion; + using MagickCore::ShepardsDistortion; + using MagickCore::ResizeDistortion; + using MagickCore::SentinelDistortion; + + // Dither methods + using MagickCore::DitherMethod; + using MagickCore::UndefinedDitherMethod; + using MagickCore::NoDitherMethod; + using MagickCore::RiemersmaDitherMethod; + using MagickCore::FloydSteinbergDitherMethod; + + // Endian options + using MagickCore::EndianType; + using MagickCore::UndefinedEndian; + using MagickCore::LSBEndian; + using MagickCore::MSBEndian; + + // Boolean types + using MagickCore::MagickBooleanType; + using MagickCore::MagickFalse; + using MagickCore::MagickTrue; + + // Evaluate options + using MagickCore::MagickEvaluateOperator; + using MagickCore::UndefinedEvaluateOperator; + using MagickCore::AbsEvaluateOperator; + using MagickCore::AddEvaluateOperator; + using MagickCore::AddModulusEvaluateOperator; + using MagickCore::AndEvaluateOperator; + using MagickCore::CosineEvaluateOperator; + using MagickCore::DivideEvaluateOperator; + using MagickCore::ExponentialEvaluateOperator; + using MagickCore::GaussianNoiseEvaluateOperator; + using MagickCore::ImpulseNoiseEvaluateOperator; + using MagickCore::LaplacianNoiseEvaluateOperator; + using MagickCore::LeftShiftEvaluateOperator; + using MagickCore::LogEvaluateOperator; + using MagickCore::MaxEvaluateOperator; + using MagickCore::MeanEvaluateOperator; + using MagickCore::MedianEvaluateOperator; + using MagickCore::MinEvaluateOperator; + using MagickCore::MultiplicativeNoiseEvaluateOperator; + using MagickCore::MultiplyEvaluateOperator; + using MagickCore::OrEvaluateOperator; + using MagickCore::PoissonNoiseEvaluateOperator; + using MagickCore::PowEvaluateOperator; + using MagickCore::RootMeanSquareEvaluateOperator; + using MagickCore::RightShiftEvaluateOperator; + using MagickCore::SetEvaluateOperator; + using MagickCore::SineEvaluateOperator; + using MagickCore::SubtractEvaluateOperator; + using MagickCore::SumEvaluateOperator; + using MagickCore::ThresholdBlackEvaluateOperator; + using MagickCore::ThresholdEvaluateOperator; + using MagickCore::ThresholdWhiteEvaluateOperator; + using MagickCore::UniformNoiseEvaluateOperator; + using MagickCore::XorEvaluateOperator; + + // Fill rules + using MagickCore::FillRule; + using MagickCore::UndefinedRule; + using MagickCore::EvenOddRule; + using MagickCore::NonZeroRule; + + // Filter types + using MagickCore::FilterType; + using MagickCore::UndefinedFilter; + using MagickCore::PointFilter; + using MagickCore::BoxFilter; + using MagickCore::TriangleFilter; + using MagickCore::HermiteFilter; + using MagickCore::HannFilter; + using MagickCore::HammingFilter; + using MagickCore::BlackmanFilter; + using MagickCore::GaussianFilter; + using MagickCore::QuadraticFilter; + using MagickCore::CubicFilter; + using MagickCore::CatromFilter; + using MagickCore::MitchellFilter; + using MagickCore::JincFilter; + using MagickCore::SincFilter; + using MagickCore::SincFastFilter; + using MagickCore::KaiserFilter; + using MagickCore::WelchFilter; + using MagickCore::ParzenFilter; + using MagickCore::BohmanFilter; + using MagickCore::BartlettFilter; + using MagickCore::LagrangeFilter; + using MagickCore::LanczosFilter; + using MagickCore::LanczosSharpFilter; + using MagickCore::Lanczos2Filter; + using MagickCore::Lanczos2SharpFilter; + using MagickCore::RobidouxFilter; + using MagickCore::RobidouxSharpFilter; + using MagickCore::CosineFilter; + using MagickCore::SplineFilter; + using MagickCore::LanczosRadiusFilter; + using MagickCore::SentinelFilter; + + // Geometry flags; + using MagickCore::GeometryFlags; + using MagickCore::AreaValue; + using MagickCore::AspectValue; + using MagickCore::GreaterValue; + using MagickCore::HeightValue; + using MagickCore::LessValue; + using MagickCore::MinimumValue; + using MagickCore::NoValue; + using MagickCore::PercentValue; + using MagickCore::WidthValue; + using MagickCore::XNegative; + using MagickCore::XValue; + using MagickCore::YNegative; + using MagickCore::YValue; + + // Bit gravity + using MagickCore::GravityType; + using MagickCore::UndefinedGravity; + using MagickCore::ForgetGravity; + using MagickCore::NorthWestGravity; + using MagickCore::NorthGravity; + using MagickCore::NorthEastGravity; + using MagickCore::WestGravity; + using MagickCore::CenterGravity; + using MagickCore::EastGravity; + using MagickCore::SouthWestGravity; + using MagickCore::SouthGravity; + using MagickCore::SouthEastGravity; + + // Image types + using MagickCore::ImageType; + using MagickCore::UndefinedType; + using MagickCore::BilevelType; + using MagickCore::GrayscaleType; + using MagickCore::GrayscaleAlphaType; + using MagickCore::PaletteType; + using MagickCore::PaletteAlphaType; + using MagickCore::TrueColorType; + using MagickCore::TrueColorAlphaType; + using MagickCore::ColorSeparationType; + using MagickCore::ColorSeparationAlphaType; + using MagickCore::OptimizeType; + using MagickCore::PaletteBilevelAlphaType; + + // Interlace types + using MagickCore::InterlaceType; + using MagickCore::UndefinedInterlace; + using MagickCore::NoInterlace; + using MagickCore::LineInterlace; + using MagickCore::PlaneInterlace; + using MagickCore::PartitionInterlace; + using MagickCore::GIFInterlace; + using MagickCore::JPEGInterlace; + using MagickCore::PNGInterlace; + + // Built-in kernels + using MagickCore::KernelInfoType; + using MagickCore::UndefinedKernel; + using MagickCore::UnityKernel; + using MagickCore::GaussianKernel; + using MagickCore::DoGKernel; + using MagickCore::LoGKernel; + using MagickCore::BlurKernel; + using MagickCore::CometKernel; + using MagickCore::BinomialKernel; + using MagickCore::LaplacianKernel; + using MagickCore::SobelKernel; + using MagickCore::FreiChenKernel; + using MagickCore::RobertsKernel; + using MagickCore::PrewittKernel; + using MagickCore::CompassKernel; + using MagickCore::KirschKernel; + using MagickCore::DiamondKernel; + using MagickCore::SquareKernel; + using MagickCore::RectangleKernel; + using MagickCore::OctagonKernel; + using MagickCore::DiskKernel; + using MagickCore::PlusKernel; + using MagickCore::CrossKernel; + using MagickCore::RingKernel; + using MagickCore::PeaksKernel; + using MagickCore::EdgesKernel; + using MagickCore::CornersKernel; + using MagickCore::DiagonalsKernel; + using MagickCore::LineEndsKernel; + using MagickCore::LineJunctionsKernel; + using MagickCore::RidgesKernel; + using MagickCore::ConvexHullKernel; + using MagickCore::ThinSEKernel; + using MagickCore::SkeletonKernel; + using MagickCore::ChebyshevKernel; + using MagickCore::ManhattanKernel; + using MagickCore::OctagonalKernel; + using MagickCore::EuclideanKernel; + using MagickCore::UserDefinedKernel; + + // Layer method + using MagickCore::LayerMethod; + using MagickCore::UndefinedLayer; + using MagickCore::CoalesceLayer; + using MagickCore::CompareAnyLayer; + using MagickCore::CompareClearLayer; + using MagickCore::CompareOverlayLayer; + using MagickCore::DisposeLayer; + using MagickCore::OptimizeLayer; + using MagickCore::OptimizeImageLayer; + using MagickCore::OptimizePlusLayer; + using MagickCore::OptimizeTransLayer; + using MagickCore::RemoveDupsLayer; + using MagickCore::RemoveZeroLayer; + using MagickCore::CompositeLayer; + using MagickCore::MergeLayer; + using MagickCore::FlattenLayer; + using MagickCore::MosaicLayer; + using MagickCore::TrimBoundsLayer; + + // Line cap types + using MagickCore::LineCap; + using MagickCore::UndefinedCap; + using MagickCore::ButtCap; + using MagickCore::RoundCap; + using MagickCore::SquareCap; + + // Line join types + using MagickCore::LineJoin; + using MagickCore::UndefinedJoin; + using MagickCore::MiterJoin; + using MagickCore::RoundJoin; + using MagickCore::BevelJoin; + + // Log event types + using MagickCore::LogEventType; + using MagickCore::UndefinedEvents; + using MagickCore::NoEvents; + using MagickCore::AccelerateEvent; + using MagickCore::AnnotateEvent; + using MagickCore::BlobEvent; + using MagickCore::CacheEvent; + using MagickCore::CoderEvent; + using MagickCore::ConfigureEvent; + using MagickCore::DeprecateEvent; + using MagickCore::DrawEvent; + using MagickCore::ExceptionEvent; + using MagickCore::ImageEvent; + using MagickCore::LocaleEvent; + using MagickCore::ModuleEvent; + using MagickCore::PixelEvent; + using MagickCore::PolicyEvent; + using MagickCore::ResourceEvent; + using MagickCore::TraceEvent; + using MagickCore::TransformEvent; + using MagickCore::UserEvent; + using MagickCore::WandEvent; + using MagickCore::X11Event; + using MagickCore::CommandEvent; + using MagickCore::AllEvents; + + // Magick functions + using MagickCore::MagickFunction; + using MagickCore::UndefinedFunction; + using MagickCore::ArcsinFunction; + using MagickCore::ArctanFunction; + using MagickCore::PolynomialFunction; + using MagickCore::SinusoidFunction; + + // Metric types + using MagickCore::MetricType; + using MagickCore::UndefinedErrorMetric; + using MagickCore::AbsoluteErrorMetric; + using MagickCore::FuzzErrorMetric; + using MagickCore::MeanAbsoluteErrorMetric; + using MagickCore::MeanErrorPerPixelErrorMetric; + using MagickCore::MeanSquaredErrorMetric; + using MagickCore::NormalizedCrossCorrelationErrorMetric; + using MagickCore::PeakAbsoluteErrorMetric; + using MagickCore::PeakSignalToNoiseRatioErrorMetric; + using MagickCore::PerceptualHashErrorMetric; + using MagickCore::RootMeanSquaredErrorMetric; + + // Morphology methods + using MagickCore::MorphologyMethod; + using MagickCore::UndefinedMorphology; + using MagickCore::ConvolveMorphology; + using MagickCore::CorrelateMorphology; + using MagickCore::ErodeMorphology; + using MagickCore::DilateMorphology; + using MagickCore::ErodeIntensityMorphology; + using MagickCore::DilateIntensityMorphology; + using MagickCore::IterativeDistanceMorphology; + using MagickCore::OpenMorphology; + using MagickCore::CloseMorphology; + using MagickCore::OpenIntensityMorphology; + using MagickCore::CloseIntensityMorphology; + using MagickCore::SmoothMorphology; + using MagickCore::EdgeInMorphology; + using MagickCore::EdgeOutMorphology; + using MagickCore::EdgeMorphology; + using MagickCore::TopHatMorphology; + using MagickCore::BottomHatMorphology; + using MagickCore::HitAndMissMorphology; + using MagickCore::ThinningMorphology; + using MagickCore::ThickenMorphology; + using MagickCore::DistanceMorphology; + using MagickCore::VoronoiMorphology; + + // Noise types + using MagickCore::NoiseType; + using MagickCore::UndefinedNoise; + using MagickCore::UniformNoise; + using MagickCore::GaussianNoise; + using MagickCore::MultiplicativeGaussianNoise; + using MagickCore::ImpulseNoise; + using MagickCore::LaplacianNoise; + using MagickCore::PoissonNoise; + + // Orientation types + using MagickCore::OrientationType; + using MagickCore::UndefinedOrientation; + using MagickCore::TopLeftOrientation; + using MagickCore::TopRightOrientation; + using MagickCore::BottomRightOrientation; + using MagickCore::BottomLeftOrientation; + using MagickCore::LeftTopOrientation; + using MagickCore::RightTopOrientation; + using MagickCore::RightBottomOrientation; + using MagickCore::LeftBottomOrientation; + + // Paint methods + using MagickCore::PaintMethod; + using MagickCore::UndefinedMethod; + using MagickCore::PointMethod; + using MagickCore::ReplaceMethod; + using MagickCore::FloodfillMethod; + using MagickCore::FillToBorderMethod; + using MagickCore::ResetMethod; + + using MagickCore::PixelChannel; + using MagickCore::UndefinedPixelChannel; + using MagickCore::RedPixelChannel; + using MagickCore::CyanPixelChannel; + using MagickCore::GrayPixelChannel; + using MagickCore::LPixelChannel; + using MagickCore::YPixelChannel; + using MagickCore::aPixelChannel; + using MagickCore::GreenPixelChannel; + using MagickCore::MagentaPixelChannel; + using MagickCore::CbPixelChannel; + using MagickCore::bPixelChannel; + using MagickCore::BluePixelChannel; + using MagickCore::YellowPixelChannel; + using MagickCore::CrPixelChannel; + using MagickCore::BlackPixelChannel; + using MagickCore::AlphaPixelChannel; + using MagickCore::IndexPixelChannel; + using MagickCore::ReadMaskPixelChannel; + using MagickCore::WriteMaskPixelChannel; + using MagickCore::MetaPixelChannel; + using MagickCore::IntensityPixelChannel; + using MagickCore::CompositePixelChannel; + using MagickCore::SyncPixelChannel; + + // Pixel intensity method + using MagickCore::PixelIntensityMethod; + using MagickCore::UndefinedPixelIntensityMethod; + using MagickCore::AveragePixelIntensityMethod; + using MagickCore::BrightnessPixelIntensityMethod; + using MagickCore::LightnessPixelIntensityMethod; + using MagickCore::MSPixelIntensityMethod; + using MagickCore::Rec601LumaPixelIntensityMethod; + using MagickCore::Rec601LuminancePixelIntensityMethod; + using MagickCore::Rec709LumaPixelIntensityMethod; + using MagickCore::Rec709LuminancePixelIntensityMethod; + using MagickCore::RMSPixelIntensityMethod; + + // PixelInterpolate methods + using MagickCore::PixelInterpolateMethod; + using MagickCore::UndefinedInterpolatePixel; + using MagickCore::AverageInterpolatePixel; + using MagickCore::Average9InterpolatePixel; + using MagickCore::Average16InterpolatePixel; + using MagickCore::BackgroundInterpolatePixel; + using MagickCore::BilinearInterpolatePixel; + using MagickCore::BlendInterpolatePixel; + using MagickCore::CatromInterpolatePixel; + using MagickCore::IntegerInterpolatePixel; + using MagickCore::MeshInterpolatePixel; + using MagickCore::NearestInterpolatePixel; + using MagickCore::SplineInterpolatePixel; + + // Pixel traits + using MagickCore::PixelTrait; + using MagickCore::UndefinedPixelTrait; + using MagickCore::CopyPixelTrait; + using MagickCore::UpdatePixelTrait; + using MagickCore::BlendPixelTrait; + + // Preview types. Not currently used by Magick++ + using MagickCore::PreviewType; + using MagickCore::UndefinedPreview; + using MagickCore::RotatePreview; + using MagickCore::ShearPreview; + using MagickCore::RollPreview; + using MagickCore::HuePreview; + using MagickCore::SaturationPreview; + using MagickCore::BrightnessPreview; + using MagickCore::GammaPreview; + using MagickCore::SpiffPreview; + using MagickCore::DullPreview; + using MagickCore::GrayscalePreview; + using MagickCore::QuantizePreview; + using MagickCore::DespecklePreview; + using MagickCore::ReduceNoisePreview; + using MagickCore::AddNoisePreview; + using MagickCore::SharpenPreview; + using MagickCore::BlurPreview; + using MagickCore::ThresholdPreview; + using MagickCore::EdgeDetectPreview; + using MagickCore::SpreadPreview; + using MagickCore::SolarizePreview; + using MagickCore::ShadePreview; + using MagickCore::RaisePreview; + using MagickCore::SegmentPreview; + using MagickCore::SwirlPreview; + using MagickCore::ImplodePreview; + using MagickCore::WavePreview; + using MagickCore::OilPaintPreview; + using MagickCore::CharcoalDrawingPreview; + using MagickCore::JPEGPreview; + + // Quantum types + using MagickCore::QuantumType; + using MagickCore::IndexQuantum; + using MagickCore::GrayQuantum; + using MagickCore::IndexAlphaQuantum; + using MagickCore::GrayAlphaQuantum; + using MagickCore::RedQuantum; + using MagickCore::CyanQuantum; + using MagickCore::GreenQuantum; + using MagickCore::YellowQuantum; + using MagickCore::BlueQuantum; + using MagickCore::MagentaQuantum; + using MagickCore::AlphaQuantum; + using MagickCore::BlackQuantum; + using MagickCore::RGBQuantum; + using MagickCore::RGBAQuantum; + using MagickCore::CMYKQuantum; + + // Pixel mask types + using MagickCore::PixelMask; + using MagickCore::UndefinedPixelMask; + using MagickCore::ReadPixelMask; + using MagickCore::WritePixelMask; + + // Rendering intents + using MagickCore::RenderingIntent; + using MagickCore::UndefinedIntent; + using MagickCore::SaturationIntent; + using MagickCore::PerceptualIntent; + using MagickCore::AbsoluteIntent; + using MagickCore::RelativeIntent; + + // Resource types + using MagickCore::ResourceType; + using MagickCore::UndefinedResource; + using MagickCore::AreaResource; + using MagickCore::DiskResource; + using MagickCore::FileResource; + using MagickCore::HeightResource; + using MagickCore::MapResource; + using MagickCore::MemoryResource; + using MagickCore::ThreadResource; + using MagickCore::ThrottleResource; + using MagickCore::TimeResource; + using MagickCore::WidthResource; + + // Resolution units + using MagickCore::ResolutionType; + using MagickCore::UndefinedResolution; + using MagickCore::PixelsPerInchResolution; + using MagickCore::PixelsPerCentimeterResolution; + + // Sparse Color methods + using MagickCore::SparseColorMethod; + using MagickCore::UndefinedColorInterpolate; + using MagickCore::BarycentricColorInterpolate; + using MagickCore::BilinearColorInterpolate; + using MagickCore::PolynomialColorInterpolate; + using MagickCore::ShepardsColorInterpolate; + using MagickCore::VoronoiColorInterpolate; + using MagickCore::InverseColorInterpolate; + using MagickCore::ManhattanColorInterpolate; + + // Statistic type + using MagickCore::StatisticType; + using MagickCore::UndefinedStatistic; + using MagickCore::GradientStatistic; + using MagickCore::MaximumStatistic; + using MagickCore::MeanStatistic; + using MagickCore::MedianStatistic; + using MagickCore::MinimumStatistic; + using MagickCore::ModeStatistic; + using MagickCore::NonpeakStatistic; + using MagickCore::RootMeanSquareStatistic; + using MagickCore::StandardDeviationStatistic; + + // StorageType type + using MagickCore::StorageType; + using MagickCore::UndefinedPixel; + using MagickCore::CharPixel; + using MagickCore::DoublePixel; + using MagickCore::FloatPixel; + using MagickCore::LongPixel; + using MagickCore::LongLongPixel; + using MagickCore::QuantumPixel; + using MagickCore::ShortPixel; + + // StretchType type + using MagickCore::StretchType; + using MagickCore::UndefinedStretch; + using MagickCore::NormalStretch; + using MagickCore::UltraCondensedStretch; + using MagickCore::ExtraCondensedStretch; + using MagickCore::CondensedStretch; + using MagickCore::SemiCondensedStretch; + using MagickCore::SemiExpandedStretch; + using MagickCore::ExpandedStretch; + using MagickCore::ExtraExpandedStretch; + using MagickCore::UltraExpandedStretch; + using MagickCore::AnyStretch; + + // StyleType type + using MagickCore::StyleType; + using MagickCore::UndefinedStyle; + using MagickCore::NormalStyle; + using MagickCore::ItalicStyle; + using MagickCore::ObliqueStyle; + using MagickCore::AnyStyle; + + // Virtual pixel methods + using MagickCore::VirtualPixelMethod; + using MagickCore::UndefinedVirtualPixelMethod; + using MagickCore::BackgroundVirtualPixelMethod; + using MagickCore::DitherVirtualPixelMethod; + using MagickCore::EdgeVirtualPixelMethod; + using MagickCore::MirrorVirtualPixelMethod; + using MagickCore::RandomVirtualPixelMethod; + using MagickCore::TileVirtualPixelMethod; + using MagickCore::TransparentVirtualPixelMethod; + using MagickCore::MaskVirtualPixelMethod; + using MagickCore::BlackVirtualPixelMethod; + using MagickCore::GrayVirtualPixelMethod; + using MagickCore::WhiteVirtualPixelMethod; + using MagickCore::HorizontalTileVirtualPixelMethod; + using MagickCore::VerticalTileVirtualPixelMethod; + using MagickCore::HorizontalTileEdgeVirtualPixelMethod; + using MagickCore::VerticalTileEdgeVirtualPixelMethod; + using MagickCore::CheckerTileVirtualPixelMethod; + +#if defined(MAGICKCORE_IMPLEMENTATION) + // + // ImageMagick symbols used in implementation code + // + using MagickCore::AcquireAlignedMemory; + using MagickCore::AcquireAuthenticCacheView; + using MagickCore::AcquireDrawingWand; + using MagickCore::AcquireExceptionInfo; + using MagickCore::AcquireVirtualCacheView; + using MagickCore::AcquireImage; + using MagickCore::AcquireKernelInfo; + using MagickCore::AcquireMagickInfo; + using MagickCore::AcquireMagickMemory; + using MagickCore::AcquireQuantumInfo; + using MagickCore::AcquireString; + using MagickCore::AcquireStringInfo; + using MagickCore::AdaptiveBlurImage; + using MagickCore::AdaptiveResizeImage; + using MagickCore::AdaptiveSharpenImage; + using MagickCore::AdaptiveThresholdImage; + using MagickCore::AddNoiseImage; + using MagickCore::AffineTransformImage; + using MagickCore::AnnotateImage; + using MagickCore::AutoGammaImage; + using MagickCore::AutoLevelImage; + using MagickCore::AutoOrientImage; + using MagickCore::Base64Decode; + using MagickCore::Base64Encode; + using MagickCore::BilevelImage; + using MagickCore::BlackThresholdImage; + using MagickCore::BlobToImage; + using MagickCore::BlueShiftImage; + using MagickCore::BlurImage; + using MagickCore::BrightnessContrastImage; + using MagickCore::BorderImage; + using MagickCore::CharcoalImage; + using MagickCore::CannyEdgeImage; + using MagickCore::ChopImage; + using MagickCore::ClampImage; + using MagickCore::ClampToQuantum; + using MagickCore::ClearMagickException; + using MagickCore::CloneDrawInfo; + using MagickCore::CloneImage; + using MagickCore::CloneImageInfo; + using MagickCore::CloneQuantizeInfo; + using MagickCore::ClutImage; + using MagickCore::ColorDecisionListImage; + using MagickCore::ColorizeImage; + using MagickCore::ColorMatrixImage; + using MagickCore::CommandOptionToMnemonic; + using MagickCore::CompareImages; + using MagickCore::CompareImagesLayers; + using MagickCore::CompositeImage; + using MagickCore::ConnectedComponentsImage; + using MagickCore::ConstituteImage; + using MagickCore::ContrastImage; + using MagickCore::ContrastStretchImage; + using MagickCore::ConvertHSLToRGB; + using MagickCore::ConvertRGBToHSL; + using MagickCore::ConvolveImage; + using MagickCore::CopyImagePixels; + using MagickCore::CopyMagickString; + using MagickCore::CropImage; + using MagickCore::CropImageToTiles; + using MagickCore::CycleColormapImage; + using MagickCore::DecipherImage; + using MagickCore::DeleteImageOption; + using MagickCore::DeleteImageRegistry; + using MagickCore::DeskewImage; + using MagickCore::DespeckleImage; + using MagickCore::DestroyCacheView; + using MagickCore::DestroyDrawInfo; + using MagickCore::DestroyDrawingWand; + using MagickCore::DestroyExceptionInfo; + using MagickCore::DestroyImageInfo; + using MagickCore::DestroyImageList; + using MagickCore::DestroyKernelInfo; + using MagickCore::DestroyMagickWand; + using MagickCore::DestroyPixelWand; + using MagickCore::DestroyQuantizeInfo; + using MagickCore::DestroyQuantumInfo; + using MagickCore::DestroyString; + using MagickCore::DestroyStringInfo; + using MagickCore::DisplayImages; + using MagickCore::DistortImage; + using MagickCore::DrawAffine; + using MagickCore::DrawAlpha; + using MagickCore::DrawAnnotation; + using MagickCore::DrawArc; + using MagickCore::DrawBezier; + using MagickCore::DrawCircle; + using MagickCore::DrawColor; + using MagickCore::DrawComment; + using MagickCore::DrawComposite; + using MagickCore::DrawEllipse; + using MagickCore::DrawImage; + using MagickCore::DrawLine; + using MagickCore::DrawPathClose; + using MagickCore::DrawPathCurveToAbsolute; + using MagickCore::DrawPathCurveToQuadraticBezierAbsolute; + using MagickCore::DrawPathCurveToQuadraticBezierRelative; + using MagickCore::DrawPathCurveToQuadraticBezierSmoothAbsolute; + using MagickCore::DrawPathCurveToQuadraticBezierSmoothRelative; + using MagickCore::DrawPathCurveToRelative; + using MagickCore::DrawPathCurveToSmoothAbsolute; + using MagickCore::DrawPathCurveToSmoothRelative; + using MagickCore::DrawPathEllipticArcAbsolute; + using MagickCore::DrawPathEllipticArcRelative; + using MagickCore::DrawPathFinish; + using MagickCore::DrawPathLineToAbsolute; + using MagickCore::DrawPathLineToHorizontalAbsolute; + using MagickCore::DrawPathLineToHorizontalRelative; + using MagickCore::DrawPathLineToRelative; + using MagickCore::DrawPathLineToVerticalAbsolute; + using MagickCore::DrawPathLineToVerticalRelative; + using MagickCore::DrawPathMoveToAbsolute; + using MagickCore::DrawPathMoveToRelative; + using MagickCore::DrawPathStart; + using MagickCore::DrawPoint; + using MagickCore::DrawPolygon; + using MagickCore::DrawPolyline; + using MagickCore::DrawPopClipPath; + using MagickCore::DrawPopDefs; + using MagickCore::DrawPopPattern; + using MagickCore::DrawPushClipPath; + using MagickCore::DrawPushDefs; + using MagickCore::DrawPushPattern; + using MagickCore::DrawRectangle; + using MagickCore::DrawRender; + using MagickCore::DrawRotate; + using MagickCore::DrawRoundRectangle; + using MagickCore::DrawScale; + using MagickCore::DrawSetClipPath; + using MagickCore::DrawSetClipRule; + using MagickCore::DrawSetClipUnits; + using MagickCore::DrawSetFillColor; + using MagickCore::DrawSetFillOpacity; + using MagickCore::DrawSetFillPatternURL; + using MagickCore::DrawSetFillRule; + using MagickCore::DrawSetFont; + using MagickCore::DrawSetFontFamily; + using MagickCore::DrawSetFontSize; + using MagickCore::DrawSetFontStretch; + using MagickCore::DrawSetFontStyle; + using MagickCore::DrawSetFontWeight; + using MagickCore::DrawSetGravity; + using MagickCore::DrawSetStrokeAntialias; + using MagickCore::DrawSetStrokeColor; + using MagickCore::DrawSetStrokeDashArray; + using MagickCore::DrawSetStrokeDashOffset; + using MagickCore::DrawSetStrokeLineCap; + using MagickCore::DrawSetStrokeLineJoin; + using MagickCore::DrawSetStrokeMiterLimit; + using MagickCore::DrawSetStrokeOpacity; + using MagickCore::DrawSetStrokePatternURL; + using MagickCore::DrawSetStrokeWidth; + using MagickCore::DrawSetTextAntialias; + using MagickCore::DrawSetTextDecoration; + using MagickCore::DrawSetTextEncoding; + using MagickCore::DrawSetTextInterlineSpacing; + using MagickCore::DrawSetTextInterwordSpacing; + using MagickCore::DrawSetTextKerning; + using MagickCore::DrawSetTextUnderColor; + using MagickCore::DrawSetViewbox; + using MagickCore::DrawSkewX; + using MagickCore::DrawSkewY; + using MagickCore::DrawTranslate; + using MagickCore::EdgeImage; + using MagickCore::EmbossImage; + using MagickCore::EncipherImage; + using MagickCore::EnhanceImage; + using MagickCore::EqualizeImage; + using MagickCore::EvaluateImage; + using MagickCore::ExportImagePixels; + using MagickCore::ExportQuantumPixels; + using MagickCore::ExtentImage; + using MagickCore::FlipImage; + using MagickCore::FloodfillPaintImage; + using MagickCore::FlopImage; + using MagickCore::FormatLocaleString; + using MagickCore::ForwardFourierTransformImage; + using MagickCore::FrameImage; + using MagickCore::FxImage; + using MagickCore::GammaImage; + using MagickCore::GaussianBlurImage; + using MagickCore::GaussianBlurImage; + using MagickCore::GetAffineMatrix; + using MagickCore::GetAuthenticMetacontent; + using MagickCore::GetBlobSize; + using MagickCore::GetCacheViewAuthenticMetacontent; + using MagickCore::GetCacheViewAuthenticPixels; + using MagickCore::GetCacheViewVirtualPixels; + using MagickCore::GetClientName; + using MagickCore::GetColorTuple; + using MagickCore::GetDrawInfo; + using MagickCore::GetGeometry; + using MagickCore::GetImageArtifact; + using MagickCore::GetImageMoments; + using MagickCore::GetImageBoundingBox; + using MagickCore::GetImageDistortion; + using MagickCore::GetImageDepth; + using MagickCore::GetImageMask; + using MagickCore::GetImageMean; + using MagickCore::GetImageKurtosis; + using MagickCore::GetImageRange; + using MagickCore::GetImageDepth; + using MagickCore::GetImageInfo; + using MagickCore::GetImageInfoFile; + using MagickCore::GetImageOption; + using MagickCore::GetImagePerceptualHash; + using MagickCore::GetAuthenticPixels; + using MagickCore::GetImageProfile; + using MagickCore::GetImageProperty; + using MagickCore::GetImageQuantizeError; + using MagickCore::GetImageType; + using MagickCore::GetMagickDecoderThreadSupport; + using MagickCore::GetMagickEncoderThreadSupport; + using MagickCore::GetMagickInfo; + using MagickCore::GetMultilineTypeMetrics; + using MagickCore::GetNextValueInLinkedList; + using MagickCore::GetNumberOfElementsInLinkedList; + using MagickCore::GetPixelBlue; + using MagickCore::GetPixelChannelOffset; + using MagickCore::GetPixelChannelTraits; + using MagickCore::GetPixelGreen; + using MagickCore::GetPixelInfo; + using MagickCore::GetPixelRed; + using MagickCore::GetNumberColors; + using MagickCore::GetPageGeometry; + using MagickCore::GetQuantizeInfo; + using MagickCore::GetStringInfoDatum; + using MagickCore::GetStringInfoLength; + using MagickCore::GetTypeMetrics; + using MagickCore::GetValueFromLinkedList; + using MagickCore::GetVirtualMetacontent; + using MagickCore::GetVirtualPixels; + using MagickCore::GetImageVirtualPixelMethod; + using MagickCore::GlobExpression; + using MagickCore::GravityAdjustGeometry; + using MagickCore::GrayscaleImage; + using MagickCore::HaldClutImage; + using MagickCore::HoughLineImage; + using MagickCore::ImageToBlob; + using MagickCore::ImagesToBlob; + using MagickCore::ImplodeImage; + using MagickCore::ImportQuantumPixels; + using MagickCore::InterpretImageProperties; + using MagickCore::InverseFourierTransformImage; + using MagickCore::InvokeDynamicImageFilter; + using MagickCore::IsEventLogging; + using MagickCore::IsGeometry; + using MagickCore::IsImageOpaque; + using MagickCore::IsImagesEqual; + using MagickCore::KuwaharaImage; + using MagickCore::LevelImage; + using MagickCore::LevelImageColors; + using MagickCore::LevelizeImage; + using MagickCore::LinearStretchImage; + using MagickCore::LiquidRescaleImage; + using MagickCore::LocalContrastImage; + using MagickCore::LocaleCompare; + using MagickCore::LockSemaphoreInfo; + using MagickCore::LogMagickEvent; + using MagickCore::MagickCoreTerminus; + using MagickCore::MagickToMime; + using MagickCore::MagnifyImage; + using MagickCore::MergeImageLayers; + using MagickCore::MinifyImage; + using MagickCore::ModulateImage; + using MagickCore::MorphologyImage; + using MagickCore::MotionBlurImage; + using MagickCore::NegateImage; + using MagickCore::NewMagickWandFromImage; + using MagickCore::NewPixelWand; + using MagickCore::NormalizeImage; + using MagickCore::OilPaintImage; + using MagickCore::OpaquePaintImage; + using MagickCore::OrderedDitherImage; + using MagickCore::OptimizeImageLayers; + using MagickCore::OptimizeImageTransparency; + using MagickCore::OptimizePlusImageLayers; + using MagickCore::ParseMetaGeometry; + using MagickCore::PerceptibleImage; + using MagickCore::PingBlob; + using MagickCore::PingImage; + using MagickCore::PixelSetPixelColor; + using MagickCore::PolaroidImage; + using MagickCore::PopDrawingWand; + using MagickCore::PosterizeImage; + using MagickCore::ProfileImage; + using MagickCore::PushDrawingWand; + using MagickCore::QuantizeImage; + using MagickCore::QueueAuthenticPixels; + using MagickCore::QueueCacheViewAuthenticPixels; + using MagickCore::RaiseImage; + using MagickCore::RandomThresholdImage; + using MagickCore::ReadImage; + using MagickCore::RegisterMagickInfo; + using MagickCore::RelinquishMagickMemory; + using MagickCore::RemapImage; + using MagickCore::ResampleImage; + using MagickCore::ResetLinkedListIterator; + using MagickCore::ResizeImage; + using MagickCore::ResizeMagickMemory; + using MagickCore::RollImage; + using MagickCore::RotateImage; + using MagickCore::RotationalBlurImage; + using MagickCore::SampleImage; + using MagickCore::ScaleImage; + using MagickCore::SegmentImage; + using MagickCore::SelectiveBlurImage; + using MagickCore::SeparateImage; + using MagickCore::SepiaToneImage; + using MagickCore::SetGeometry; + using MagickCore::SetImageAlpha; + using MagickCore::SetImageArtifact; + using MagickCore::SetImageBackgroundColor; + using MagickCore::SetImageColorspace; + using MagickCore::SetImageDepth; + using MagickCore::SetImageExtent; + using MagickCore::SetImageInfo; + using MagickCore::SetImageInfoFile; + using MagickCore::SetImageMask; + using MagickCore::SetImageOption; + using MagickCore::SetImageProfile; + using MagickCore::SetImageProperty; + using MagickCore::SetImageRegistry; + using MagickCore::SetImageType; + using MagickCore::SetLogEventMask; + using MagickCore::SetMagickResourceLimit; + using MagickCore::SetImageVirtualPixelMethod; + using MagickCore::SetPixelChannel; + using MagickCore::SetImageChannelMask; + using MagickCore::SetStringInfoDatum; + using MagickCore::ShadeImage; + using MagickCore::ShadowImage; + using MagickCore::SharpenImage; + using MagickCore::SharpenImage; + using MagickCore::ShaveImage; + using MagickCore::ShearImage; + using MagickCore::SigmoidalContrastImage; + using MagickCore::SignatureImage; + using MagickCore::SimilarityImage; + using MagickCore::SketchImage; + using MagickCore::SmushImages; + using MagickCore::SolarizeImage; + using MagickCore::SparseColorImage; + using MagickCore::SpliceImage; + using MagickCore::SpreadImage; + using MagickCore::StatisticImage; + using MagickCore::SteganoImage; + using MagickCore::StereoImage; + using MagickCore::StripImage; + using MagickCore::SwirlImage; + using MagickCore::SyncCacheViewAuthenticPixels; + using MagickCore::SyncImage; + using MagickCore::SyncAuthenticPixels; + using MagickCore::TextureImage; + using MagickCore::ThrowException; + using MagickCore::TintImage; + using MagickCore::TransformImageColorspace; + using MagickCore::TransparentPaintImage; + using MagickCore::TransparentPaintImageChroma; + using MagickCore::TransposeImage; + using MagickCore::TransverseImage; + using MagickCore::TrimImage; + using MagickCore::UniqueImageColors; + using MagickCore::UnlockSemaphoreInfo; + using MagickCore::UnregisterMagickInfo; + using MagickCore::UnsharpMaskImage; + using MagickCore::VignetteImage; + using MagickCore::WaveImage; + using MagickCore::WaveletDenoiseImage; + using MagickCore::WhiteThresholdImage; + using MagickCore::WriteImage; + +#endif // MAGICKCORE_IMPLEMENTATION + +} + +////////////////////////////////////////////////////////////////////// +// +// No user-serviceable parts beyond this point +// +////////////////////////////////////////////////////////////////////// +#define GetPPException \ + MagickCore::ExceptionInfo \ + *exceptionInfo; \ + exceptionInfo=MagickCore::AcquireExceptionInfo(); +#define GetAndSetPPChannelMask(channel) \ + MagickCore::ChannelType \ + channel_mask; \ + channel_mask=MagickCore::SetImageChannelMask(image(),channel) +#define ClonePPDrawException(wand) \ + MagickCore::ExceptionInfo \ + *exceptionInfo; \ + exceptionInfo=MagickCore::DrawCloneExceptionInfo(wand) +#define RestorePPChannelMask \ + MagickCore::SetPixelChannelMask(image(),channel_mask) +#define SetPPChannelMask(channel) \ + (void) MagickCore::SetImageChannelMask(image(),channel) +#define ThrowPPDrawException(quiet) \ + throwException(exceptionInfo,quiet); \ + (void) MagickCore::DestroyExceptionInfo(exceptionInfo) +#define ThrowPPException(quiet) \ + throwException(exceptionInfo,quiet); \ + (void) MagickCore::DestroyExceptionInfo(exceptionInfo) + +#endif // Magick_Include_header diff --git a/bin/7.0.5-5/include/ImageMagick-7/Magick++/Montage.h b/bin/7.0.5-5/include/ImageMagick-7/Magick++/Montage.h new file mode 100755 index 0000000..61a161d --- /dev/null +++ b/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 +#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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/Magick++/Pixels.h b/bin/7.0.5-5/include/ImageMagick-7/Magick++/Pixels.h new file mode 100755 index 0000000..1eb11b0 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/Magick++/ResourceLimits.h b/bin/7.0.5-5/include/ImageMagick-7/Magick++/ResourceLimits.h new file mode 100755 index 0000000..2e0db88 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/Magick++/STL.h b/bin/7.0.5-5/include/ImageMagick-7/Magick++/STL.h new file mode 100755 index 0000000..0506cfa --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/Magick++/STL.h @@ -0,0 +1,2796 @@ +// This may look like C code, but it is really -*- C++ -*- +// +// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003 +// Copyright Dirk Lemstra 2013-2016 +// +// Definition and implementation of template functions for using +// Magick::Image with STL containers. +// + +#ifndef Magick_STL_header +#define Magick_STL_header + +#include "Magick++/Include.h" +#include +#include +#include +#include +#include + +#include "Magick++/CoderInfo.h" +#include "Magick++/Drawable.h" +#include "Magick++/Exception.h" +#include "Magick++/Montage.h" + +namespace Magick +{ + // + // STL function object declarations/definitions + // + + // Function objects provide the means to invoke an operation on one + // or more image objects in an STL-compatable container. The + // arguments to the function object constructor(s) are compatable + // with the arguments to the equivalent Image class method and + // provide the means to supply these options when the function + // object is invoked. + + // For example, to read a GIF animation, set the color red to + // transparent for all frames, and write back out: + // + // list images; + // readImages( &images, "animation.gif" ); + // for_each( images.begin(), images.end(), transparentImage( "red" ) ); + // writeImages( images.begin(), images.end(), "animation.gif" ); + + // Adaptive-blur image with specified blur factor + class MagickPPExport adaptiveBlurImage + { + public: + adaptiveBlurImage( const double radius_ = 1, const double sigma_ = 0.5 ); + + void operator()( Image &image_ ) const; + + private: + double _radius; + double _sigma; + }; + + // Local adaptive threshold image + // http://www.dai.ed.ac.uk/HIPR2/adpthrsh.htm + // Width x height define the size of the pixel neighborhood + // offset = constant to subtract from pixel neighborhood mean + class MagickPPExport adaptiveThresholdImage + { + public: + adaptiveThresholdImage( const size_t width_, + const size_t height_, + const ::ssize_t offset_ = 0 ); + + void operator()( Image &image_ ) const; + + private: + size_t _width; + size_t _height; + ::ssize_t _offset; + }; + + // Add noise to image with specified noise type + class MagickPPExport addNoiseImage + { + public: + addNoiseImage ( NoiseType noiseType_ ); + + void operator()( Image &image_ ) const; + + private: + NoiseType _noiseType; + }; + + // Transform image by specified affine (or free transform) matrix. + class MagickPPExport affineTransformImage + { + public: + affineTransformImage( const DrawableAffine &affine_ ); + + void operator()( Image &image_ ) const; + + private: + DrawableAffine _affine; + }; + + // Annotate image (draw text on image) + class MagickPPExport annotateImage + { + public: + // Annotate using specified text, and placement location + annotateImage ( const std::string &text_, + const Geometry &geometry_ ); + + // Annotate using specified text, bounding area, and placement + // gravity + annotateImage ( const std::string &text_, + const Geometry &geometry_, + const GravityType gravity_ ); + + // Annotate with text using specified text, bounding area, + // placement gravity, and rotation. + annotateImage ( const std::string &text_, + const Geometry &geometry_, + const GravityType gravity_, + const double degrees_ ); + + // Annotate with text (bounding area is entire image) and + // placement gravity. + annotateImage ( const std::string &text_, + const GravityType gravity_ ); + + void operator()( Image &image_ ) const; + + private: + const std::string _text; + const Geometry _geometry; + const GravityType _gravity; + const double _degrees; + }; + + // Blur image with specified blur factor + class MagickPPExport blurImage + { + public: + blurImage( const double radius_ = 1, const double sigma_ = 0.5 ); + + void operator()( Image &image_ ) const; + + private: + double _radius; + double _sigma; + }; + + // Border image (add border to image) + class MagickPPExport borderImage + { + public: + borderImage( const Geometry &geometry_ = borderGeometryDefault ); + + void operator()( Image &image_ ) const; + + private: + Geometry _geometry; + }; + + // Extract channel from image + class MagickPPExport channelImage + { + public: + channelImage( const ChannelType channel_ ); + + void operator()( Image &image_ ) const; + + private: + ChannelType _channel; + }; + + // Charcoal effect image (looks like charcoal sketch) + class MagickPPExport charcoalImage + { + public: + charcoalImage( const double radius_ = 1, const double sigma_ = 0.5 ); + + void operator()( Image &image_ ) const; + + private: + double _radius; + double _sigma; + }; + + // Chop image (remove vertical or horizontal subregion of image) + class MagickPPExport chopImage + { + public: + chopImage( const Geometry &geometry_ ); + + void operator()( Image &image_ ) const; + + private: + Geometry _geometry; + }; + + // Accepts a lightweight Color Correction Collection (CCC) file which solely + // contains one or more color corrections and applies the correction to the + // image. + class MagickPPExport cdlImage + { + public: + cdlImage( const std::string &cdl_ ); + + void operator()( Image &image_ ) const; + + private: + std::string _cdl; + }; + + // Colorize image using pen color at specified percent alpha + class MagickPPExport colorizeImage + { + public: + colorizeImage( const unsigned int alphaRed_, + const unsigned int alphaGreen_, + const unsigned int alphaBlue_, + const Color &penColor_ ); + + colorizeImage( const unsigned int alpha_, + const Color &penColor_ ); + + void operator()( Image &image_ ) const; + + private: + unsigned int _alphaRed; + unsigned int _alphaGreen; + unsigned int _alphaBlue; + Color _penColor; + }; + + // Apply a color matrix to the image channels. The user supplied + // matrix may be of order 1 to 5 (1x1 through 5x5). + class MagickPPExport colorMatrixImage + { + public: + colorMatrixImage( const size_t order_, + const double *color_matrix_ ); + + void operator()( Image &image_ ) const; + + private: + size_t _order; + const double *_color_matrix; + }; + + // Convert the image colorspace representation + class MagickPPExport colorSpaceImage + { + public: + colorSpaceImage( ColorspaceType colorSpace_ ); + + void operator()( Image &image_ ) const; + + private: + ColorspaceType _colorSpace; + }; + + // Comment image (add comment string to image) + class MagickPPExport commentImage + { + public: + commentImage( const std::string &comment_ ); + + void operator()( Image &image_ ) const; + + private: + std::string _comment; + }; + + // Compose an image onto another at specified offset and using + // specified algorithm + class MagickPPExport compositeImage + { + public: + compositeImage( const Image &compositeImage_, + ::ssize_t xOffset_, + ::ssize_t yOffset_, + CompositeOperator compose_ = InCompositeOp ); + + compositeImage( const Image &compositeImage_, + const Geometry &offset_, + CompositeOperator compose_ = InCompositeOp ); + + void operator()( Image &image_ ) const; + + private: + Image _compositeImage; + ::ssize_t _xOffset; + ::ssize_t _yOffset; + CompositeOperator _compose; + }; + + // Contrast image (enhance intensity differences in image) + class MagickPPExport contrastImage + { + public: + contrastImage( const size_t sharpen_ ); + + void operator()( Image &image_ ) const; + + private: + size_t _sharpen; + }; + + // Crop image (subregion of original image) + class MagickPPExport cropImage + { + public: + cropImage( const Geometry &geometry_ ); + + void operator()( Image &image_ ) const; + + private: + Geometry _geometry; + }; + + // Cycle image colormap + class MagickPPExport cycleColormapImage + { + public: + cycleColormapImage( const ::ssize_t amount_ ); + + void operator()( Image &image_ ) const; + + private: + ::ssize_t _amount; + }; + + // Despeckle image (reduce speckle noise) + class MagickPPExport despeckleImage + { + public: + despeckleImage( void ); + + void operator()( Image &image_ ) const; + + private: + }; + + // Distort image. distorts an image using various distortion methods, by + // mapping color lookups of the source image to a new destination image + // usally of the same size as the source image, unless 'bestfit' is set to + // true. + class MagickPPExport distortImage + { + public: + distortImage( const Magick::DistortMethod method_, + const size_t number_arguments_, + const double *arguments_, + const bool bestfit_ ); + + distortImage( const Magick::DistortMethod method_, + const size_t number_arguments_, + const double *arguments_ ); + + void operator()( Image &image_ ) const; + + private: + DistortMethod _method; + size_t _number_arguments; + const double *_arguments; + bool _bestfit; + }; + + // Draw on image + class MagickPPExport drawImage + { + public: + // Draw on image using a single drawable + // Store in list to make implementation easier + drawImage( const Drawable &drawable_ ); + + // Draw on image using a drawable list + drawImage( const DrawableList &drawable_ ); + + void operator()( Image &image_ ) const; + + private: + DrawableList _drawableList; + }; + + // Edge image (hilight edges in image) + class MagickPPExport edgeImage + { + public: + edgeImage( const double radius_ = 0.0 ); + + void operator()( Image &image_ ) const; + + private: + double _radius; + }; + + // Emboss image (hilight edges with 3D effect) + class MagickPPExport embossImage + { + public: + embossImage( void ); + embossImage( const double radius_, const double sigma_ ); + + void operator()( Image &image_ ) const; + + private: + double _radius; + double _sigma; + }; + + // Enhance image (minimize noise) + class MagickPPExport enhanceImage + { + public: + enhanceImage( void ); + + void operator()( Image &image_ ) const; + + private: + }; + + // Equalize image (histogram equalization) + class MagickPPExport equalizeImage + { + public: + equalizeImage( void ); + + void operator()( Image &image_ ) const; + + private: + }; + + // Color to use when filling drawn objects + class MagickPPExport fillColorImage + { + public: + fillColorImage( const Color &fillColor_ ); + + void operator()( Image &image_ ) const; + + private: + Color _fillColor; + }; + + // Flip image (reflect each scanline in the vertical direction) + class MagickPPExport flipImage + { + public: + flipImage( void ); + + void operator()( Image &image_ ) const; + + private: + }; + + // Floodfill designated area with a matte value + class MagickPPExport floodFillAlphaImage + + { + public: + floodFillAlphaImage(const ::ssize_t x_,const ::ssize_t y_, + const unsigned int alpha_,const Color &target_,const bool invert_=false); + + void operator()(Image &image_) const; + + private: + Color _target; + unsigned int _alpha; + ::ssize_t _x; + ::ssize_t _y; + bool _invert; + }; + + // Flood-fill image with color + class MagickPPExport floodFillColorImage + + { + public: + // Flood-fill color across pixels starting at target-pixel and + // stopping at pixels matching specified border color. + // Uses current fuzz setting when determining color match. + floodFillColorImage(const Geometry &point_,const Color &fillColor_, + const bool invert_=false); + floodFillColorImage(const ::ssize_t x_,const ::ssize_t y_, + const Color &fillColor_,const bool invert_=false); + + // Flood-fill color across pixels starting at target-pixel and + // stopping at pixels matching specified border color. + // Uses current fuzz setting when determining color match. + floodFillColorImage(const Geometry &point_,const Color &fillColor_, + const Color &borderColor_,const bool invert_=false); + floodFillColorImage(const ::ssize_t x_,const ::ssize_t y_, + const Color &fillColor_,const Color &borderColor_, + const bool invert_=false); + + void operator()(Image &image_) const; + + private: + ::ssize_t _x; + ::ssize_t _y; + Color _fillColor; + Color _borderColor; + bool _invert; + }; + + // Flood-fill image with texture + class MagickPPExport floodFillTextureImage + + { + public: + // Flood-fill texture across pixels that match the color of the + // target pixel and are neighbors of the target pixel. + // Uses current fuzz setting when determining color match. + floodFillTextureImage(const ::ssize_t x_,const ::ssize_t y_, + const Image &texture_,const bool invert_=false); + floodFillTextureImage(const Geometry &point_,const Image &texture_, + const bool invert_=false); + + // Flood-fill texture across pixels starting at target-pixel and + // stopping at pixels matching specified border color. + // Uses current fuzz setting when determining color match. + floodFillTextureImage(const ::ssize_t x_,const ::ssize_t y_, + const Image &texture_,const Color &borderColor_, + const bool invert_=false); + + floodFillTextureImage(const Geometry &point_,const Image &texture_, + const Color &borderColor_,const bool invert_=false); + + void operator()(Image &image_) const; + + private: + ::ssize_t _x; + ::ssize_t _y; + Image _texture; + Color _borderColor; + bool _invert; + }; + + // Flop image (reflect each scanline in the horizontal direction) + class MagickPPExport flopImage + { + public: + flopImage( void ); + + void operator()( Image &image_ ) const; + + private: + }; + + // Frame image + class MagickPPExport frameImage + { + public: + frameImage( const Geometry &geometry_ = frameGeometryDefault ); + + frameImage( const size_t width_, const size_t height_, + const ::ssize_t innerBevel_ = 6, const ::ssize_t outerBevel_ = 6 ); + + void operator()( Image &image_ ) const; + + private: + size_t _width; + size_t _height; + ::ssize_t _outerBevel; + ::ssize_t _innerBevel; + }; + + // Gamma correct image + class MagickPPExport gammaImage + { + public: + gammaImage( const double gamma_ ); + + gammaImage ( const double gammaRed_, + const double gammaGreen_, + const double gammaBlue_ ); + + void operator()( Image &image_ ) const; + + private: + double _gammaRed; + double _gammaGreen; + double _gammaBlue; + }; + + // Gaussian blur image + // The number of neighbor pixels to be included in the convolution + // mask is specified by 'width_'. The standard deviation of the + // gaussian bell curve is specified by 'sigma_'. + class MagickPPExport gaussianBlurImage + { + public: + gaussianBlurImage( const double width_, const double sigma_ ); + + void operator()( Image &image_ ) const; + + private: + double _width; + double _sigma; + }; + + // Apply a color lookup table (Hald CLUT) to the image. + class MagickPPExport haldClutImage + { + public: + haldClutImage( const Image &haldClutImage_ ); + + void operator()( Image &image_ ) const; + + private: + Image _haldClutImage; + }; + + // Implode image (special effect) + class MagickPPExport implodeImage + { + public: + implodeImage( const double factor_ = 50 ); + + void operator()( Image &image_ ) const; + + private: + double _factor; + }; + + // implements the inverse discrete Fourier transform (IFT) of the image + // either as a magnitude / phase or real / imaginary image pair. + class MagickPPExport inverseFourierTransformImage + { + public: + inverseFourierTransformImage( const Image &phaseImage_ ); + + void operator()( Image &image_ ) const; + + private: + Image _phaseImage; + }; + + // Set image validity. Valid images become empty (inValid) if + // argument is false. + class MagickPPExport isValidImage + { + public: + isValidImage( const bool isValid_ ); + + void operator()( Image &image_ ) const; + + private: + bool _isValid; + }; + + // Label image + class MagickPPExport labelImage + { + public: + labelImage( const std::string &label_ ); + + void operator()( Image &image_ ) const; + + private: + std::string _label; + }; + + + // Level image + class MagickPPExport levelImage + { + public: + levelImage( const double black_point, + const double white_point, + const double mid_point=1.0 ); + + void operator()( Image &image_ ) const; + + private: + double _black_point; + double _white_point; + double _mid_point; + }; + + // Magnify image by integral size + class MagickPPExport magnifyImage + { + public: + magnifyImage( void ); + + void operator()( Image &image_ ) const; + + private: + }; + + // Remap image colors with closest color from reference image + class MagickPPExport mapImage + { + public: + mapImage( const Image &mapImage_ , + const bool dither_ = false ); + + void operator()( Image &image_ ) const; + + private: + Image _mapImage; + bool _dither; + }; + + // Filter image by replacing each pixel component with the median + // color in a circular neighborhood + class MagickPPExport medianConvolveImage + { + public: + medianConvolveImage( const double radius_ = 0.0 ); + + void operator()( Image &image_ ) const; + + private: + double _radius; + }; + + // Merge image layers + class MagickPPExport mergeLayersImage + { + public: + mergeLayersImage ( LayerMethod layerMethod_ ); + + void operator()( Image &image_ ) const; + + private: + LayerMethod _layerMethod; + }; + + // Reduce image by integral size + class MagickPPExport minifyImage + { + public: + minifyImage( void ); + + void operator()( Image &image_ ) const; + + private: + }; + + // Modulate percent hue, saturation, and brightness of an image + class MagickPPExport modulateImage + { + public: + modulateImage( const double brightness_, + const double saturation_, + const double hue_ ); + + void operator()( Image &image_ ) const; + + private: + double _brightness; + double _saturation; + double _hue; + }; + + // Negate colors in image. Set grayscale to only negate grayscale + // values in image. + class MagickPPExport negateImage + { + public: + negateImage( const bool grayscale_ = false ); + + void operator()( Image &image_ ) const; + + private: + bool _grayscale; + }; + + // Normalize image (increase contrast by normalizing the pixel + // values to span the full range of color values) + class MagickPPExport normalizeImage + { + public: + normalizeImage( void ); + + void operator()( Image &image_ ) const; + + private: + }; + + // Oilpaint image (image looks like oil painting) + class MagickPPExport oilPaintImage + { + public: + oilPaintImage( const double radius_ = 3 ); + + void operator()( Image &image_ ) const; + + private: + double _radius; + }; + + // Set or attenuate the image alpha channel. If the image pixels + // are opaque then they are set to the specified alpha value, + // otherwise they are blended with the supplied alpha value. The + // value of alpha_ ranges from 0 (completely opaque) to + // QuantumRange. The defines OpaqueAlpha and TransparentAlpha are + // available to specify completely opaque or completely transparent, + // respectively. + class MagickPPExport alphaImage + { + public: + alphaImage( const unsigned int alpha_ ); + + void operator()( Image &image_ ) const; + + private: + unsigned int _alpha; + }; + + // Change color of opaque pixel to specified pen color. + class MagickPPExport opaqueImage + { + public: + opaqueImage( const Color &opaqueColor_, + const Color &penColor_ ); + + void operator()( Image &image_ ) const; + + private: + Color _opaqueColor; + Color _penColor; + }; + + // Quantize image (reduce number of colors) + class MagickPPExport quantizeImage + { + public: + quantizeImage( const bool measureError_ = false ); + + void operator()( Image &image_ ) const; + + private: + bool _measureError; + }; + + // Raise image (lighten or darken the edges of an image to give a + // 3-D raised or lowered effect) + class MagickPPExport raiseImage + { + public: + raiseImage( const Geometry &geometry_ = raiseGeometryDefault, + const bool raisedFlag_ = false ); + + void operator()( Image &image_ ) const; + + private: + Geometry _geometry; + bool _raisedFlag; + }; + + class MagickPPExport ReadOptions + { + public: + + // Default constructor + ReadOptions(void); + + // Copy constructor + ReadOptions(const ReadOptions& options_); + + // Destructor + ~ReadOptions(); + + // Vertical and horizontal resolution in pixels of the image + void density(const Geometry &geomery_); + Geometry density(void) const; + + // Image depth (8 or 16) + void depth(size_t depth_); + size_t depth(void) const; + + // Suppress all warning messages. Error messages are still reported. + void quiet(const bool quiet_); + bool quiet(void) const; + + // Image size (required for raw formats) + void size(const Geometry &geometry_); + Geometry size(void) const; + + // + // Internal implementation methods. Please do not use. + // + + MagickCore::ImageInfo *imageInfo(void); + + private: + + // Assignment not supported + ReadOptions& operator=(const ReadOptions&); + + MagickCore::ImageInfo *_imageInfo; + bool _quiet; + }; + + // Reduce noise in image using a noise peak elimination filter + class MagickPPExport reduceNoiseImage + { + public: + reduceNoiseImage( void ); + + reduceNoiseImage (const size_t order_ ); + + void operator()( Image &image_ ) const; + + private: + size_t _order; + }; + + // Resize image to specified size. + class MagickPPExport resizeImage + { + public: + resizeImage( const Geometry &geometry_ ); + + void operator()( Image &image_ ) const; + + private: + Geometry _geometry; + }; + + // Roll image (rolls image vertically and horizontally) by specified + // number of columnms and rows) + class MagickPPExport rollImage + { + public: + rollImage( const Geometry &roll_ ); + + rollImage( const ::ssize_t columns_, const ::ssize_t rows_ ); + + void operator()( Image &image_ ) const; + + private: + size_t _columns; + size_t _rows; + }; + + // Rotate image counter-clockwise by specified number of degrees. + class MagickPPExport rotateImage + { + public: + rotateImage( const double degrees_ ); + + void operator()( Image &image_ ) const; + + private: + double _degrees; + }; + + // Resize image by using pixel sampling algorithm + class MagickPPExport sampleImage + { + public: + sampleImage( const Geometry &geometry_ ); + + void operator()( Image &image_ ) const; + + private: + Geometry _geometry; + }; + + // Resize image by using simple ratio algorithm + class MagickPPExport scaleImage + { + public: + scaleImage( const Geometry &geometry_ ); + + void operator()( Image &image_ ) const; + + private: + Geometry _geometry; + }; + + // Segment (coalesce similar image components) by analyzing the + // histograms of the color components and identifying units that are + // homogeneous with the fuzzy c-means technique. + // Also uses QuantizeColorSpace and Verbose image attributes + class MagickPPExport segmentImage + { + public: + segmentImage( const double clusterThreshold_ = 1.0, + const double smoothingThreshold_ = 1.5 ); + + void operator()( Image &image_ ) const; + + private: + double _clusterThreshold; + double _smoothingThreshold; + }; + + // Shade image using distant light source + class MagickPPExport shadeImage + { + public: + shadeImage( const double azimuth_ = 30, + const double elevation_ = 30, + const bool colorShading_ = false ); + + void operator()( Image &image_ ) const; + + private: + double _azimuth; + double _elevation; + bool _colorShading; + }; + + // Shadow effect image (simulate an image shadow) + class MagickPPExport shadowImage + { + public: + shadowImage( const double percent_opacity_ = 80, const double sigma_ = 0.5, + const ssize_t x_ = 5, const ssize_t y_ = 5 ); + + void operator()( Image &image_ ) const; + + private: + double _percent_opacity; + double _sigma; + ssize_t _x; + ssize_t _y; + }; + + // Sharpen pixels in image + class MagickPPExport sharpenImage + { + public: + sharpenImage( const double radius_ = 1, const double sigma_ = 0.5 ); + + void operator()( Image &image_ ) const; + + private: + double _radius; + double _sigma; + }; + + // Shave pixels from image edges. + class MagickPPExport shaveImage + { + public: + shaveImage( const Geometry &geometry_ ); + + void operator()( Image &image_ ) const; + + private: + Geometry _geometry; + }; + + + // Shear image (create parallelogram by sliding image by X or Y axis) + class MagickPPExport shearImage + { + public: + shearImage( const double xShearAngle_, + const double yShearAngle_ ); + + void operator()( Image &image_ ) const; + + private: + double _xShearAngle; + double _yShearAngle; + }; + + // Solarize image (similar to effect seen when exposing a + // photographic film to light during the development process) + class MagickPPExport solarizeImage + { + public: + solarizeImage( const double factor_ ); + + void operator()( Image &image_ ) const; + + private: + double _factor; + }; + + // Splice the background color into the image. + class MagickPPExport spliceImage + { + public: + spliceImage( const Geometry &geometry_ ); + + void operator()( Image &image_ ) const; + + private: + Geometry _geometry; + }; + + // Spread pixels randomly within image by specified ammount + class MagickPPExport spreadImage + { + public: + spreadImage( const size_t amount_ = 3 ); + + void operator()( Image &image_ ) const; + + private: + size_t _amount; + }; + + // Add a digital watermark to the image (based on second image) + class MagickPPExport steganoImage + { + public: + steganoImage( const Image &waterMark_ ); + + void operator()( Image &image_ ) const; + + private: + Image _waterMark; + }; + + // Create an image which appears in stereo when viewed with red-blue glasses + // (Red image on left, blue on right) + class MagickPPExport stereoImage + { + public: + stereoImage( const Image &rightImage_ ); + + void operator()( Image &image_ ) const; + + private: + Image _rightImage; + }; + + // Color to use when drawing object outlines + class MagickPPExport strokeColorImage + { + public: + strokeColorImage( const Color &strokeColor_ ); + + void operator()( Image &image_ ) const; + + private: + Color _strokeColor; + }; + + // Swirl image (image pixels are rotated by degrees) + class MagickPPExport swirlImage + { + public: + swirlImage( const double degrees_ ); + + void operator()( Image &image_ ) const; + + private: + double _degrees; + }; + + // Channel a texture on image background + class MagickPPExport textureImage + { + public: + textureImage( const Image &texture_ ); + + void operator()( Image &image_ ) const; + + private: + Image _texture; + }; + + // Threshold image + class MagickPPExport thresholdImage + { + public: + thresholdImage( const double threshold_ ); + + void operator()( Image &image_ ) const; + + private: + double _threshold; + }; + + // Set image color to transparent + class MagickPPExport transparentImage + { + public: + transparentImage( const Color& color_ ); + + void operator()( Image &image_ ) const; + + private: + Color _color; + }; + + // Trim edges that are the background color from the image + class MagickPPExport trimImage + { + public: + trimImage( void ); + + void operator()( Image &image_ ) const; + + private: + }; + + // Map image pixels to a sine wave + class MagickPPExport waveImage + { + public: + waveImage( const double amplitude_ = 25.0, + const double wavelength_ = 150.0 ); + + void operator()( Image &image_ ) const; + + private: + double _amplitude; + double _wavelength; + }; + + // Zoom image to specified size. + class MagickPPExport zoomImage + { + public: + zoomImage( const Geometry &geometry_ ); + + void operator()( Image &image_ ) const; + + private: + Geometry _geometry; + }; + + // + // Function object image attribute accessors + // + + // Join images into a single multi-image file + class MagickPPExport adjoinImage + { + public: + adjoinImage( const bool flag_ ); + + void operator()( Image &image_ ) const; + + private: + bool _flag; + }; + + // Time in 1/100ths of a second which must expire before displaying + // the next image in an animated sequence. + class MagickPPExport animationDelayImage + { + public: + animationDelayImage( const size_t delay_ ); + + void operator()( Image &image_ ) const; + + private: + size_t _delay; + }; + + // Number of iterations to loop an animation (e.g. Netscape loop + // extension) for. + class MagickPPExport animationIterationsImage + { + public: + animationIterationsImage( const size_t iterations_ ); + + void operator()( Image &image_ ) const; + + private: + size_t _iterations; + }; + + // Image background color + class MagickPPExport backgroundColorImage + { + public: + backgroundColorImage( const Color &color_ ); + + void operator()( Image &image_ ) const; + + private: + Color _color; + }; + + // Name of texture image to tile onto the image background + class MagickPPExport backgroundTextureImage + { + public: + backgroundTextureImage( const std::string &backgroundTexture_ ); + + void operator()( Image &image_ ) const; + + private: + std::string _backgroundTexture; + }; + + // Image border color + class MagickPPExport borderColorImage + { + public: + borderColorImage( const Color &color_ ); + + void operator()( Image &image_ ) const; + + private: + Color _color; + }; + + // Text bounding-box base color (default none) + class MagickPPExport boxColorImage + { + public: + boxColorImage( const Color &boxColor_ ); + + void operator()( Image &image_ ) const; + + private: + Color _boxColor; + }; + + // Chromaticity blue primary point. + class MagickPPExport chromaBluePrimaryImage + { + public: + chromaBluePrimaryImage(const double x_,const double y_,const double z_); + + void operator()(Image &image_) const; + + private: + double _x; + double _y; + double _z; + }; + + // Chromaticity green primary point. + class MagickPPExport chromaGreenPrimaryImage + { + public: + chromaGreenPrimaryImage(const double x_,const double y_,const double z_); + + void operator()(Image &image_) const; + + private: + double _x; + double _y; + double _z; + }; + + // Chromaticity red primary point. + class MagickPPExport chromaRedPrimaryImage + { + public: + chromaRedPrimaryImage(const double x_,const double y_,const double z_); + + void operator()(Image &image_) const; + + private: + double _x; + double _y; + double _z; + }; + + // Chromaticity white point. + class MagickPPExport chromaWhitePointImage + { + public: + chromaWhitePointImage(const double x_,const double y_,const double z_); + + void operator()(Image &image_) const; + + private: + double _x; + double _y; + double _z; + }; + + // Colors within this distance are considered equal + class MagickPPExport colorFuzzImage + { + public: + colorFuzzImage( const double fuzz_ ); + + void operator()( Image &image_ ) const; + + private: + double _fuzz; + }; + + // Color at colormap position index_ + class MagickPPExport colorMapImage + { + public: + colorMapImage( const size_t index_, const Color &color_ ); + + void operator()( Image &image_ ) const; + + private: + size_t _index; + Color _color; + }; + + // Composition operator to be used when composition is implicitly used + // (such as for image flattening). + class MagickPPExport composeImage + { + public: + composeImage( const CompositeOperator compose_ ); + + void operator()( Image &image_ ) const; + + private: + CompositeOperator _compose; + }; + + // Compression type + class MagickPPExport compressTypeImage + { + public: + compressTypeImage( const CompressionType compressType_ ); + + void operator()( Image &image_ ) const; + + private: + CompressionType _compressType; + }; + + // Vertical and horizontal resolution in pixels of the image + class MagickPPExport densityImage + { + public: + densityImage( const Point &point_ ); + + void operator()( Image &image_ ) const; + + private: + Point _point; + }; + + // Image depth (bits allocated to red/green/blue components) + class MagickPPExport depthImage + { + public: + depthImage( const size_t depth_ ); + + void operator()( Image &image_ ) const; + + private: + size_t _depth; + }; + + // Endianness (LSBEndian like Intel or MSBEndian like SPARC) for image + // formats which support endian-specific options. + class MagickPPExport endianImage + { + public: + endianImage( const EndianType endian_ ); + + void operator()( Image &image_ ) const; + + private: + EndianType _endian; + }; + + // Image file name + class MagickPPExport fileNameImage + { + public: + fileNameImage( const std::string &fileName_ ); + + void operator()( Image &image_ ) const; + + private: + std::string _fileName; + }; + + // Filter to use when resizing image + class MagickPPExport filterTypeImage + { + public: + filterTypeImage( const FilterType filterType_ ); + + void operator()( Image &image_ ) const; + + private: + FilterType _filterType; + }; + + // Text rendering font + class MagickPPExport fontImage + { + public: + fontImage( const std::string &font_ ); + + void operator()( Image &image_ ) const; + + private: + std::string _font; + }; + + // Font point size + class MagickPPExport fontPointsizeImage + { + public: + fontPointsizeImage( const size_t pointsize_ ); + + void operator()( Image &image_ ) const; + + private: + size_t _pointsize; + }; + + // GIF disposal method + class MagickPPExport gifDisposeMethodImage + { + public: + gifDisposeMethodImage( const DisposeType disposeMethod_ ); + + void operator()( Image &image_ ) const; + + private: + DisposeType _disposeMethod; + }; + + // Type of interlacing to use + class MagickPPExport interlaceTypeImage + { + public: + interlaceTypeImage( const InterlaceType interlace_ ); + + void operator()( Image &image_ ) const; + + private: + InterlaceType _interlace; + }; + + // File type magick identifier (.e.g "GIF") + class MagickPPExport magickImage + { + public: + magickImage( const std::string &magick_ ); + + void operator()( Image &image_ ) const; + + private: + std::string _magick; + }; + + // Image supports transparent color + class MagickPPExport alphaFlagImage + { + public: + alphaFlagImage( const bool alphaFlag_ ); + + void operator()( Image &image_ ) const; + + private: + bool _alphaFlag; + }; + + // Transparent color + class MagickPPExport matteColorImage + { + public: + matteColorImage( const Color &matteColor_ ); + + void operator()( Image &image_ ) const; + + private: + Color _matteColor; + }; + + // Indicate that image is black and white + class MagickPPExport monochromeImage + { + public: + monochromeImage( const bool monochromeFlag_ ); + + void operator()( Image &image_ ) const; + + private: + bool _monochromeFlag; + }; + + // Pen color + class MagickPPExport penColorImage + { + public: + penColorImage( const Color &penColor_ ); + + void operator()( Image &image_ ) const; + + private: + Color _penColor; + }; + + // Pen texture image. + class MagickPPExport penTextureImage + { + public: + penTextureImage( const Image &penTexture_ ); + + void operator()( Image &image_ ) const; + + private: + Image _penTexture; + }; + + // Set pixel color at location x & y. + class MagickPPExport pixelColorImage + { + public: + pixelColorImage( const ::ssize_t x_, + const ::ssize_t y_, + const Color &color_); + + void operator()( Image &image_ ) const; + + private: + ::ssize_t _x; + ::ssize_t _y; + Color _color; + }; + + // Postscript page size. + class MagickPPExport pageImage + { + public: + pageImage( const Geometry &pageSize_ ); + + void operator()( Image &image_ ) const; + + private: + Geometry _pageSize; + }; + + // JPEG/MIFF/PNG compression level (default 75). + class MagickPPExport qualityImage + { + public: + qualityImage( const size_t quality_ ); + + void operator()( Image &image_ ) const; + + private: + size_t _quality; + }; + + // Maximum number of colors to quantize to + class MagickPPExport quantizeColorsImage + { + public: + quantizeColorsImage( const size_t colors_ ); + + void operator()( Image &image_ ) const; + + private: + size_t _colors; + }; + + // Colorspace to quantize in. + class MagickPPExport quantizeColorSpaceImage + { + public: + quantizeColorSpaceImage( const ColorspaceType colorSpace_ ); + + void operator()( Image &image_ ) const; + + private: + ColorspaceType _colorSpace; + }; + + // Dither image during quantization (default true). + class MagickPPExport quantizeDitherImage + { + public: + quantizeDitherImage( const bool ditherFlag_ ); + + void operator()( Image &image_ ) const; + + private: + bool _ditherFlag; + }; + + // Quantization tree-depth + class MagickPPExport quantizeTreeDepthImage + { + public: + quantizeTreeDepthImage( const size_t treeDepth_ ); + + void operator()( Image &image_ ) const; + + private: + size_t _treeDepth; + }; + + // The type of rendering intent + class MagickPPExport renderingIntentImage + { + public: + renderingIntentImage( const RenderingIntent renderingIntent_ ); + + void operator()( Image &image_ ) const; + + private: + RenderingIntent _renderingIntent; + }; + + // Units of image resolution + class MagickPPExport resolutionUnitsImage + { + public: + resolutionUnitsImage( const ResolutionType resolutionUnits_ ); + + void operator()( Image &image_ ) const; + + private: + ResolutionType _resolutionUnits; + }; + + // Image scene number + class MagickPPExport sceneImage + { + public: + sceneImage( const size_t scene_ ); + + void operator()( Image &image_ ) const; + + private: + size_t _scene; + }; + + // adjust the image contrast with a non-linear sigmoidal contrast algorithm + class MagickPPExport sigmoidalContrastImage + { + public: + sigmoidalContrastImage( const size_t sharpen_, + const double contrast, + const double midpoint = QuantumRange / 2.0 ); + + void operator()( Image &image_ ) const; + + private: + size_t _sharpen; + double contrast; + double midpoint; + }; + + // Width and height of a raw image + class MagickPPExport sizeImage + { + public: + sizeImage( const Geometry &geometry_ ); + + void operator()( Image &image_ ) const; + + private: + Geometry _geometry; + }; + + // stripImage strips an image of all profiles and comments. + class MagickPPExport stripImage + { + public: + stripImage( void ); + + void operator()( Image &image_ ) const; + + private: + }; + + // Subimage of an image sequence + class MagickPPExport subImageImage + { + public: + subImageImage( const size_t subImage_ ); + + void operator()( Image &image_ ) const; + + private: + size_t _subImage; + }; + + // Number of images relative to the base image + class MagickPPExport subRangeImage + { + public: + subRangeImage( const size_t subRange_ ); + + void operator()( Image &image_ ) const; + + private: + size_t _subRange; + }; + + // Anti-alias Postscript and TrueType fonts (default true) + class MagickPPExport textAntiAliasImage + { + public: + textAntiAliasImage( const bool flag_ ); + + void operator()( Image &image_ ) const; + + private: + bool _flag; + }; + + // Image storage type + class MagickPPExport typeImage + { + public: + typeImage( const ImageType type_ ); + + void operator()( Image &image_ ) const; + + private: + Magick::ImageType _type; + }; + + + // Print detailed information about the image + class MagickPPExport verboseImage + { + public: + verboseImage( const bool verbose_ ); + + void operator()( Image &image_ ) const; + + private: + bool _verbose; + }; + + // X11 display to display to, obtain fonts from, or to capture + // image from + class MagickPPExport x11DisplayImage + { + public: + x11DisplayImage( const std::string &display_ ); + + void operator()( Image &image_ ) const; + + private: + std::string _display; + }; + + ////////////////////////////////////////////////////////// + // + // Implementation template definitions. Not for end-use. + // + ////////////////////////////////////////////////////////// + + // Changes the channel mask of the images and places the old + // values in the container. + template + void channelMaskImages(InputIterator first_,InputIterator last_, + Container *container_,const ChannelType channel_) + { + MagickCore::ChannelType + channel_mask; + + container_->clear(); + for (InputIterator iter = first_; iter != last_; ++iter) + { + iter->modifyImage(); + channel_mask=MagickCore::SetImageChannelMask(iter->image(),channel_); + container_->push_back(channel_mask); + } + } + + // Insert images in image list into existing container (appending to container) + // The images should not be deleted since only the image ownership is passed. + // The options are copied into the object. + template + void insertImages(Container *sequence_,MagickCore::Image* images_) + { + MagickCore::Image + *image, + *next; + + image=images_; + while (image != (MagickCore::Image *) NULL) + { + next=image->next; + image->next=(MagickCore::Image *) NULL; + + if (next != (MagickCore::Image *) NULL) + next->previous=(MagickCore::Image *) NULL; + + sequence_->push_back(Magick::Image(image)); + + image=next; + } + } + + // Link images together into an image list based on the ordering of + // the container implied by the iterator. This step is done in + // preparation for use with ImageMagick functions which operate on + // lists of images. + // Images are selected by range, first_ to last_ so that a subset of + // the container may be selected. Specify first_ via the + // container's begin() method and last_ via the container's end() + // method in order to specify the entire container. + template + bool linkImages(InputIterator first_,InputIterator last_) + { + MagickCore::Image + *current, + *previous; + + ::ssize_t + scene; + + scene=0; + previous=(MagickCore::Image *) NULL; + for (InputIterator iter = first_; iter != last_; ++iter) + { + // Unless we reduce the reference count to one, the same image + // structure may occur more than once in the container, causing + // the linked list to fail. + iter->modifyImage(); + + current=iter->image(); + + current->previous=previous; + current->next=(MagickCore::Image *) NULL; + current->scene=scene++; + + if (previous != (MagickCore::Image *) NULL) + previous->next=current; + + previous=current; + } + return(scene > 0 ? true : false); + } + + // Restores the channel mask of the images. + template + void restoreChannelMaskImages(InputIterator first_,InputIterator last_, + Container *container_) + { + typename Container::iterator + channel_mask; + + channel_mask=container_->begin(); + for (InputIterator iter = first_; iter != last_; ++iter) + { + iter->modifyImage(); + (void) MagickCore::SetImageChannelMask(iter->image(), + (const MagickCore::ChannelType) *channel_mask); + channel_mask++; + } + } + + // Remove links added by linkImages. This should be called after the + // ImageMagick function call has completed to reset the image list + // back to its pristine un-linked state. + template + void unlinkImages(InputIterator first_,InputIterator last_) + { + MagickCore::Image + *image; + + for (InputIterator iter = first_; iter != last_; ++iter) + { + image=iter->image(); + image->previous=(MagickCore::Image *) NULL; + image->next=(MagickCore::Image *) NULL; + } + } + + /////////////////////////////////////////////////////////////////// + // + // Template definitions for documented API + // + /////////////////////////////////////////////////////////////////// + + template + void animateImages( InputIterator first_,InputIterator last_) + { + if (linkImages(first_,last_) == false) + return; + GetPPException; + MagickCore::AnimateImages(first_->imageInfo(),first_->image(), + exceptionInfo); + unlinkImages(first_,last_); + ThrowPPException(first_->quiet()); + } + + // Append images from list into single image in either horizontal or + // vertical direction. + template + void appendImages( Image *appendedImage_, + InputIterator first_, + InputIterator last_, + bool stack_ = false) { + if (linkImages(first_,last_) == false) + return; + GetPPException; + MagickCore::Image* image = MagickCore::AppendImages( first_->image(), + (MagickBooleanType) stack_, + exceptionInfo ); + unlinkImages( first_, last_ ); + appendedImage_->replaceImage( image ); + ThrowPPException(appendedImage_->quiet()); + } + + // Adds the names of the artifacts of the image to the container. + template + void artifactNames(Container *names_,const Image* image_) + { + const char* + name; + + names_->clear(); + + MagickCore::ResetImageArtifactIterator(image_->constImage()); + name=MagickCore::GetNextImageArtifact(image_->constImage()); + while (name != (const char *) NULL) + { + names_->push_back(std::string(name)); + name=MagickCore::GetNextImageArtifact(image_->constImage()); + } + } + + // Adds the names of the attributes of the image to the container. + template + void attributeNames(Container *names_,const Image* image_) + { + const char* + name; + + names_->clear(); + + MagickCore::ResetImagePropertyIterator(image_->constImage()); + name=MagickCore::GetNextImageProperty(image_->constImage()); + while (name != (const char *) NULL) + { + names_->push_back(std::string(name)); + name=MagickCore::GetNextImageProperty(image_->constImage()); + } + } + + // Average a set of images. + // All the input images must be the same size in pixels. + template + void averageImages( Image *averagedImage_, + InputIterator first_, + InputIterator last_ ) { + if (linkImages(first_,last_) == false) + return; + GetPPException; + MagickCore::Image* image = MagickCore::EvaluateImages( first_->image(), + MagickCore::MeanEvaluateOperator, exceptionInfo ); + unlinkImages( first_, last_ ); + averagedImage_->replaceImage( image ); + ThrowPPException(averagedImage_->quiet()); + } + + // Merge a sequence of images. + // This is useful for GIF animation sequences that have page + // offsets and disposal methods. A container to contain + // the updated image sequence is passed via the coalescedImages_ + // option. + template + void coalesceImages( Container *coalescedImages_, + InputIterator first_, + InputIterator last_ ) { + if (linkImages(first_,last_) == false) + return; + GetPPException; + MagickCore::Image* images = MagickCore::CoalesceImages( first_->image(), + exceptionInfo); + // Unlink image list + unlinkImages( first_, last_ ); + + // Ensure container is empty + coalescedImages_->clear(); + + // Move images to container + insertImages( coalescedImages_, images ); + + // Report any error + ThrowPPException(first_->quiet()); + } + + // Return format coders matching specified conditions. + // + // The default (if no match terms are supplied) is to return all + // available format coders. + // + // For example, to return all readable formats: + // list coderList; + // coderInfoList( &coderList, CoderInfo::TrueMatch, CoderInfo::AnyMatch, CoderInfo::AnyMatch) + // + template + void coderInfoList( Container *container_, + CoderInfo::MatchType isReadable_ = CoderInfo::AnyMatch, + CoderInfo::MatchType isWritable_ = CoderInfo::AnyMatch, + CoderInfo::MatchType isMultiFrame_ = CoderInfo::AnyMatch + ) { + // Obtain first entry in MagickInfo list + size_t number_formats; + GetPPException; + char **coder_list = + MagickCore::GetMagickList( "*", &number_formats, exceptionInfo ); + if( !coder_list ) + { + throwException(exceptionInfo); + throwExceptionExplicit(MagickCore::MissingDelegateError, + "Coder array not returned!", 0 ); + } + + // Clear out container + container_->clear(); + + for ( ::ssize_t i=0; i < (::ssize_t) number_formats; i++) + { + const MagickCore::MagickInfo *magick_info = + MagickCore::GetMagickInfo( coder_list[i], exceptionInfo ); + coder_list[i]=(char *) + MagickCore::RelinquishMagickMemory( coder_list[i] ); + + // Skip stealth coders + if ( MagickCore::GetMagickStealth(magick_info) ) + continue; + + try { + CoderInfo coderInfo( magick_info->name ); + + // Test isReadable_ + if ( isReadable_ != CoderInfo::AnyMatch && + (( coderInfo.isReadable() && isReadable_ != CoderInfo::TrueMatch ) || + ( !coderInfo.isReadable() && isReadable_ != CoderInfo::FalseMatch )) ) + continue; + + // Test isWritable_ + if ( isWritable_ != CoderInfo::AnyMatch && + (( coderInfo.isWritable() && isWritable_ != CoderInfo::TrueMatch ) || + ( !coderInfo.isWritable() && isWritable_ != CoderInfo::FalseMatch )) ) + continue; + + // Test isMultiFrame_ + if ( isMultiFrame_ != CoderInfo::AnyMatch && + (( coderInfo.isMultiFrame() && isMultiFrame_ != CoderInfo::TrueMatch ) || + ( !coderInfo.isMultiFrame() && isMultiFrame_ != CoderInfo::FalseMatch )) ) + continue; + + // Append matches to container + container_->push_back( coderInfo ); + } + // Intentionally ignore missing module errors + catch ( Magick::ErrorModule ) + { + continue; + } + } + coder_list=(char **) MagickCore::RelinquishMagickMemory( coder_list ); + ThrowPPException(false); + } + + // + // Fill container with color histogram. + // Entries are of type "std::pair". Use the pair + // "first" member to access the Color and the "second" member to access + // the number of times the color occurs in the image. + // + // For example: + // + // Using : + // + // Image image("image.miff"); + // map histogram; + // colorHistogram( &histogram, image ); + // std::map::const_iterator p=histogram.begin(); + // while (p != histogram.end()) + // { + // cout << setw(10) << (int)p->second << ": (" + // << setw(quantum_width) << (int)p->first.redQuantum() << "," + // << setw(quantum_width) << (int)p->first.greenQuantum() << "," + // << setw(quantum_width) << (int)p->first.blueQuantum() << ")" + // << endl; + // p++; + // } + // + // Using : + // + // Image image("image.miff"); + // std::vector > histogram; + // colorHistogram( &histogram, image ); + // std::vector >::const_iterator p=histogram.begin(); + // while (p != histogram.end()) + // { + // cout << setw(10) << (int)p->second << ": (" + // << setw(quantum_width) << (int)p->first.redQuantum() << "," + // << setw(quantum_width) << (int)p->first.greenQuantum() << "," + // << setw(quantum_width) << (int)p->first.blueQuantum() << ")" + // << endl; + // p++; + // } + + template + void colorHistogram( Container *histogram_, const Image image) + { + GetPPException; + + // Obtain histogram array + size_t colors; + MagickCore::PixelInfo *histogram_array = + MagickCore::GetImageHistogram( image.constImage(), &colors, exceptionInfo ); + ThrowPPException(image.quiet()); + + // Clear out container + histogram_->clear(); + + // Transfer histogram array to container + for ( size_t i=0; i < colors; i++) + { + histogram_->insert( histogram_->end(), std::pair + ( Color(histogram_array[i]), (size_t) histogram_array[i].count) ); + } + + // Deallocate histogram array + histogram_array=(MagickCore::PixelInfo *) + MagickCore::RelinquishMagickMemory(histogram_array); + } + + // Combines one or more images into a single image. The grayscale value of + // the pixels of each image in the sequence is assigned in order to the + // specified channels of the combined image. The typical ordering would be + // image 1 => Red, 2 => Green, 3 => Blue, etc. + template + void combineImages(Image *combinedImage_,InputIterator first_, + InputIterator last_,const ChannelType channel_, + const ColorspaceType colorspace_) + { + MagickCore::Image + *image; + + std::vector + channelMask; + + if (linkImages(first_,last_) == false) + return; + GetPPException; + channelMaskImages(first_,last_,&channelMask,channel_); + image=CombineImages(first_->image(),colorspace_,exceptionInfo); + restoreChannelMaskImages(first_,last_,&channelMask); + unlinkImages(first_,last_); + combinedImage_->replaceImage(image); + ThrowPPException(combinedImage_->quiet()); + } + + template + void cropToTiles(Container *tiledImages_,const Image image_, + const Geometry &geometry_) + { + GetPPException; + MagickCore::Image* images=CropImageToTiles(image_.constImage(), + static_cast(geometry_).c_str(),exceptionInfo); + tiledImages_->clear(); + insertImages(tiledImages_,images); + ThrowPPException(image_.quiet()); + } + + // Break down an image sequence into constituent parts. This is + // useful for creating GIF or MNG animation sequences. + template + void deconstructImages(Container *deconstructedImages_, + InputIterator first_,InputIterator last_) + { + MagickCore::Image + *images; + + if (linkImages(first_,last_) == false) + return; + GetPPException; + images=CompareImagesLayers(first_->image(),CompareAnyLayer,exceptionInfo); + unlinkImages(first_,last_); + + deconstructedImages_->clear(); + insertImages(deconstructedImages_,images); + + ThrowPPException(first_->quiet()); + } + + // + // Display an image sequence + // + template + void displayImages(InputIterator first_,InputIterator last_) + { + if (linkImages(first_,last_) == false) + return; + GetPPException; + MagickCore::DisplayImages(first_->imageInfo(),first_->image(), + exceptionInfo); + unlinkImages(first_,last_); + ThrowPPException(first_->quiet()); + } + + // Applies a value to the image with an arithmetic, relational, + // or logical operator to an image. Use these operations to lighten or darken + // an image, to increase or decrease contrast in an image, or to produce the + // "negative" of an image. + template + void evaluateImages( Image *evaluatedImage_, + InputIterator first_, + InputIterator last_, + const MagickEvaluateOperator operator_ ) { + if (linkImages(first_,last_) == false) + return; + GetPPException; + MagickCore::Image* image = EvaluateImages( first_->image(), operator_, exceptionInfo ); + unlinkImages( first_, last_ ); + evaluatedImage_->replaceImage( image ); + ThrowPPException(evaluatedImage_->quiet()); + } + + // Merge a sequence of image frames which represent image layers. + // This is useful for combining Photoshop layers into a single image. + template + void flattenImages( Image *flattendImage_, + InputIterator first_, + InputIterator last_ ) { + if (linkImages(first_,last_) == false) + return; + GetPPException; + MagickCore::Image* image = MagickCore::MergeImageLayers( first_->image(), + FlattenLayer,exceptionInfo ); + unlinkImages( first_, last_ ); + flattendImage_->replaceImage( image ); + ThrowPPException(flattendImage_->quiet()); + } + + // Implements the discrete Fourier transform (DFT) of the image either as a + // magnitude / phase or real / imaginary image pair. + template + void forwardFourierTransformImage( Container *fourierImages_, + const Image &image_ ) { + GetPPException; + + // Build image list + MagickCore::Image* images = ForwardFourierTransformImage( + image_.constImage(), MagickTrue, exceptionInfo); + + // Ensure container is empty + fourierImages_->clear(); + + // Move images to container + insertImages( fourierImages_, images ); + + // Report any error + ThrowPPException(image_.quiet()); + } + template + void forwardFourierTransformImage( Container *fourierImages_, + const Image &image_, const bool magnitude_ ) { + GetPPException; + + // Build image list + MagickCore::Image* images = ForwardFourierTransformImage( + image_.constImage(), magnitude_ == true ? MagickTrue : MagickFalse, + exceptionInfo); + + // Ensure container is empty + fourierImages_->clear(); + + // Move images to container + insertImages( fourierImages_, images ); + + // Report any error + ThrowPPException(image_.quiet()); + } + + // Applies a mathematical expression to a sequence of images. + template + void fxImages(Image *fxImage_,InputIterator first_,InputIterator last_, + const std::string expression) + { + MagickCore::Image + *image; + + if (linkImages(first_,last_) == false) + return; + GetPPException; + image=FxImage(first_->constImage(),expression.c_str(),exceptionInfo); + unlinkImages(first_,last_); + fxImage_->replaceImage(image); + ThrowPPException(fxImage_->quiet()); + } + + // Replace the colors of a sequence of images with the closest color + // from a reference image. + // Set dither_ to true to enable dithering. Set measureError_ to + // true in order to evaluate quantization error. + template + void mapImages(InputIterator first_,InputIterator last_, + const Image& mapImage_,bool dither_=false,bool measureError_=false) + { + MagickCore::Image + *image; + + MagickCore::QuantizeInfo + quantizeInfo; + + if (linkImages(first_,last_) == false) + return; + GetPPException; + MagickCore::GetQuantizeInfo(&quantizeInfo); + quantizeInfo.dither_method = dither_ ? MagickCore::RiemersmaDitherMethod : + MagickCore::NoDitherMethod; + MagickCore::RemapImages(&quantizeInfo,first_->image(), + (mapImage_.isValid() ? mapImage_.constImage() : + (const MagickCore::Image*) NULL),exceptionInfo); + unlinkImages(first_,last_); + if (exceptionInfo->severity != MagickCore::UndefinedException) + { + unlinkImages(first_,last_); + throwException(exceptionInfo,mapImage_.quiet()); + } + + image=first_->image(); + while(image != (MagickCore::Image *) NULL) + { + // Calculate quantization error + if (measureError_) + { + MagickCore::GetImageQuantizeError(image,exceptionInfo); + if (exceptionInfo->severity > MagickCore::UndefinedException) + { + unlinkImages(first_,last_); + throwException(exceptionInfo,mapImage_.quiet()); + } + } + + // Update DirectClass representation of pixels + MagickCore::SyncImage(image,exceptionInfo); + if (exceptionInfo->severity > MagickCore::UndefinedException) + { + unlinkImages(first_,last_); + throwException(exceptionInfo,mapImage_.quiet()); + } + + // Next image + image=image->next; + } + + unlinkImages(first_,last_); + (void) MagickCore::DestroyExceptionInfo(exceptionInfo); + } + + // Composes all the image layers from the current given + // image onward to produce a single image of the merged layers. + template + void mergeImageLayers( Image *mergedImage_, + InputIterator first_, + InputIterator last_, + const LayerMethod method_ ) { + if (linkImages(first_,last_) == false) + return; + GetPPException; + MagickCore::Image* image = MergeImageLayers( first_->image(), method_, exceptionInfo ); + unlinkImages( first_, last_ ); + mergedImage_->replaceImage( image ); + ThrowPPException(mergedImage_->quiet()); + } + + // Create a composite image by combining several separate images. + template + void montageImages(Container *montageImages_,InputIterator first_, + InputIterator last_,const Montage &options_) + { + MagickCore::Image + *images; + + MagickCore::MontageInfo + *montageInfo; + + if (linkImages(first_,last_) == false) + return; + + montageInfo=static_cast( + MagickCore::AcquireMagickMemory(sizeof(MagickCore::MontageInfo))); + + // Update montage options with those set in montageOpts_ + options_.updateMontageInfo(*montageInfo); + + // Update options which must transfer to image options + if (options_.label().length() != 0) + first_->label(options_.label()); + + // Do montage + GetPPException; + images=MagickCore::MontageImages(first_->image(),montageInfo, + exceptionInfo); + + // Unlink linked image list + unlinkImages(first_,last_); + + // Reset output container to pristine state + montageImages_->clear(); + + if (images != (MagickCore::Image *) NULL) + insertImages(montageImages_,images); + + // Clean up any allocated data in montageInfo + MagickCore::DestroyMontageInfo(montageInfo); + + // Report any montage error + ThrowPPException(first_->quiet()); + + // Apply transparency to montage images + if (montageImages_->size() > 0 && options_.transparentColor().isValid()) + for_each(montageImages_->begin(),montageImages_->end(),transparentImage( + options_.transparentColor())); + } + + // Morph a set of images + template + void morphImages( Container *morphedImages_, + InputIterator first_, + InputIterator last_, + size_t frames_ ) { + if (linkImages(first_,last_) == false) + return; + GetPPException; + + MagickCore::Image* images = MagickCore::MorphImages( first_->image(), frames_, + exceptionInfo); + // Unlink image list + unlinkImages( first_, last_ ); + + // Ensure container is empty + morphedImages_->clear(); + + // Move images to container + insertImages( morphedImages_, images ); + + // Report any error + ThrowPPException(first_->quiet()); + } + + // Inlay a number of images to form a single coherent picture. + template + void mosaicImages( Image *mosaicImage_, + InputIterator first_, + InputIterator last_ ) { + if (linkImages(first_,last_) == false) + return; + GetPPException; + MagickCore::Image* image = MagickCore::MergeImageLayers( first_->image(), + MosaicLayer,exceptionInfo ); + unlinkImages( first_, last_ ); + mosaicImage_->replaceImage( image ); + ThrowPPException(mosaicImage_->quiet()); + } + + // Compares each image the GIF disposed forms of the previous image in + // the sequence. From this it attempts to select the smallest cropped + // image to replace each frame, while preserving the results of the + // GIF animation. + template + void optimizeImageLayers( Container *optimizedImages_, + InputIterator first_, + InputIterator last_ ) { + if (linkImages(first_,last_) == false) + return; + GetPPException; + MagickCore::Image* images = OptimizeImageLayers( first_->image(), exceptionInfo ); + + unlinkImages( first_, last_ ); + + optimizedImages_->clear(); + + insertImages( optimizedImages_, images ); + + ThrowPPException(first_->quiet()); + } + + // optimizeImagePlusLayers is exactly as optimizeImageLayers, but may + // also add or even remove extra frames in the animation, if it improves + // the total number of pixels in the resulting GIF animation. + template + void optimizePlusImageLayers( Container *optimizedImages_, + InputIterator first_, + InputIterator last_ ) { + if (linkImages(first_,last_) == false) + return; + GetPPException; + MagickCore::Image* images = OptimizePlusImageLayers( first_->image(), exceptionInfo ); + + unlinkImages( first_, last_ ); + + optimizedImages_->clear(); + + insertImages( optimizedImages_, images ); + + ThrowPPDrawException(first_->quiet()); + } + + // Compares each image the GIF disposed forms of the previous image in the + // sequence. Any pixel that does not change the displayed result is replaced + // with transparency. + template + void optimizeTransparency(InputIterator first_,InputIterator last_) + { + if (linkImages(first_,last_) == false) + return; + GetPPException; + OptimizeImageTransparency(first_->image(),exceptionInfo); + unlinkImages(first_,last_ ); + + ThrowPPException(first_->quiet()); + } + + // Adds the names of the profiles of the image to the container. + template + void profileNames(Container *names_,const Image* image_) + { + const char* + name; + + names_->clear(); + + MagickCore::ResetImageProfileIterator(image_->constImage()); + name=MagickCore::GetNextImageProfile(image_->constImage()); + while (name != (const char *) NULL) + { + names_->push_back(std::string(name)); + name=MagickCore::GetNextImageProfile(image_->constImage()); + } + } + + // Quantize colors in images using current quantization settings + // Set measureError_ to true in order to measure quantization error + template + void quantizeImages(InputIterator first_,InputIterator last_, + bool measureError_ = false) + { + if (linkImages(first_,last_) == false) + return; + GetPPException; + MagickCore::QuantizeImages(first_->quantizeInfo(),first_->image(), + exceptionInfo); + unlinkImages(first_,last_); + + MagickCore::Image *image=first_->image(); + while (image != (MagickCore::Image *) NULL) + { + // Calculate quantization error + if (measureError_) + MagickCore::GetImageQuantizeError(image,exceptionInfo); + + // Update DirectClass representation of pixels + MagickCore::SyncImage(image,exceptionInfo); + + image=image->next; + } + unlinkImages(first_,last_); + ThrowPPException(first_->quiet()); + } + + // Read images into existing container (appending to container) + template + void readImages(Container *sequence_,const std::string &imageSpec_, + ReadOptions &options) + { + MagickCore::Image + *images; + + MagickCore::ImageInfo + *imageInfo; + + imageInfo=options.imageInfo(); + imageSpec_.copy(imageInfo->filename,MagickPathExtent-1); + imageInfo->filename[imageSpec_.length()] = 0; + GetPPException; + images=MagickCore::ReadImage(imageInfo,exceptionInfo); + insertImages(sequence_,images); + ThrowPPException(options.quiet()); + } + + template + void readImages(Container *sequence_,const std::string &imageSpec_) + { + ReadOptions options; + readImages(sequence_,imageSpec_,options); + } + + template + void readImages(Container *sequence_,const Blob &blob_,ReadOptions &options) + { + MagickCore::Image + *images; + + GetPPException; + images=MagickCore::BlobToImage(options.imageInfo(),blob_.data(), + blob_.length(),exceptionInfo); + insertImages(sequence_,images); + ThrowPPException(options.quiet()); + } + + template + void readImages(Container *sequence_,const Blob &blob_) + { + ReadOptions options; + readImages(sequence_,blob_,options); + } + + // Returns a separate grayscale image for each channel specified. + template + void separateImages(Container *separatedImages_,Image &image_, + const ChannelType channel_) + { + MagickCore::ChannelType + channel_mask; + + MagickCore::Image + *images; + + GetPPException; + channel_mask=MagickCore::SetImageChannelMask(image_.image(),channel_); + images=SeparateImages(image_.constImage(),exceptionInfo); + MagickCore::SetPixelChannelMask(image_.image(),channel_mask); + + separatedImages_->clear(); + insertImages(separatedImages_,images); + + ThrowPPException(image_.quiet()); + } + + // Smush images from list into single image in either horizontal or + // vertical direction. + template + void smushImages(Image *smushedImage_,InputIterator first_, + InputIterator last_,const ssize_t offset_,bool stack_=false) + { + MagickCore::Image + *newImage; + + if (linkImages(first_,last_) == false) + return; + GetPPException; + newImage=MagickCore::SmushImages(first_->constImage(), + (MagickBooleanType) stack_,offset_,exceptionInfo); + unlinkImages(first_,last_); + smushedImage_->replaceImage(newImage); + ThrowPPException(smushedImage_->quiet()); + } + + // Write Images + template + void writeImages( InputIterator first_, + InputIterator last_, + const std::string &imageSpec_, + bool adjoin_ = true ) { + + if (linkImages(first_,last_) == false) + return; + + first_->adjoin( adjoin_ ); + + GetPPException; + ::ssize_t errorStat = MagickCore::WriteImages( first_->constImageInfo(), + first_->image(), + imageSpec_.c_str(), + exceptionInfo ); + unlinkImages( first_, last_ ); + + if ( errorStat != false ) + { + (void) MagickCore::DestroyExceptionInfo( exceptionInfo ); + return; + } + + ThrowPPException(first_->quiet()); + } + // Write images to BLOB + template + void writeImages( InputIterator first_, + InputIterator last_, + Blob *blob_, + bool adjoin_ = true) { + if (linkImages(first_,last_) == false) + return; + + first_->adjoin( adjoin_ ); + + GetPPException; + size_t length = 2048; // Efficient size for small images + void* data = MagickCore::ImagesToBlob( first_->imageInfo(), + first_->image(), + &length, + exceptionInfo); + blob_->updateNoCopy( data, length, Magick::Blob::MallocAllocator ); + + unlinkImages( first_, last_ ); + + ThrowPPException(first_->quiet()); + } + +} // namespace Magick + +#endif // Magick_STL_header diff --git a/bin/7.0.5-5/include/ImageMagick-7/Magick++/Statistic.h b/bin/7.0.5-5/include/ImageMagick-7/Magick++/Statistic.h new file mode 100755 index 0000000..f9d46a6 --- /dev/null +++ b/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 + +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 _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 _srgbHuPhash; + std::vector _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 _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 _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 _channels; + }; +} + +#endif // Magick_ChannelMoments_header diff --git a/bin/7.0.5-5/include/ImageMagick-7/Magick++/TypeMetric.h b/bin/7.0.5-5/include/ImageMagick-7/Magick++/TypeMetric.h new file mode 100755 index 0000000..338616b --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/MagickCore.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/MagickCore.h new file mode 100755 index 0000000..1e6d6af --- /dev/null +++ b/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 +#include +#include +#include +#include +#include + +#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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/animate.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/animate.h new file mode 100755 index 0000000..39c3552 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/annotate.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/annotate.h new file mode 100755 index 0000000..d74f924 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/artifact.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/artifact.h new file mode 100755 index 0000000..c4687cb --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/attribute.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/attribute.h new file mode 100755 index 0000000..746c794 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/blob.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/blob.h new file mode 100755 index 0000000..e16fcc5 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/cache-view.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/cache-view.h new file mode 100755 index 0000000..aa39b22 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/cache.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/cache.h new file mode 100755 index 0000000..133c860 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/channel.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/channel.h new file mode 100755 index 0000000..c2cceac --- /dev/null +++ b/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 + +#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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/cipher.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/cipher.h new file mode 100755 index 0000000..5913613 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/client.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/client.h new file mode 100755 index 0000000..52d2de8 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/coder.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/coder.h new file mode 100755 index 0000000..8ad596d --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/color.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/color.h new file mode 100755 index 0000000..8ca1404 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/colormap.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/colormap.h new file mode 100755 index 0000000..d4219fb --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/colorspace.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/colorspace.h new file mode 100755 index 0000000..9187e53 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/compare.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/compare.h new file mode 100755 index 0000000..79bf6ad --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/composite.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/composite.h new file mode 100755 index 0000000..ca65821 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/compress.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/compress.h new file mode 100755 index 0000000..9562385 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/configure.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/configure.h new file mode 100755 index 0000000..3ab20a9 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/constitute.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/constitute.h new file mode 100755 index 0000000..2d731e4 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/decorate.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/decorate.h new file mode 100755 index 0000000..fbe43e8 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/delegate.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/delegate.h new file mode 100755 index 0000000..360e559 --- /dev/null +++ b/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 +#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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/deprecate.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/deprecate.h new file mode 100755 index 0000000..0ebe684 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/display.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/display.h new file mode 100755 index 0000000..6f6eae7 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/distort.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/distort.h new file mode 100755 index 0000000..b30fdfd --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/distribute-cache.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/distribute-cache.h new file mode 100755 index 0000000..8b3963f --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/draw.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/draw.h new file mode 100755 index 0000000..41ec1e3 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/effect.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/effect.h new file mode 100755 index 0000000..64d004e --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/enhance.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/enhance.h new file mode 100755 index 0000000..4fd563f --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/exception.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/exception.h new file mode 100755 index 0000000..f3166de --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/feature.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/feature.h new file mode 100755 index 0000000..4bccfb3 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/fourier.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/fourier.h new file mode 100755 index 0000000..219e20c --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/fx.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/fx.h new file mode 100755 index 0000000..3dae953 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/gem.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/gem.h new file mode 100755 index 0000000..cab696e --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/geometry.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/geometry.h new file mode 100755 index 0000000..b21776c --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/histogram.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/histogram.h new file mode 100755 index 0000000..074d87d --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/identify.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/identify.h new file mode 100755 index 0000000..b47f8d9 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/image-view.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/image-view.h new file mode 100755 index 0000000..d8ce1f5 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/image.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/image.h new file mode 100755 index 0000000..3b78e4c --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/layer.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/layer.h new file mode 100755 index 0000000..8e5c2d7 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/linked-list.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/linked-list.h new file mode 100755 index 0000000..276f3e7 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/list.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/list.h new file mode 100755 index 0000000..bc6136b --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/locale_.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/locale_.h new file mode 100755 index 0000000..ddda6fd --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/log.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/log.h new file mode 100755 index 0000000..46c5e21 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/magic.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/magic.h new file mode 100755 index 0000000..f016ad5 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/magick-baseconfig.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/magick-baseconfig.h new file mode 100755 index 0000000..338ba24 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/magick-baseconfig.h @@ -0,0 +1,1640 @@ +#ifndef _MAGICKCORE_MAGICK_BASECONFIG_H +#define _MAGICKCORE_MAGICK_BASECONFIG_H 1 + +/* MagickCore/magick-baseconfig.h. Generated automatically at end of configure. */ +/* config/config.h. Generated from config.h.in by configure. */ +/* config/config.h.in. Generated from configure.ac by autoheader. */ + +/* Define if building universal (internal helper macro) */ +/* #undef AC_APPLE_UNIVERSAL_BUILD */ + +/* Define if you have AUTOTRACE library */ +/* #undef AUTOTRACE_DELEGATE */ + +/* Define if coders and filters are to be built as modules. */ +/* #undef BUILD_MODULES */ + +/* Define if you have the bzip2 library */ +#ifndef MAGICKCORE_BZLIB_DELEGATE +#define MAGICKCORE_BZLIB_DELEGATE 1 +#endif + +/* Define if you have CAIRO library */ +/* #undef CAIRO_DELEGATE */ + +/* permit enciphering and deciphering image pixels */ +#ifndef MAGICKCORE_CIPHER_SUPPORT +#define MAGICKCORE_CIPHER_SUPPORT 1 +#endif + +/* Define to 1 if the `closedir' function returns void instead of `int'. */ +/* #undef CLOSEDIR_VOID */ + +/* coders subdirectory. */ +#ifndef MAGICKCORE_CODER_DIRNAME +#define MAGICKCORE_CODER_DIRNAME "coders" +#endif + +/* Directory where architecture-dependent configuration files live. */ +#ifndef MAGICKCORE_CONFIGURE_PATH +#define MAGICKCORE_CONFIGURE_PATH "/Users/johannespichler/Downloads/newTest/build/etc/ImageMagick-7/" +#endif + +/* Subdirectory of lib where architecture-dependent configuration files live. + */ +#ifndef MAGICKCORE_CONFIGURE_RELATIVE_PATH +#define MAGICKCORE_CONFIGURE_RELATIVE_PATH "ImageMagick-7" +#endif + +/* Define if you have DJVU library */ +/* #undef DJVU_DELEGATE */ + +/* Directory where ImageMagick documents live. */ +#ifndef MAGICKCORE_DOCUMENTATION_PATH +#define MAGICKCORE_DOCUMENTATION_PATH "/Users/johannespichler/Downloads/newTest/build/share/doc/ImageMagick-7/" +#endif + +/* Define if you have Display Postscript */ +/* #undef DPS_DELEGATE */ + +/* exclude deprecated methods in MagickCore API */ +/* #undef EXCLUDE_DEPRECATED */ + +/* Directory where executables are installed. */ +#ifndef MAGICKCORE_EXECUTABLE_PATH +#define MAGICKCORE_EXECUTABLE_PATH "/Users/johannespichler/Downloads/newTest/build/bin/" +#endif + +/* Define if you have FFTW library */ +#ifndef MAGICKCORE_FFTW_DELEGATE +#define MAGICKCORE_FFTW_DELEGATE 1 +#endif + +/* filter subdirectory. */ +#ifndef MAGICKCORE_FILTER_DIRNAME +#define MAGICKCORE_FILTER_DIRNAME "filters" +#endif + +/* Define if you have FLIF library */ +/* #undef FLIF_DELEGATE */ + +/* Define if you have FONTCONFIG library */ +/* #undef FONTCONFIG_DELEGATE */ + +/* Define if you have FlashPIX library */ +/* #undef FPX_DELEGATE */ + +/* Define if you have FREETYPE library */ +/* #undef FREETYPE_DELEGATE */ + +/* Define if you have Ghostscript library or framework */ +/* #undef GS_DELEGATE */ + +/* Define if you have GVC library */ +/* #undef GVC_DELEGATE */ + +/* Define to 1 if you have the `acosh' function. */ +#ifndef MAGICKCORE_HAVE_ACOSH +#define MAGICKCORE_HAVE_ACOSH 1 +#endif + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_ARM_LIMITS_H */ + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_ARPA_INET_H +#define MAGICKCORE_HAVE_ARPA_INET_H 1 +#endif + +/* Define to 1 if you have the `asinh' function. */ +#ifndef MAGICKCORE_HAVE_ASINH +#define MAGICKCORE_HAVE_ASINH 1 +#endif + +/* Define to 1 if you have the `atanh' function. */ +#ifndef MAGICKCORE_HAVE_ATANH +#define MAGICKCORE_HAVE_ATANH 1 +#endif + +/* Define to 1 if you have the `atexit' function. */ +#ifndef MAGICKCORE_HAVE_ATEXIT +#define MAGICKCORE_HAVE_ATEXIT 1 +#endif + +/* Define to 1 if you have the `atoll' function. */ +#ifndef MAGICKCORE_HAVE_ATOLL +#define MAGICKCORE_HAVE_ATOLL 1 +#endif + +/* define if bool is a built-in type */ +#ifndef MAGICKCORE_HAVE_BOOL +#define MAGICKCORE_HAVE_BOOL /**/ +#endif + +/* Define to 1 if you have the `cabs' function. */ +#ifndef MAGICKCORE_HAVE_CABS +#define MAGICKCORE_HAVE_CABS 1 +#endif + +/* Define to 1 if you have the `carg' function. */ +#ifndef MAGICKCORE_HAVE_CARG +#define MAGICKCORE_HAVE_CARG 1 +#endif + +/* Define to 1 if you have the `cimag' function. */ +#ifndef MAGICKCORE_HAVE_CIMAG +#define MAGICKCORE_HAVE_CIMAG 1 +#endif + +/* Define to 1 if you have the `clock' function. */ +#ifndef MAGICKCORE_HAVE_CLOCK +#define MAGICKCORE_HAVE_CLOCK 1 +#endif + +/* Define to 1 if you have the `clock_getres' function. */ +#ifndef MAGICKCORE_HAVE_CLOCK_GETRES +#define MAGICKCORE_HAVE_CLOCK_GETRES 1 +#endif + +/* Define to 1 if you have clock_gettime. */ +#ifndef MAGICKCORE_HAVE_CLOCK_GETTIME +#define MAGICKCORE_HAVE_CLOCK_GETTIME 1 +#endif + +/* Define to 1 if clock_gettime supports CLOCK_REALTIME. */ +#ifndef MAGICKCORE_HAVE_CLOCK_REALTIME +#define MAGICKCORE_HAVE_CLOCK_REALTIME 1 +#endif + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_CL_CL_H */ + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_COMPLEX_H +#define MAGICKCORE_HAVE_COMPLEX_H 1 +#endif + +/* Define to 1 if you have the `creal' function. */ +#ifndef MAGICKCORE_HAVE_CREAL +#define MAGICKCORE_HAVE_CREAL 1 +#endif + +/* Define to 1 if you have the `ctime_r' function. */ +#ifndef MAGICKCORE_HAVE_CTIME_R +#define MAGICKCORE_HAVE_CTIME_R 1 +#endif + +/* Define to 1 if you have the declaration of `pread', and to 0 if you don't. + */ +#ifndef MAGICKCORE_HAVE_DECL_PREAD +#define MAGICKCORE_HAVE_DECL_PREAD 1 +#endif + +/* Define to 1 if you have the declaration of `pwrite', and to 0 if you don't. + */ +#ifndef MAGICKCORE_HAVE_DECL_PWRITE +#define MAGICKCORE_HAVE_DECL_PWRITE 1 +#endif + +/* Define to 1 if you have the declaration of `strerror_r', and to 0 if you + don't. */ +#ifndef MAGICKCORE_HAVE_DECL_STRERROR_R +#define MAGICKCORE_HAVE_DECL_STRERROR_R 1 +#endif + +/* Define to 1 if you have the declaration of `strlcpy', and to 0 if you + don't. */ +#ifndef MAGICKCORE_HAVE_DECL_STRLCPY +#define MAGICKCORE_HAVE_DECL_STRLCPY 1 +#endif + +/* Define to 1 if you have the declaration of `tzname', and to 0 if you don't. + */ +/* #undef HAVE_DECL_TZNAME */ + +/* Define to 1 if you have the declaration of `vsnprintf', and to 0 if you + don't. */ +#ifndef MAGICKCORE_HAVE_DECL_VSNPRINTF +#define MAGICKCORE_HAVE_DECL_VSNPRINTF 1 +#endif + +/* Define to 1 if you have the `directio' function. */ +/* #undef HAVE_DIRECTIO */ + +/* Define to 1 if you have the header file, and it defines `DIR'. + */ +#ifndef MAGICKCORE_HAVE_DIRENT_H +#define MAGICKCORE_HAVE_DIRENT_H 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_DLFCN_H +#define MAGICKCORE_HAVE_DLFCN_H 1 +#endif + +/* Define to 1 if you don't have `vprintf' but do have `_doprnt.' */ +/* #undef HAVE_DOPRNT */ + +/* Define to 1 if the system has the type `double_t'. */ +#ifndef MAGICKCORE_HAVE_DOUBLE_T +#define MAGICKCORE_HAVE_DOUBLE_T 1 +#endif + +/* Define to 1 if you have the `erf' function. */ +#ifndef MAGICKCORE_HAVE_ERF +#define MAGICKCORE_HAVE_ERF 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_ERRNO_H +#define MAGICKCORE_HAVE_ERRNO_H 1 +#endif + +/* Define to 1 if you have the `execvp' function. */ +#ifndef MAGICKCORE_HAVE_EXECVP +#define MAGICKCORE_HAVE_EXECVP 1 +#endif + +/* Define to 1 if you have the `fchmod' function. */ +#ifndef MAGICKCORE_HAVE_FCHMOD +#define MAGICKCORE_HAVE_FCHMOD 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_FCNTL_H +#define MAGICKCORE_HAVE_FCNTL_H 1 +#endif + +/* Define to 1 if the system has the type `float_t'. */ +#ifndef MAGICKCORE_HAVE_FLOAT_T +#define MAGICKCORE_HAVE_FLOAT_T 1 +#endif + +/* Define to 1 if you have the `floor' function. */ +#ifndef MAGICKCORE_HAVE_FLOOR +#define MAGICKCORE_HAVE_FLOOR 1 +#endif + +/* Define to 1 if you have the `fork' function. */ +#ifndef MAGICKCORE_HAVE_FORK +#define MAGICKCORE_HAVE_FORK 1 +#endif + +/* Define to 1 if fseeko (and presumably ftello) exists and is declared. */ +#ifndef MAGICKCORE_HAVE_FSEEKO +#define MAGICKCORE_HAVE_FSEEKO 1 +#endif + +/* Define to 1 if you have the `ftime' function. */ +#ifndef MAGICKCORE_HAVE_FTIME +#define MAGICKCORE_HAVE_FTIME 1 +#endif + +/* Define to 1 if you have the `ftruncate' function. */ +#ifndef MAGICKCORE_HAVE_FTRUNCATE +#define MAGICKCORE_HAVE_FTRUNCATE 1 +#endif + +/* Define to 1 if you have the `getcwd' function. */ +#ifndef MAGICKCORE_HAVE_GETCWD +#define MAGICKCORE_HAVE_GETCWD 1 +#endif + +/* Define to 1 if you have the `getc_unlocked' function. */ +#ifndef MAGICKCORE_HAVE_GETC_UNLOCKED +#define MAGICKCORE_HAVE_GETC_UNLOCKED 1 +#endif + +/* Define to 1 if you have the `getdtablesize' function. */ +#ifndef MAGICKCORE_HAVE_GETDTABLESIZE +#define MAGICKCORE_HAVE_GETDTABLESIZE 1 +#endif + +/* Define to 1 if you have the `getexecname' function. */ +/* #undef HAVE_GETEXECNAME */ + +/* Define to 1 if you have the `getpagesize' function. */ +#ifndef MAGICKCORE_HAVE_GETPAGESIZE +#define MAGICKCORE_HAVE_GETPAGESIZE 1 +#endif + +/* Define to 1 if you have the `getpid' function. */ +#ifndef MAGICKCORE_HAVE_GETPID +#define MAGICKCORE_HAVE_GETPID 1 +#endif + +/* Define to 1 if you have the `getrlimit' function. */ +#ifndef MAGICKCORE_HAVE_GETRLIMIT +#define MAGICKCORE_HAVE_GETRLIMIT 1 +#endif + +/* Define to 1 if you have the `getrusage' function. */ +#ifndef MAGICKCORE_HAVE_GETRUSAGE +#define MAGICKCORE_HAVE_GETRUSAGE 1 +#endif + +/* Define to 1 if you have the `gettimeofday' function. */ +#ifndef MAGICKCORE_HAVE_GETTIMEOFDAY +#define MAGICKCORE_HAVE_GETTIMEOFDAY 1 +#endif + +/* Define to 1 if you have the `gmtime_r' function. */ +#ifndef MAGICKCORE_HAVE_GMTIME_R +#define MAGICKCORE_HAVE_GMTIME_R 1 +#endif + +/* Compile with hugepage support */ +/* #undef HAVE_HUGEPAGES */ + +/* Define to 1 if the system has the type `intmax_t'. */ +#ifndef MAGICKCORE_HAVE_INTMAX_T +#define MAGICKCORE_HAVE_INTMAX_T 1 +#endif + +/* Define to 1 if the system has the type `intptr_t'. */ +#ifndef MAGICKCORE_HAVE_INTPTR_T +#define MAGICKCORE_HAVE_INTPTR_T 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_INTTYPES_H +#define MAGICKCORE_HAVE_INTTYPES_H 1 +#endif + +/* Define to 1 if you have the `isnan' function. */ +#ifndef MAGICKCORE_HAVE_ISNAN +#define MAGICKCORE_HAVE_ISNAN 1 +#endif + +/* Define to 1 if you have the `j0' function. */ +#ifndef MAGICKCORE_HAVE_J0 +#define MAGICKCORE_HAVE_J0 1 +#endif + +/* Define to 1 if you have the `j1' function. */ +#ifndef MAGICKCORE_HAVE_J1 +#define MAGICKCORE_HAVE_J1 1 +#endif + +/* Define if you have the header file. */ +/* #undef HAVE_LCMS2_H */ + +/* Define if you have the header file. */ +/* #undef HAVE_LCMS2_LCMS2_H */ + +/* Define to 1 if you have the `gcov' library (-lgcov). */ +/* #undef HAVE_LIBGCOV */ + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_LIMITS_H +#define MAGICKCORE_HAVE_LIMITS_H 1 +#endif + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_LINUX_UNISTD_H */ + +/* Define to 1 if you have the `lltostr' function. */ +/* #undef HAVE_LLTOSTR */ + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_LOCALE_H +#define MAGICKCORE_HAVE_LOCALE_H 1 +#endif + +/* Define to 1 if the system has the type `locale_t'. */ +#ifndef MAGICKCORE_HAVE_LOCALE_T +#define MAGICKCORE_HAVE_LOCALE_T 1 +#endif + +/* Define to 1 if you have the `localtime_r' function. */ +#ifndef MAGICKCORE_HAVE_LOCALTIME_R +#define MAGICKCORE_HAVE_LOCALTIME_R 1 +#endif + +/* Define to 1 if the system has the type `long double'. */ +#ifndef MAGICKCORE_HAVE_LONG_DOUBLE +#define MAGICKCORE_HAVE_LONG_DOUBLE 1 +#endif + +/* Define to 1 if the type `long double' works and has more range or precision + than `double'. */ +#ifndef MAGICKCORE_HAVE_LONG_DOUBLE_WIDER +#define MAGICKCORE_HAVE_LONG_DOUBLE_WIDER 1 +#endif + +/* Define to 1 if the system has the type 'long long int'. */ +#ifndef MAGICKCORE_HAVE_LONG_LONG_INT +#define MAGICKCORE_HAVE_LONG_LONG_INT 1 +#endif + +/* Define to 1 if you have the `lstat' function. */ +#ifndef MAGICKCORE_HAVE_LSTAT +#define MAGICKCORE_HAVE_LSTAT 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_MACHINE_PARAM_H +#define MAGICKCORE_HAVE_MACHINE_PARAM_H 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_MACH_O_DYLD_H +#define MAGICKCORE_HAVE_MACH_O_DYLD_H 1 +#endif + +/* Define to 1 if declares mbstate_t. */ +#ifndef MAGICKCORE_HAVE_MBSTATE_T +#define MAGICKCORE_HAVE_MBSTATE_T 1 +#endif + +/* Define to 1 if you have the `memmove' function. */ +#ifndef MAGICKCORE_HAVE_MEMMOVE +#define MAGICKCORE_HAVE_MEMMOVE 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_MEMORY_H +#define MAGICKCORE_HAVE_MEMORY_H 1 +#endif + +/* Define to 1 if you have the `memset' function. */ +#ifndef MAGICKCORE_HAVE_MEMSET +#define MAGICKCORE_HAVE_MEMSET 1 +#endif + +/* Define to 1 if you have the `mkstemp' function. */ +#ifndef MAGICKCORE_HAVE_MKSTEMP +#define MAGICKCORE_HAVE_MKSTEMP 1 +#endif + +/* Define to 1 if you have a working `mmap' system call. */ +#ifndef MAGICKCORE_HAVE_MMAP +#define MAGICKCORE_HAVE_MMAP 1 +#endif + +/* Define to 1 if you have the `munmap' function. */ +#ifndef MAGICKCORE_HAVE_MUNMAP +#define MAGICKCORE_HAVE_MUNMAP 1 +#endif + +/* define if the compiler implements namespaces */ +#ifndef MAGICKCORE_HAVE_NAMESPACES +#define MAGICKCORE_HAVE_NAMESPACES /**/ +#endif + +/* Define if g++ supports namespace std. */ +#ifndef MAGICKCORE_HAVE_NAMESPACE_STD +#define MAGICKCORE_HAVE_NAMESPACE_STD /**/ +#endif + +/* Define to 1 if you have the `nanosleep' function. */ +#ifndef MAGICKCORE_HAVE_NANOSLEEP +#define MAGICKCORE_HAVE_NANOSLEEP 1 +#endif + +/* Define to 1 if you have the header file, and it defines `DIR'. */ +/* #undef HAVE_NDIR_H */ + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_NETINET_IN_H +#define MAGICKCORE_HAVE_NETINET_IN_H 1 +#endif + +/* Define to 1 if you have the `newlocale' function. */ +#ifndef MAGICKCORE_HAVE_NEWLOCALE +#define MAGICKCORE_HAVE_NEWLOCALE 1 +#endif + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_OPENCL_CL_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_OS_H */ + +/* Define to 1 if you have the `pclose' function. */ +#ifndef MAGICKCORE_HAVE_PCLOSE +#define MAGICKCORE_HAVE_PCLOSE 1 +#endif + +/* Define to 1 if you have the `poll' function. */ +#ifndef MAGICKCORE_HAVE_POLL +#define MAGICKCORE_HAVE_POLL 1 +#endif + +/* Define to 1 if you have the `popen' function. */ +#ifndef MAGICKCORE_HAVE_POPEN +#define MAGICKCORE_HAVE_POPEN 1 +#endif + +/* Define to 1 if you have the `posix_fadvise' function. */ +/* #undef HAVE_POSIX_FADVISE */ + +/* Define to 1 if you have the `posix_fallocate' function. */ +/* #undef HAVE_POSIX_FALLOCATE */ + +/* Define to 1 if you have the `posix_madvise' function. */ +#ifndef MAGICKCORE_HAVE_POSIX_MADVISE +#define MAGICKCORE_HAVE_POSIX_MADVISE 1 +#endif + +/* Define to 1 if you have the `posix_memalign' function. */ +#ifndef MAGICKCORE_HAVE_POSIX_MEMALIGN +#define MAGICKCORE_HAVE_POSIX_MEMALIGN 1 +#endif + +/* Define to 1 if you have the `posix_spawnp' function. */ +#ifndef MAGICKCORE_HAVE_POSIX_SPAWNP +#define MAGICKCORE_HAVE_POSIX_SPAWNP 1 +#endif + +/* Define to 1 if you have the `pow' function. */ +#ifndef MAGICKCORE_HAVE_POW +#define MAGICKCORE_HAVE_POW 1 +#endif + +/* Define to 1 if you have the `pread' function. */ +#ifndef MAGICKCORE_HAVE_PREAD +#define MAGICKCORE_HAVE_PREAD 1 +#endif + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_PROCESS_H */ + +/* Define if you have POSIX threads libraries and header files. */ +#ifndef MAGICKCORE_HAVE_PTHREAD +#define MAGICKCORE_HAVE_PTHREAD 1 +#endif + +/* Have PTHREAD_PRIO_INHERIT. */ +#ifndef MAGICKCORE_HAVE_PTHREAD_PRIO_INHERIT +#define MAGICKCORE_HAVE_PTHREAD_PRIO_INHERIT 1 +#endif + +/* Define to 1 if you have the `pwrite' function. */ +#ifndef MAGICKCORE_HAVE_PWRITE +#define MAGICKCORE_HAVE_PWRITE 1 +#endif + +/* Define to 1 if you have the `qsort_r' function. */ +#ifndef MAGICKCORE_HAVE_QSORT_R +#define MAGICKCORE_HAVE_QSORT_R 1 +#endif + +/* Define to 1 if you have the `raise' function. */ +#ifndef MAGICKCORE_HAVE_RAISE +#define MAGICKCORE_HAVE_RAISE 1 +#endif + +/* Define to 1 if you have the `rand_r' function. */ +#ifndef MAGICKCORE_HAVE_RAND_R +#define MAGICKCORE_HAVE_RAND_R 1 +#endif + +/* Define to 1 if you have the `readlink' function. */ +#ifndef MAGICKCORE_HAVE_READLINK +#define MAGICKCORE_HAVE_READLINK 1 +#endif + +/* Define to 1 if you have the `realpath' function. */ +#ifndef MAGICKCORE_HAVE_REALPATH +#define MAGICKCORE_HAVE_REALPATH 1 +#endif + +/* Define to 1 if you have the `seekdir' function. */ +#ifndef MAGICKCORE_HAVE_SEEKDIR +#define MAGICKCORE_HAVE_SEEKDIR 1 +#endif + +/* Define to 1 if you have the `select' function. */ +#ifndef MAGICKCORE_HAVE_SELECT +#define MAGICKCORE_HAVE_SELECT 1 +#endif + +/* Define to 1 if you have the `sendfile' function. */ +#ifndef MAGICKCORE_HAVE_SENDFILE +#define MAGICKCORE_HAVE_SENDFILE 1 +#endif + +/* Define to 1 if you have the `setlocale' function. */ +#ifndef MAGICKCORE_HAVE_SETLOCALE +#define MAGICKCORE_HAVE_SETLOCALE 1 +#endif + +/* Define to 1 if you have the `setvbuf' function. */ +#ifndef MAGICKCORE_HAVE_SETVBUF +#define MAGICKCORE_HAVE_SETVBUF 1 +#endif + +/* X11 server supports shape extension */ +/* #undef HAVE_SHAPE */ + +/* X11 server supports shared memory extension */ +/* #undef HAVE_SHARED_MEMORY */ + +/* Define to 1 if you have the `sigaction' function. */ +#ifndef MAGICKCORE_HAVE_SIGACTION +#define MAGICKCORE_HAVE_SIGACTION 1 +#endif + +/* Define to 1 if you have the `sigemptyset' function. */ +#ifndef MAGICKCORE_HAVE_SIGEMPTYSET +#define MAGICKCORE_HAVE_SIGEMPTYSET 1 +#endif + +/* Define to 1 if you have the `socket' function. */ +#ifndef MAGICKCORE_HAVE_SOCKET +#define MAGICKCORE_HAVE_SOCKET 1 +#endif + +/* Define to 1 if you have the `spawnvp' function. */ +/* #undef HAVE_SPAWNVP */ + +/* Define to 1 if you have the `sqrt' function. */ +#ifndef MAGICKCORE_HAVE_SQRT +#define MAGICKCORE_HAVE_SQRT 1 +#endif + +/* Define to 1 if you have the `stat' function. */ +#ifndef MAGICKCORE_HAVE_STAT +#define MAGICKCORE_HAVE_STAT 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_STDARG_H +#define MAGICKCORE_HAVE_STDARG_H 1 +#endif + +/* Define to 1 if stdbool.h conforms to C99. */ +#ifndef MAGICKCORE_HAVE_STDBOOL_H +#define MAGICKCORE_HAVE_STDBOOL_H 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_STDINT_H +#define MAGICKCORE_HAVE_STDINT_H 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_STDLIB_H +#define MAGICKCORE_HAVE_STDLIB_H 1 +#endif + +/* define if the compiler supports ISO C++ standard library */ +#ifndef MAGICKCORE_HAVE_STD_LIBS +#define MAGICKCORE_HAVE_STD_LIBS /**/ +#endif + +/* Define to 1 if you have the `strcasecmp' function. */ +#ifndef MAGICKCORE_HAVE_STRCASECMP +#define MAGICKCORE_HAVE_STRCASECMP 1 +#endif + +/* Define to 1 if you have the `strchr' function. */ +#ifndef MAGICKCORE_HAVE_STRCHR +#define MAGICKCORE_HAVE_STRCHR 1 +#endif + +/* Define to 1 if you have the `strcspn' function. */ +#ifndef MAGICKCORE_HAVE_STRCSPN +#define MAGICKCORE_HAVE_STRCSPN 1 +#endif + +/* Define to 1 if you have the `strdup' function. */ +#ifndef MAGICKCORE_HAVE_STRDUP +#define MAGICKCORE_HAVE_STRDUP 1 +#endif + +/* Define to 1 if you have the `strerror' function. */ +#ifndef MAGICKCORE_HAVE_STRERROR +#define MAGICKCORE_HAVE_STRERROR 1 +#endif + +/* Define to 1 if you have the `strerror_r' function. */ +#ifndef MAGICKCORE_HAVE_STRERROR_R +#define MAGICKCORE_HAVE_STRERROR_R 1 +#endif + +/* Define to 1 if cpp supports the ANSI # stringizing operator. */ +#ifndef MAGICKCORE_HAVE_STRINGIZE +#define MAGICKCORE_HAVE_STRINGIZE 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_STRINGS_H +#define MAGICKCORE_HAVE_STRINGS_H 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_STRING_H +#define MAGICKCORE_HAVE_STRING_H 1 +#endif + +/* Define to 1 if you have the `strlcat' function. */ +#ifndef MAGICKCORE_HAVE_STRLCAT +#define MAGICKCORE_HAVE_STRLCAT 1 +#endif + +/* Define to 1 if you have the `strlcpy' function. */ +#ifndef MAGICKCORE_HAVE_STRLCPY +#define MAGICKCORE_HAVE_STRLCPY 1 +#endif + +/* Define to 1 if you have the `strncasecmp' function. */ +#ifndef MAGICKCORE_HAVE_STRNCASECMP +#define MAGICKCORE_HAVE_STRNCASECMP 1 +#endif + +/* Define to 1 if you have the `strpbrk' function. */ +#ifndef MAGICKCORE_HAVE_STRPBRK +#define MAGICKCORE_HAVE_STRPBRK 1 +#endif + +/* Define to 1 if you have the `strrchr' function. */ +#ifndef MAGICKCORE_HAVE_STRRCHR +#define MAGICKCORE_HAVE_STRRCHR 1 +#endif + +/* Define to 1 if you have the `strspn' function. */ +#ifndef MAGICKCORE_HAVE_STRSPN +#define MAGICKCORE_HAVE_STRSPN 1 +#endif + +/* Define to 1 if you have the `strstr' function. */ +#ifndef MAGICKCORE_HAVE_STRSTR +#define MAGICKCORE_HAVE_STRSTR 1 +#endif + +/* Define to 1 if you have the `strtod' function. */ +#ifndef MAGICKCORE_HAVE_STRTOD +#define MAGICKCORE_HAVE_STRTOD 1 +#endif + +/* Define to 1 if you have the `strtod_l' function. */ +#ifndef MAGICKCORE_HAVE_STRTOD_L +#define MAGICKCORE_HAVE_STRTOD_L 1 +#endif + +/* Define to 1 if you have the `strtol' function. */ +#ifndef MAGICKCORE_HAVE_STRTOL +#define MAGICKCORE_HAVE_STRTOL 1 +#endif + +/* Define to 1 if you have the `strtoul' function. */ +#ifndef MAGICKCORE_HAVE_STRTOUL +#define MAGICKCORE_HAVE_STRTOUL 1 +#endif + +/* Define to 1 if `tm_zone' is a member of `struct tm'. */ +#ifndef MAGICKCORE_HAVE_STRUCT_TM_TM_ZONE +#define MAGICKCORE_HAVE_STRUCT_TM_TM_ZONE 1 +#endif + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SUN_PREFETCH_H */ + +/* Define to 1 if you have the `symlink' function. */ +#ifndef MAGICKCORE_HAVE_SYMLINK +#define MAGICKCORE_HAVE_SYMLINK 1 +#endif + +/* Define to 1 if you have the `sysconf' function. */ +#ifndef MAGICKCORE_HAVE_SYSCONF +#define MAGICKCORE_HAVE_SYSCONF 1 +#endif + +/* Define to 1 if you have the header file, and it defines `DIR'. + */ +/* #undef HAVE_SYS_DIR_H */ + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_SYS_IPC_H +#define MAGICKCORE_HAVE_SYS_IPC_H 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_SYS_MMAN_H +#define MAGICKCORE_HAVE_SYS_MMAN_H 1 +#endif + +/* Define to 1 if you have the header file, and it defines `DIR'. + */ +/* #undef HAVE_SYS_NDIR_H */ + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_SYS_PARAM_H +#define MAGICKCORE_HAVE_SYS_PARAM_H 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_SYS_RESOURCE_H +#define MAGICKCORE_HAVE_SYS_RESOURCE_H 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_SYS_SELECT_H +#define MAGICKCORE_HAVE_SYS_SELECT_H 1 +#endif + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_SENDFILE_H */ + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_SYS_SOCKET_H +#define MAGICKCORE_HAVE_SYS_SOCKET_H 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_SYS_STAT_H +#define MAGICKCORE_HAVE_SYS_STAT_H 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_SYS_SYSLIMITS_H +#define MAGICKCORE_HAVE_SYS_SYSLIMITS_H 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_SYS_TIMEB_H +#define MAGICKCORE_HAVE_SYS_TIMEB_H 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_SYS_TIMES_H +#define MAGICKCORE_HAVE_SYS_TIMES_H 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_SYS_TIME_H +#define MAGICKCORE_HAVE_SYS_TIME_H 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_SYS_TYPES_H +#define MAGICKCORE_HAVE_SYS_TYPES_H 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_SYS_WAIT_H +#define MAGICKCORE_HAVE_SYS_WAIT_H 1 +#endif + +/* Define to 1 if you have the `telldir' function. */ +#ifndef MAGICKCORE_HAVE_TELLDIR +#define MAGICKCORE_HAVE_TELLDIR 1 +#endif + +/* Define to 1 if you have the `tempnam' function. */ +#ifndef MAGICKCORE_HAVE_TEMPNAM +#define MAGICKCORE_HAVE_TEMPNAM 1 +#endif + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_TIFFCONF_H */ + +/* Define to 1 if you have the `TIFFIsBigEndian' function. */ +/* #undef HAVE_TIFFISBIGENDIAN */ + +/* Define to 1 if you have the `TIFFIsCODECConfigured' function. */ +/* #undef HAVE_TIFFISCODECCONFIGURED */ + +/* Define to 1 if you have the `TIFFMergeFieldInfo' function. */ +/* #undef HAVE_TIFFMERGEFIELDINFO */ + +/* Define to 1 if you have the `TIFFReadEXIFDirectory' function. */ +/* #undef HAVE_TIFFREADEXIFDIRECTORY */ + +/* Define to 1 if you have the `TIFFSetErrorHandlerExt' function. */ +/* #undef HAVE_TIFFSETERRORHANDLEREXT */ + +/* Define to 1 if you have the `TIFFSetTagExtender' function. */ +/* #undef HAVE_TIFFSETTAGEXTENDER */ + +/* Define to 1 if you have the `TIFFSetWarningHandlerExt' function. */ +/* #undef HAVE_TIFFSETWARNINGHANDLEREXT */ + +/* Define to 1 if you have the `TIFFSwabArrayOfTriples' function. */ +/* #undef HAVE_TIFFSWABARRAYOFTRIPLES */ + +/* Define to 1 if you have the `times' function. */ +#ifndef MAGICKCORE_HAVE_TIMES +#define MAGICKCORE_HAVE_TIMES 1 +#endif + +/* Define to 1 if your `struct tm' has `tm_zone'. Deprecated, use + `HAVE_STRUCT_TM_TM_ZONE' instead. */ +#ifndef MAGICKCORE_HAVE_TM_ZONE +#define MAGICKCORE_HAVE_TM_ZONE 1 +#endif + +/* Define to 1 if you don't have `tm_zone' but do have the external array + `tzname'. */ +/* #undef HAVE_TZNAME */ + +/* Define to 1 if the system has the type `uintmax_t'. */ +#ifndef MAGICKCORE_HAVE_UINTMAX_T +#define MAGICKCORE_HAVE_UINTMAX_T 1 +#endif + +/* Define to 1 if the system has the type `uintptr_t'. */ +#ifndef MAGICKCORE_HAVE_UINTPTR_T +#define MAGICKCORE_HAVE_UINTPTR_T 1 +#endif + +/* Define to 1 if you have the `ulltostr' function. */ +/* #undef HAVE_ULLTOSTR */ + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_UNISTD_H +#define MAGICKCORE_HAVE_UNISTD_H 1 +#endif + +/* Define to 1 if the system has the type 'unsigned long long int'. */ +#ifndef MAGICKCORE_HAVE_UNSIGNED_LONG_LONG_INT +#define MAGICKCORE_HAVE_UNSIGNED_LONG_LONG_INT 1 +#endif + +/* Define to 1 if you have the `uselocale' function. */ +#ifndef MAGICKCORE_HAVE_USELOCALE +#define MAGICKCORE_HAVE_USELOCALE 1 +#endif + +/* Define to 1 if you have the `usleep' function. */ +#ifndef MAGICKCORE_HAVE_USLEEP +#define MAGICKCORE_HAVE_USLEEP 1 +#endif + +/* Define to 1 if you have the `utime' function. */ +#ifndef MAGICKCORE_HAVE_UTIME +#define MAGICKCORE_HAVE_UTIME 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_UTIME_H +#define MAGICKCORE_HAVE_UTIME_H 1 +#endif + +/* Define to 1 if you have the `vfork' function. */ +#ifndef MAGICKCORE_HAVE_VFORK +#define MAGICKCORE_HAVE_VFORK 1 +#endif + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_VFORK_H */ + +/* Define to 1 if you have the `vfprintf' function. */ +#ifndef MAGICKCORE_HAVE_VFPRINTF +#define MAGICKCORE_HAVE_VFPRINTF 1 +#endif + +/* Define to 1 if you have the `vfprintf_l' function. */ +#ifndef MAGICKCORE_HAVE_VFPRINTF_L +#define MAGICKCORE_HAVE_VFPRINTF_L 1 +#endif + +/* Define to 1 if you have the `vprintf' function. */ +#ifndef MAGICKCORE_HAVE_VPRINTF +#define MAGICKCORE_HAVE_VPRINTF 1 +#endif + +/* Define to 1 if you have the `vsnprintf' function. */ +#ifndef MAGICKCORE_HAVE_VSNPRINTF +#define MAGICKCORE_HAVE_VSNPRINTF 1 +#endif + +/* Define to 1 if you have the `vsnprintf_l' function. */ +#ifndef MAGICKCORE_HAVE_VSNPRINTF_L +#define MAGICKCORE_HAVE_VSNPRINTF_L 1 +#endif + +/* Define to 1 if you have the `vsprintf' function. */ +#ifndef MAGICKCORE_HAVE_VSPRINTF +#define MAGICKCORE_HAVE_VSPRINTF 1 +#endif + +/* Define to 1 if you have the `waitpid' function. */ +#ifndef MAGICKCORE_HAVE_WAITPID +#define MAGICKCORE_HAVE_WAITPID 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_WCHAR_H +#define MAGICKCORE_HAVE_WCHAR_H 1 +#endif + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_WINDOWS_H */ + +/* Define to 1 if `fork' works. */ +#ifndef MAGICKCORE_HAVE_WORKING_FORK +#define MAGICKCORE_HAVE_WORKING_FORK 1 +#endif + +/* Define to 1 if `vfork' works. */ +#ifndef MAGICKCORE_HAVE_WORKING_VFORK +#define MAGICKCORE_HAVE_WORKING_VFORK 1 +#endif + +/* Define to 1 if you have the header file. */ +#ifndef MAGICKCORE_HAVE_XLOCALE_H +#define MAGICKCORE_HAVE_XLOCALE_H 1 +#endif + +/* Define to 1 if you have the `_aligned_malloc' function. */ +/* #undef HAVE__ALIGNED_MALLOC */ + +/* Define to 1 if the system has the type `_Bool'. */ +#ifndef MAGICKCORE_HAVE__BOOL +#define MAGICKCORE_HAVE__BOOL 1 +#endif + +/* Define to 1 if you have the `_exit' function. */ +#ifndef MAGICKCORE_HAVE__EXIT +#define MAGICKCORE_HAVE__EXIT 1 +#endif + +/* Define to 1 if you have the `_NSGetExecutablePath' function. */ +#ifndef MAGICKCORE_HAVE__NSGETEXECUTABLEPATH +#define MAGICKCORE_HAVE__NSGETEXECUTABLEPATH 1 +#endif + +/* Define to 1 if you have the `_pclose' function. */ +/* #undef HAVE__PCLOSE */ + +/* Define to 1 if you have the `_popen' function. */ +/* #undef HAVE__POPEN */ + +/* Define to 1 if you have the `_wfopen' function. */ +/* #undef HAVE__WFOPEN */ + +/* Define to 1 if you have the `_wstat' function. */ +/* #undef HAVE__WSTAT */ + +/* define if your compiler has __attribute__ */ +#ifndef MAGICKCORE_HAVE___ATTRIBUTE__ +#define MAGICKCORE_HAVE___ATTRIBUTE__ 1 +#endif + +/* Whether hdri is enabled or not */ +#ifndef MAGICKCORE_HDRI_ENABLE_OBSOLETE_IN_H +#define MAGICKCORE_HDRI_ENABLE_OBSOLETE_IN_H 1 +#endif + +/* Define if you have jemalloc memory allocation library */ +/* #undef HasJEMALLOC */ + +/* Define if you have umem memory allocation library */ +/* #undef HasUMEM */ + +/* Directory where ImageMagick architecture headers live. */ +#ifndef MAGICKCORE_INCLUDEARCH_PATH +#define MAGICKCORE_INCLUDEARCH_PATH "/Users/johannespichler/Downloads/newTest/build/include/ImageMagick-7/" +#endif + +/* Directory where ImageMagick headers live. */ +#ifndef MAGICKCORE_INCLUDE_PATH +#define MAGICKCORE_INCLUDE_PATH "/Users/johannespichler/Downloads/newTest/build/include/ImageMagick-7/" +#endif + +/* ImageMagick is formally installed under prefix */ +#ifndef MAGICKCORE_INSTALLED_SUPPORT +#define MAGICKCORE_INSTALLED_SUPPORT 1 +#endif + +/* Define if you have JBIG library */ +/* #undef JBIG_DELEGATE */ + +/* Define if you have JPEG library */ +#ifndef MAGICKCORE_JPEG_DELEGATE +#define MAGICKCORE_JPEG_DELEGATE 1 +#endif + +/* Define if you have LCMS library */ +/* #undef LCMS_DELEGATE */ + +/* Define if you have OPENJP2 library */ +/* #undef LIBOPENJP2_DELEGATE */ + +/* Directory where architecture-dependent files live. */ +#ifndef MAGICKCORE_LIBRARY_PATH +#define MAGICKCORE_LIBRARY_PATH "/Users/johannespichler/Downloads/newTest/build/lib/ImageMagick-7.0.5/" +#endif + +/* Subdirectory of lib where ImageMagick architecture dependent files are + installed. */ +#ifndef MAGICKCORE_LIBRARY_RELATIVE_PATH +#define MAGICKCORE_LIBRARY_RELATIVE_PATH "ImageMagick-7.0.5" +#endif + +/* Binaries in libraries path base name (will be during install linked to bin) + */ +#ifndef MAGICKCORE_LIB_BIN_BASEDIRNAME +#define MAGICKCORE_LIB_BIN_BASEDIRNAME "bin" +#endif + +/* Define if you have LQR library */ +/* #undef LQR_DELEGATE */ + +/* Define if using libltdl to support dynamically loadable modules */ +/* #undef LTDL_DELEGATE */ + +/* Define to the sub-directory where libtool stores uninstalled libraries. */ +#ifndef MAGICKCORE_LT_OBJDIR +#define MAGICKCORE_LT_OBJDIR ".libs/" +#endif + +/* Define if you have LZMA library */ +#ifndef MAGICKCORE_LZMA_DELEGATE +#define MAGICKCORE_LZMA_DELEGATE 1 +#endif + +/* Define to prepend to default font search path. */ +/* #undef MAGICK_FONT_PATH */ + +/* Target Host CPU */ +#ifndef MAGICKCORE_MAGICK_TARGET_CPU +#define MAGICKCORE_MAGICK_TARGET_CPU x86_64 +#endif + +/* Target Host OS */ +#ifndef MAGICKCORE_MAGICK_TARGET_OS +#define MAGICKCORE_MAGICK_TARGET_OS darwin16.5.0 +#endif + +/* Target Host Vendor */ +#ifndef MAGICKCORE_MAGICK_TARGET_VENDOR +#define MAGICKCORE_MAGICK_TARGET_VENDOR apple +#endif + +/* Module directory name without ABI part. */ +#ifndef MAGICKCORE_MODULES_BASEDIRNAME +#define MAGICKCORE_MODULES_BASEDIRNAME "modules" +#endif + +/* Module directory dirname */ +/* #undef MODULES_DIRNAME */ + +/* Magick API method prefix */ +/* #undef NAMESPACE_PREFIX */ + +/* Define to 1 if assertions should be disabled. */ +/* #undef NDEBUG */ + +/* Define if you have OPENEXR library */ +/* #undef OPENEXR_DELEGATE */ + +/* Name of package */ +#ifndef MAGICKCORE_PACKAGE +#define MAGICKCORE_PACKAGE "ImageMagick" +#endif + +/* Define to the address where bug reports for this package should be sent. */ +#ifndef MAGICKCORE_PACKAGE_BUGREPORT +#define MAGICKCORE_PACKAGE_BUGREPORT "https://github.com/ImageMagick/ImageMagick/issues" +#endif + +/* Define to the full name of this package. */ +#ifndef MAGICKCORE_PACKAGE_NAME +#define MAGICKCORE_PACKAGE_NAME "ImageMagick" +#endif + +/* Define to the full name and version of this package. */ +#ifndef MAGICKCORE_PACKAGE_STRING +#define MAGICKCORE_PACKAGE_STRING "ImageMagick 7.0.5-5" +#endif + +/* Define to the one symbol short name of this package. */ +#ifndef MAGICKCORE_PACKAGE_TARNAME +#define MAGICKCORE_PACKAGE_TARNAME "ImageMagick" +#endif + +/* Define to the home page for this package. */ +#ifndef MAGICKCORE_PACKAGE_URL +#define MAGICKCORE_PACKAGE_URL "https://www.imagemagick.org" +#endif + +/* Define to the version of this package. */ +#ifndef MAGICKCORE_PACKAGE_VERSION +#define MAGICKCORE_PACKAGE_VERSION "7.0.5-5" +#endif + +/* Define if you have PANGOCAIRO library */ +/* #undef PANGOCAIRO_DELEGATE */ + +/* Define if you have PANGO library */ +/* #undef PANGO_DELEGATE */ + +/* enable pipes (|) in filenames */ +/* #undef PIPES_SUPPORT */ + +/* Define if you have PNG library */ +#ifndef MAGICKCORE_PNG_DELEGATE +#define MAGICKCORE_PNG_DELEGATE 1 +#endif + +/* Define to necessary symbol if this constant uses a non-standard name on + your system. */ +/* #undef PTHREAD_CREATE_JOINABLE */ + +/* Pixel cache threshold in MB (defaults to available memory) */ +/* #undef PixelCacheThreshold */ + +/* Number of bits in a pixel Quantum (8/16/32/64) */ +#ifndef MAGICKCORE_QUANTUM_DEPTH_OBSOLETE_IN_H +#define MAGICKCORE_QUANTUM_DEPTH_OBSOLETE_IN_H 16 +#endif + +/* Define if you have RAQM library */ +/* #undef RAQM_DELEGATE */ + +/* Define as the return type of signal handlers (`int' or `void'). */ +#ifndef MAGICKCORE_RETSIGTYPE +#define MAGICKCORE_RETSIGTYPE void +#endif + +/* Define if you have RSVG library */ +/* #undef RSVG_DELEGATE */ + +/* Define to the type of arg 1 for `select'. */ +#ifndef MAGICKCORE_SELECT_TYPE_ARG1 +#define MAGICKCORE_SELECT_TYPE_ARG1 int +#endif + +/* Define to the type of args 2, 3 and 4 for `select'. */ +#ifndef MAGICKCORE_SELECT_TYPE_ARG234 +#define MAGICKCORE_SELECT_TYPE_ARG234 (fd_set *) +#endif + +/* Define to the type of arg 5 for `select'. */ +#ifndef MAGICKCORE_SELECT_TYPE_ARG5 +#define MAGICKCORE_SELECT_TYPE_ARG5 (struct timeval *) +#endif + +/* Sharearch directory name without ABI part. */ +#ifndef MAGICKCORE_SHAREARCH_BASEDIRNAME +#define MAGICKCORE_SHAREARCH_BASEDIRNAME "config" +#endif + +/* Sharearch directory dirname */ +/* #undef SHAREARCH_DIRNAME */ + +/* Directory where architecture-independent configuration files live. */ +#ifndef MAGICKCORE_SHARE_PATH +#define MAGICKCORE_SHARE_PATH "/Users/johannespichler/Downloads/newTest/build/share/ImageMagick-7/" +#endif + +/* Subdirectory of lib where architecture-independent configuration files + live. */ +#ifndef MAGICKCORE_SHARE_RELATIVE_PATH +#define MAGICKCORE_SHARE_RELATIVE_PATH "ImageMagick-7" +#endif + +/* The size of `double', as computed by sizeof. */ +#ifndef MAGICKCORE_SIZEOF_DOUBLE +#define MAGICKCORE_SIZEOF_DOUBLE 8 +#endif + +/* The size of `double_t', as computed by sizeof. */ +#ifndef MAGICKCORE_SIZEOF_DOUBLE_T +#define MAGICKCORE_SIZEOF_DOUBLE_T 8 +#endif + +/* The size of `float', as computed by sizeof. */ +#ifndef MAGICKCORE_SIZEOF_FLOAT +#define MAGICKCORE_SIZEOF_FLOAT 4 +#endif + +/* The size of `float_t', as computed by sizeof. */ +#ifndef MAGICKCORE_SIZEOF_FLOAT_T +#define MAGICKCORE_SIZEOF_FLOAT_T 4 +#endif + +/* The size of `long double', as computed by sizeof. */ +#ifndef MAGICKCORE_SIZEOF_LONG_DOUBLE +#define MAGICKCORE_SIZEOF_LONG_DOUBLE 16 +#endif + +/* The size of `off_t', as computed by sizeof. */ +#ifndef MAGICKCORE_SIZEOF_OFF_T +#define MAGICKCORE_SIZEOF_OFF_T 8 +#endif + +/* The size of `signed int', as computed by sizeof. */ +#ifndef MAGICKCORE_SIZEOF_SIGNED_INT +#define MAGICKCORE_SIZEOF_SIGNED_INT 4 +#endif + +/* The size of `signed long', as computed by sizeof. */ +#ifndef MAGICKCORE_SIZEOF_SIGNED_LONG +#define MAGICKCORE_SIZEOF_SIGNED_LONG 8 +#endif + +/* The size of `signed long long', as computed by sizeof. */ +#ifndef MAGICKCORE_SIZEOF_SIGNED_LONG_LONG +#define MAGICKCORE_SIZEOF_SIGNED_LONG_LONG 8 +#endif + +/* The size of `signed short', as computed by sizeof. */ +#ifndef MAGICKCORE_SIZEOF_SIGNED_SHORT +#define MAGICKCORE_SIZEOF_SIGNED_SHORT 2 +#endif + +/* The size of `size_t', as computed by sizeof. */ +#ifndef MAGICKCORE_SIZEOF_SIZE_T +#define MAGICKCORE_SIZEOF_SIZE_T 8 +#endif + +/* The size of `ssize_t', as computed by sizeof. */ +#ifndef MAGICKCORE_SIZEOF_SSIZE_T +#define MAGICKCORE_SIZEOF_SSIZE_T 8 +#endif + +/* The size of `unsigned int', as computed by sizeof. */ +#ifndef MAGICKCORE_SIZEOF_UNSIGNED_INT +#define MAGICKCORE_SIZEOF_UNSIGNED_INT 4 +#endif + +/* The size of `unsigned int*', as computed by sizeof. */ +#ifndef MAGICKCORE_SIZEOF_UNSIGNED_INTP +#define MAGICKCORE_SIZEOF_UNSIGNED_INTP 8 +#endif + +/* The size of `unsigned long', as computed by sizeof. */ +#ifndef MAGICKCORE_SIZEOF_UNSIGNED_LONG +#define MAGICKCORE_SIZEOF_UNSIGNED_LONG 8 +#endif + +/* The size of `unsigned long long', as computed by sizeof. */ +#ifndef MAGICKCORE_SIZEOF_UNSIGNED_LONG_LONG +#define MAGICKCORE_SIZEOF_UNSIGNED_LONG_LONG 8 +#endif + +/* The size of `unsigned short', as computed by sizeof. */ +#ifndef MAGICKCORE_SIZEOF_UNSIGNED_SHORT +#define MAGICKCORE_SIZEOF_UNSIGNED_SHORT 2 +#endif + +/* Define to 1 if the `S_IS*' macros in do not work properly. */ +/* #undef STAT_MACROS_BROKEN */ + +/* Define to 1 if you have the ANSI C header files. */ +#ifndef MAGICKCORE_STDC_HEADERS +#define MAGICKCORE_STDC_HEADERS 1 +#endif + +/* Define to 1 if strerror_r returns char *. */ +/* #undef STRERROR_R_CHAR_P */ + +/* Define if you have POSIX threads libraries and header files. */ +#ifndef MAGICKCORE_THREAD_SUPPORT +#define MAGICKCORE_THREAD_SUPPORT 1 +#endif + +/* Define if you have TIFF library */ +/* #undef TIFF_DELEGATE */ + +/* Define to 1 if you can safely include both and . */ +#ifndef MAGICKCORE_TIME_WITH_SYS_TIME +#define MAGICKCORE_TIME_WITH_SYS_TIME 1 +#endif + +/* Define to 1 if your declares `struct tm'. */ +/* #undef TM_IN_SYS_TIME */ + +/* Enable extensions on AIX 3, Interix. */ +#ifndef _ALL_SOURCE +# define _ALL_SOURCE 1 +#endif +/* Enable GNU extensions on systems that have them. */ +#ifndef _GNU_SOURCE +# define _GNU_SOURCE 1 +#endif +/* Enable threading extensions on Solaris. */ +#ifndef _POSIX_PTHREAD_SEMANTICS +# define _POSIX_PTHREAD_SEMANTICS 1 +#endif +/* Enable extensions on HP NonStop. */ +#ifndef _TANDEM_SOURCE +# define _TANDEM_SOURCE 1 +#endif +/* Enable general extensions on Solaris. */ +#ifndef __EXTENSIONS__ +# define __EXTENSIONS__ 1 +#endif + + +/* Version number of package */ +#ifndef MAGICKCORE_VERSION +#define MAGICKCORE_VERSION "7.0.5-5" +#endif + +/* Define if you have WEBP library */ +#ifndef MAGICKCORE_WEBP_DELEGATE +#define MAGICKCORE_WEBP_DELEGATE 1 +#endif + +/* Define to use the Windows GDI32 library */ +/* #undef WINGDI32_DELEGATE */ + +/* Define if using the dmalloc debugging malloc package */ +/* #undef WITH_DMALLOC */ + +/* Define if you have WMF library */ +/* #undef WMF_DELEGATE */ + +/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most + significant byte first (like Motorola and SPARC, unlike Intel). */ +#if defined AC_APPLE_UNIVERSAL_BUILD +# if defined __BIG_ENDIAN__ +# define WORDS_BIGENDIAN 1 +# endif +#else +# ifndef WORDS_BIGENDIAN +/* # undef WORDS_BIGENDIAN */ +# endif +#endif + +/* Location of X11 configure files */ +#ifndef MAGICKCORE_X11_CONFIGURE_PATH +#define MAGICKCORE_X11_CONFIGURE_PATH "" +#endif + +/* Define if you have X11 library */ +/* #undef X11_DELEGATE */ + +/* Define if you have XML library */ +#ifndef MAGICKCORE_XML_DELEGATE +#define MAGICKCORE_XML_DELEGATE 1 +#endif + +/* Define to 1 if the X Window System is missing or not being used. */ +#ifndef MAGICKCORE_X_DISPLAY_MISSING +#define MAGICKCORE_X_DISPLAY_MISSING 1 +#endif + +/* Build self-contained, embeddable, zero-configuration ImageMagick */ +/* #undef ZERO_CONFIGURATION_SUPPORT */ + +/* Define if you have ZLIB library */ +#ifndef MAGICKCORE_ZLIB_DELEGATE +#define MAGICKCORE_ZLIB_DELEGATE 1 +#endif + +/* Enable large inode numbers on Mac OS X 10.5. */ +#ifndef _DARWIN_USE_64_BIT_INODE +# define _DARWIN_USE_64_BIT_INODE 1 +#endif + +/* Number of bits in a file offset, on hosts where this is settable. */ +/* #undef _FILE_OFFSET_BITS */ + +/* enable run-time bounds-checking */ +/* #undef _FORTIFY_SOURCE */ + +/* Define to 1 to make fseeko visible on some hosts (e.g. glibc 2.2). */ +/* #undef _LARGEFILE_SOURCE */ + +/* Define for large files, on AIX-style hosts. */ +/* #undef _LARGE_FILES */ + +/* Define to 1 if on MINIX. */ +/* #undef _MINIX */ + +/* Define this for the OpenCL Accelerator */ +/* #undef _OPENCL */ + +/* Define to 2 if the system does not provide POSIX.1 features except with + this defined. */ +/* #undef _POSIX_1_SOURCE */ + +/* Define to 1 if you need to in order for `stat' and other things to work. */ +/* #undef _POSIX_SOURCE */ + +/* Define for Solaris 2.5.1 so the uint32_t typedef from , + , or is not used. If the typedef were allowed, the + #define below would cause a syntax error. */ +/* #undef _UINT32_T */ + +/* Define for Solaris 2.5.1 so the uint64_t typedef from , + , or is not used. If the typedef were allowed, the + #define below would cause a syntax error. */ +/* #undef _UINT64_T */ + +/* Define for Solaris 2.5.1 so the uint8_t typedef from , + , or is not used. If the typedef were allowed, the + #define below would cause a syntax error. */ +/* #undef _UINT8_T */ + +/* Define to 1 if type `char' is unsigned and you are not using gcc. */ +#ifndef __CHAR_UNSIGNED__ +/* # undef __CHAR_UNSIGNED__ */ +#endif + +/* Define to appropriate substitue if compiler does not have __func__ */ +/* #undef __func__ */ + +/* Define to empty if `const' does not conform to ANSI C. */ +/* #undef const */ + +/* Define to `int' if doesn't define. */ +/* #undef gid_t */ + +/* Define to `__inline__' or `__inline' if that's what the C compiler + calls it, or to nothing if 'inline' is not supported under any name. */ +#ifndef __cplusplus +/* #undef inline */ +#endif + +/* Define to the type of a signed integer type of width exactly 16 bits if + such a type exists and the standard includes do not define it. */ +/* #undef int16_t */ + +/* Define to the type of a signed integer type of width exactly 32 bits if + such a type exists and the standard includes do not define it. */ +/* #undef int32_t */ + +/* Define to the type of a signed integer type of width exactly 64 bits if + such a type exists and the standard includes do not define it. */ +/* #undef int64_t */ + +/* Define to the type of a signed integer type of width exactly 8 bits if such + a type exists and the standard includes do not define it. */ +/* #undef int8_t */ + +/* Define to the widest signed integer type if and do + not define. */ +/* #undef intmax_t */ + +/* Define to the type of a signed integer type wide enough to hold a pointer, + if such a type exists, and if the system does not define it. */ +/* #undef intptr_t */ + +/* Define to a type if does not define. */ +/* #undef mbstate_t */ + +/* Define to `int' if does not define. */ +/* #undef mode_t */ + +/* Define to `long int' if does not define. */ +/* #undef off_t */ + +/* Define to `int' if does not define. */ +/* #undef pid_t */ + +/* Define to the equivalent of the C99 'restrict' keyword, or to + nothing if this is not supported. Do not define if restrict is + supported directly. */ +#ifndef _magickcore_restrict +#define _magickcore_restrict __restrict +#endif +/* Work around a bug in Sun C++: it does not support _Restrict or + __restrict__, even though the corresponding Sun C compiler ends up with + "#define restrict _Restrict" or "#define restrict __restrict__" in the + previous line. Perhaps some future version of Sun C++ will work with + restrict; if so, hopefully it defines __RESTRICT like Sun C does. */ +#if defined __SUNPRO_CC && !defined __RESTRICT +# define _Restrict +# define __restrict__ +#endif + +/* Define to `unsigned int' if does not define. */ +/* #undef size_t */ + +/* Define to `int' if does not define. */ +/* #undef ssize_t */ + +/* Define to `int' if doesn't define. */ +/* #undef uid_t */ + +/* Define to the type of an unsigned integer type of width exactly 16 bits if + such a type exists and the standard includes do not define it. */ +/* #undef uint16_t */ + +/* Define to the type of an unsigned integer type of width exactly 32 bits if + such a type exists and the standard includes do not define it. */ +/* #undef uint32_t */ + +/* Define to the type of an unsigned integer type of width exactly 64 bits if + such a type exists and the standard includes do not define it. */ +/* #undef uint64_t */ + +/* Define to the type of an unsigned integer type of width exactly 8 bits if + such a type exists and the standard includes do not define it. */ +/* #undef uint8_t */ + +/* Define to the widest unsigned integer type if and + do not define. */ +/* #undef uintmax_t */ + +/* Define to the type of an unsigned integer type wide enough to hold a + pointer, if such a type exists, and if the system does not define it. */ +/* #undef uintptr_t */ + +/* Define as `fork' if `vfork' does not work. */ +/* #undef vfork */ + +/* Define to empty if the keyword `volatile' does not work. Warning: valid + code using `volatile' can become incorrect without. Disable with care. */ +/* #undef volatile */ + +/* once: _MAGICKCORE_MAGICK_BASECONFIG_H */ +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/magick-config.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/magick-config.h new file mode 100755 index 0000000..4321527 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/magick-type.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/magick-type.h new file mode 100755 index 0000000..c20d3bf --- /dev/null +++ b/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 +# 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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/magick.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/magick.h new file mode 100755 index 0000000..4d13b3b --- /dev/null +++ b/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 +#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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/matrix.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/matrix.h new file mode 100755 index 0000000..f195708 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/memory_.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/memory_.h new file mode 100755 index 0000000..3893905 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/method-attribute.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/method-attribute.h new file mode 100755 index 0000000..5de0069 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/methods.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/methods.h new file mode 100755 index 0000000..120d4f4 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/methods.h @@ -0,0 +1,1418 @@ +/* + 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 API methods prefix. + + nm -p magick/.libs/libMagickCore.a | grep ' T ' | egrep -vi '(Magick)|(lt_)' | \ + egrep -v '(MagickError)|(MagickFatalError)|(MagickWarning)|(ThrowException)' | \ + awk '{ printf("#define %s PrependMagickMethod(%s)\n", $3, $3); }' | sort +*/ +#ifndef MAGICKCORE_METHOD_H +#define MAGICKCORE_METHOD_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +#if defined(MAGICKCORE_NAMESPACE_PREFIX) + +#if defined(__STDC__) +#define PrescanMagickPrefix(prefix,method) prefix ## method +#else +#define PrescanMagickPrefix(prefix,method) prefix(method) +#endif +#define EvaluateMagickPrefix(prefix,method) PrescanMagickPrefix(prefix,method) +#define PrependMagickMethod(method) \ + EvaluateMagickPrefix(MAGICKCORE_NAMESPACE_PREFIX,method) + +#define AcquireQuantumMemory PrependMagickMethod(AcquireQuantumMemory) +#define AcquireCacheViewIndexes PrependMagickMethod(AcquireCacheViewIndexes) +#define AcquireCacheViewPixels PrependMagickMethod(AcquireCacheViewPixels) +#define AcquireCacheView PrependMagickMethod(AcquireCacheView) +#define AcquireDrawInfo PrependMagickMethod(AcquireDrawInfo) +#define AcquireExceptionInfo PrependMagickMethod(AcquireExceptionInfo) +#define AcquireFxInfo PrependMagickMethod(AcquireFxInfo) +#define AcquireImageColormap PrependMagickMethod(AcquireImageColormap) +#define AcquireImageInfo PrependMagickMethod(AcquireImageInfo) +#define AcquireImagePixels PrependMagickMethod(AcquireImagePixels) +#define AcquireImage PrependMagickMethod(AcquireImage) +#define AcquireIndexes PrependMagickMethod(AcquireIndexes) +#define AcquireKernelBuiltIn PrependMagickMethod(AcquireKernelBuiltIn) +#define AcquireKernelInfo PrependMagickMethod(AcquireKernelInfo) +#define AcquireMagickMatrix PrependMagickMethod(AcquireMagickMatrix) +#define AcquireMagickMemory PrependMagickMethod(AcquireMagickMemory) +#define AcquireMagickResource PrependMagickMethod(AcquireMagickResource) +#define AcquireMemory PrependMagickMethod(AcquireMemory) +#define AcquireNextImage PrependMagickMethod(AcquireNextImage) +#define AcquireOneCacheViewPixel PrependMagickMethod(AcquireOneCacheViewPixel) +#define AcquireOneCacheViewVirtualPixel PrependMagickMethod(AcquireOneCacheViewVirtualPixel) +#define AcquireOneMagickPixel PrependMagickMethod(AcquireOneMagickPixel) +#define AcquireOnePixel PrependMagickMethod(AcquireOnePixel) +#define AcquireOneVirtualPixel PrependMagickMethod(AcquireOneVirtualPixel) +#define AcquirePixelCacheNexus PrependMagickMethod(AcquirePixelCacheNexus) +#define AcquirePixelCache PrependMagickMethod(AcquirePixelCache) +#define AcquirePixels PrependMagickMethod(AcquirePixels) +#define AcquireQuantizeInfo PrependMagickMethod(AcquireQuantizeInfo) +#define AcquireQuantumInfo PrependMagickMethod(AcquireQuantumInfo) +#define AcquireQuantumMemory PrependMagickMethod(AcquireQuantumMemory) +#define AcquireRandomInfo PrependMagickMethod(AcquireRandomInfo) +#define AcquireResampleFilter PrependMagickMethod(AcquireResampleFilter) +#define AcquireResizeFilter PrependMagickMethod(AcquireResizeFilter) +#define AcquireSemaphoreInfo PrependMagickMethod(AcquireSemaphoreInfo) +#define AcquireSignatureInfo PrependMagickMethod(AcquireSignatureInfo) +#define AcquireStreamInfo PrependMagickMethod(AcquireStreamInfo) +#define AcquireStringInfo PrependMagickMethod(AcquireStringInfo) +#define AcquireString PrependMagickMethod(AcquireString) +#define AcquireTimerInfo PrependMagickMethod(AcquireTimerInfo) +#define AcquireTokenInfo PrependMagickMethod(AcquireTokenInfo) +#define AcquireUniqueFilename PrependMagickMethod(AcquireUniqueFilename) +#define AcquireUniqueFileResource PrependMagickMethod(AcquireUniqueFileResource) +#define AcquireUniqueSymbolicLink PrependMagickMethod(AcquireUniqueSymbolicLink) +#define AdaptiveBlurImage PrependMagickMethod(AdaptiveBlurImage) +#define AdaptiveBlurImage PrependMagickMethod(AdaptiveBlurImage) +#define AdaptiveResizeImage PrependMagickMethod(AdaptiveResizeImage) +#define AdaptiveSharpenImage PrependMagickMethod(AdaptiveSharpenImage) +#define AdaptiveSharpenImage PrependMagickMethod(AdaptiveSharpenImage) +#define AdaptiveThresholdImage PrependMagickMethod(AdaptiveThresholdImage) +#define AddChildToXMLTree PrependMagickMethod(AddChildToXMLTree) +#define AddNoiseImage PrependMagickMethod(AddNoiseImage) +#define AddNoiseImage PrependMagickMethod(AddNoiseImage) +#define AddPathToXMLTree PrependMagickMethod(AddPathToXMLTree) +#define AddValueToSplayTree PrependMagickMethod(AddValueToSplayTree) +#define AffineTransformImage PrependMagickMethod(AffineTransformImage) +#define AffinityImage PrependMagickMethod(AffinityImage) +#define AffinityImages PrependMagickMethod(AffinityImages) +#define AllocateImageColormap PrependMagickMethod(AllocateImageColormap) +#define AllocateImage PrependMagickMethod(AllocateImage) +#define AllocateNextImage PrependMagickMethod(AllocateNextImage) +#define AllocateSemaphoreInfo PrependMagickMethod(AllocateSemaphoreInfo) +#define AllocateString PrependMagickMethod(AllocateString) +#define analyzeImage PrependMagickMethod(analyzeImage) +#define AnimateImages PrependMagickMethod(AnimateImages) +#define AnnotateImage PrependMagickMethod(AnnotateImage) +#define AppendImageFormat PrependMagickMethod(AppendImageFormat) +#define AppendImages PrependMagickMethod(AppendImages) +#define AppendImageToList PrependMagickMethod(AppendImageToList) +#define AppendValueToLinkedList PrependMagickMethod(AppendValueToLinkedList) +#define Ascii85Encode PrependMagickMethod(Ascii85Encode) +#define Ascii85Flush PrependMagickMethod(Ascii85Flush) +#define Ascii85Initialize PrependMagickMethod(Ascii85Initialize) +#define AsynchronousResourceComponentTerminus PrependMagickMethod(AsynchronousResourceComponentTerminus) +#define AttachBlob PrependMagickMethod(AttachBlob) +#define AutoGammaImage PrependMagickMethod(AutoGammaImage) +#define AutoGammaImage PrependMagickMethod(AutoGammaImage) +#define AutoLevelImage PrependMagickMethod(AutoLevelImage) +#define AutoLevelImage PrependMagickMethod(AutoLevelImage) +#define AverageImages PrependMagickMethod(AverageImages) +#define Base64Decode PrependMagickMethod(Base64Decode) +#define Base64Encode PrependMagickMethod(Base64Encode) +#define BilevelImage PrependMagickMethod(BilevelImage) +#define BilevelImage PrependMagickMethod(BilevelImage) +#define BlackThresholdImage PrependMagickMethod(BlackThresholdImage) +#define BlackThresholdImage PrependMagickMethod(BlackThresholdImage) +#define BlobToFile PrependMagickMethod(BlobToFile) +#define BlobToImage PrependMagickMethod(BlobToImage) +#define BlueShiftImage PrependMagickMethod(BlueShiftImage) +#define BlurImage PrependMagickMethod(BlurImage) +#define BlurImage PrependMagickMethod(BlurImage) +#define BorderImage PrependMagickMethod(BorderImage) +#define BrightnessContrastImage PrependMagickMethod(BrightnessContrastImage) +#define BrightnessContrastImage PrependMagickMethod(BrightnessContrastImage) +#define CacheComponentGenesis PrependMagickMethod(CacheComponentGenesis) +#define CacheComponentTerminus PrependMagickMethod(CacheComponentTerminus) +#define CanonicalXMLContent PrependMagickMethod(CanonicalXMLContent) +#define CatchException PrependMagickMethod(CatchException) +#define CatchImageException PrependMagickMethod(CatchImageException) +#define ChannelImage PrependMagickMethod(ChannelImage) +#define ChannelThresholdImage PrependMagickMethod(ChannelThresholdImage) +#define CharcoalImage PrependMagickMethod(CharcoalImage) +#define ChopImage PrependMagickMethod(ChopImage) +#define ChopPathComponents PrependMagickMethod(ChopPathComponents) +#define ClampImage PrependMagickMethod(ClampImage) +#define ClampImage PrependMagickMethod(ClampImage) +#define ClearLinkedList PrependMagickMethod(ClearLinkedList) +#define ClearMagickException PrependMagickMethod(ClearMagickException) +#define ClipImagePath PrependMagickMethod(ClipImagePath) +#define ClipImage PrependMagickMethod(ClipImage) +#define ClipPathImage PrependMagickMethod(ClipPathImage) +#define CloneBlobInfo PrependMagickMethod(CloneBlobInfo) +#define CloneCacheView PrependMagickMethod(CloneCacheView) +#define CloneDrawInfo PrependMagickMethod(CloneDrawInfo) +#define CloneImageArtifacts PrependMagickMethod(CloneImageArtifacts) +#define CloneImageAttributes PrependMagickMethod(CloneImageAttributes) +#define CloneImageInfo PrependMagickMethod(CloneImageInfo) +#define CloneImageList PrependMagickMethod(CloneImageList) +#define CloneImageOptions PrependMagickMethod(CloneImageOptions) +#define CloneImage PrependMagickMethod(CloneImage) +#define CloneImageProfiles PrependMagickMethod(CloneImageProfiles) +#define CloneImageProperties PrependMagickMethod(CloneImageProperties) +#define CloneImages PrependMagickMethod(CloneImages) +#define CloneMemory PrependMagickMethod(CloneMemory) +#define CloneMontageInfo PrependMagickMethod(CloneMontageInfo) +#define ClonePixelCacheMethods PrependMagickMethod(ClonePixelCacheMethods) +#define ClonePixelCache PrependMagickMethod(ClonePixelCache) +#define CloneQuantizeInfo PrependMagickMethod(CloneQuantizeInfo) +#define CloneSplayTree PrependMagickMethod(CloneSplayTree) +#define CloneStringInfo PrependMagickMethod(CloneStringInfo) +#define CloneString PrependMagickMethod(CloneString) +#define CloseBlob PrependMagickMethod(CloseBlob) +#define CloseCacheView PrependMagickMethod(CloseCacheView) +#define CloseMagickLog PrependMagickMethod(CloseMagickLog) +#define ClutImage PrependMagickMethod(ClutImage) +#define ClutImage PrependMagickMethod(ClutImage) +#define CoalesceImages PrependMagickMethod(CoalesceImages) +#define CoderComponentGenesis PrependMagickMethod(CoderComponentGenesis) +#define CoderComponentTerminus PrependMagickMethod(CoderComponentTerminus) +#define ColorComponentGenesis PrependMagickMethod(ColorComponentGenesis) +#define ColorComponentTerminus PrependMagickMethod(ColorComponentTerminus) +#define ColorDecisionListImage PrependMagickMethod(ColorDecisionListImage) +#define ColorFloodfillImage PrependMagickMethod(ColorFloodfillImage) +#define ColorizeImage PrependMagickMethod(ColorizeImage) +#define CombineImages PrependMagickMethod(CombineImages) +#define CompareHashmapStringInfo PrependMagickMethod(CompareHashmapStringInfo) +#define CompareHashmapString PrependMagickMethod(CompareHashmapString) +#define CompareImages PrependMagickMethod(CompareImages) +#define CompareImagesLayers PrependMagickMethod(CompareImagesLayers) +#define CompareImages PrependMagickMethod(CompareImages) +#define CompareSplayTreeStringInfo PrependMagickMethod(CompareSplayTreeStringInfo) +#define CompareSplayTreeString PrependMagickMethod(CompareSplayTreeString) +#define CompareStringInfo PrependMagickMethod(CompareStringInfo) +#define CompositeImage PrependMagickMethod(CompositeImage) +#define CompositeImage PrependMagickMethod(CompositeImage) +#define CompositeLayers PrependMagickMethod(CompositeLayers) +#define CompressImageColormap PrependMagickMethod(CompressImageColormap) +#define ConcatenateColorComponent PrependMagickMethod(ConcatenateColorComponent) +#define ConcatenateMagickString PrependMagickMethod(ConcatenateMagickString) +#define ConcatenateStringInfo PrependMagickMethod(ConcatenateStringInfo) +#define ConcatenateString PrependMagickMethod(ConcatenateString) +#define ConfigureComponentGenesis PrependMagickMethod(ConfigureComponentGenesis) +#define ConfigureComponentTerminus PrependMagickMethod(ConfigureComponentTerminus) +#define ConfigureFileToStringInfo PrependMagickMethod(ConfigureFileToStringInfo) +#define ConsolidateCMYKImages PrependMagickMethod(ConsolidateCMYKImages) +#define ConstantString PrependMagickMethod(ConstantString) +#define ConstituteComponentGenesis PrependMagickMethod(ConstituteComponentGenesis) +#define ConstituteComponentTerminus PrependMagickMethod(ConstituteComponentTerminus) +#define ConstituteImage PrependMagickMethod(ConstituteImage) +#define ContinueTimer PrependMagickMethod(ContinueTimer) +#define ContrastImage PrependMagickMethod(ContrastImage) +#define ContrastStretchImage PrependMagickMethod(ContrastStretchImage) +#define ContrastStretchImage PrependMagickMethod(ContrastStretchImage) +#define ConvertHSBToRGB PrependMagickMethod(ConvertHSBToRGB) +#define ConvertHSLToRGB PrependMagickMethod(ConvertHSLToRGB) +#define ConvertHWBToRGB PrependMagickMethod(ConvertHWBToRGB) +#define ConvertRGBToHSB PrependMagickMethod(ConvertRGBToHSB) +#define ConvertRGBToHSL PrependMagickMethod(ConvertRGBToHSL) +#define ConvertRGBToHWB PrependMagickMethod(ConvertRGBToHWB) +#define ConvolveImage PrependMagickMethod(ConvolveImage) +#define ConvolveImage PrependMagickMethod(ConvolveImage) +#define CopyMagickMemory PrependMagickMethod(CopyMagickMemory) +#define CopyMagickString PrependMagickMethod(CopyMagickString) +#define CropImage PrependMagickMethod(CropImage) +#define CycleColormapImage PrependMagickMethod(CycleColormapImage) +#define DecipherImage PrependMagickMethod(DecipherImage) +#define DeconstructImages PrependMagickMethod(DeconstructImages) +#define DefineImageArtifact PrependMagickMethod(DefineImageArtifact) +#define DefineImageOption PrependMagickMethod(DefineImageOption) +#define DefineImageProperty PrependMagickMethod(DefineImageProperty) +#define DefineImageRegistry PrependMagickMethod(DefineImageRegistry) +#define DelegateComponentGenesis PrependMagickMethod(DelegateComponentGenesis) +#define DelegateComponentTerminus PrependMagickMethod(DelegateComponentTerminus) +#define DeleteImageArtifact PrependMagickMethod(DeleteImageArtifact) +#define DeleteImageAttribute PrependMagickMethod(DeleteImageAttribute) +#define DeleteImageFromList PrependMagickMethod(DeleteImageFromList) +#define DeleteImageList PrependMagickMethod(DeleteImageList) +#define DeleteImageOption PrependMagickMethod(DeleteImageOption) +#define DeleteImageProfile PrependMagickMethod(DeleteImageProfile) +#define DeleteImageProperty PrependMagickMethod(DeleteImageProperty) +#define DeleteImageRegistry PrependMagickMethod(DeleteImageRegistry) +#define DeleteImages PrependMagickMethod(DeleteImages) +#define DeleteMagickRegistry PrependMagickMethod(DeleteMagickRegistry) +#define DeleteNodeByValueFromSplayTree PrependMagickMethod(DeleteNodeByValueFromSplayTree) +#define DeleteNodeFromSplayTree PrependMagickMethod(DeleteNodeFromSplayTree) +#define DescribeImage PrependMagickMethod(DescribeImage) +#define DeskewImage PrependMagickMethod(DeskewImage) +#define DespeckleImage PrependMagickMethod(DespeckleImage) +#define DestroyBlob PrependMagickMethod(DestroyBlob) +#define DestroyCacheView PrependMagickMethod(DestroyCacheView) +#define DestroyConfigureOptions PrependMagickMethod(DestroyConfigureOptions) +#define DestroyDrawInfo PrependMagickMethod(DestroyDrawInfo) +#define DestroyExceptionInfo PrependMagickMethod(DestroyExceptionInfo) +#define DestroyFxInfo PrependMagickMethod(DestroyFxInfo) +#define DestroyHashmap PrependMagickMethod(DestroyHashmap) +#define DestroyImageArtifacts PrependMagickMethod(DestroyImageArtifacts) +#define DestroyImageAttributes PrependMagickMethod(DestroyImageAttributes) +#define DestroyImageInfo PrependMagickMethod(DestroyImageInfo) +#define DestroyImageList PrependMagickMethod(DestroyImageList) +#define DestroyImageOptions PrependMagickMethod(DestroyImageOptions) +#define DestroyImagePixels PrependMagickMethod(DestroyImagePixels) +#define DestroyImage PrependMagickMethod(DestroyImage) +#define DestroyImageProfiles PrependMagickMethod(DestroyImageProfiles) +#define DestroyImageProperties PrependMagickMethod(DestroyImageProperties) +#define DestroyImages PrependMagickMethod(DestroyImages) +#define DestroyKernel PrependMagickMethod(DestroyKernel) +#define DestroyLinkedList PrependMagickMethod(DestroyLinkedList) +#define DestroyLocaleOptions PrependMagickMethod(DestroyLocaleOptions) +#define DestroyMagickMemory PrependMagickMethod(DestroyMagickMemory) +#define DestroyMagick PrependMagickMethod(DestroyMagick) +#define DestroyMagickRegistry PrependMagickMethod(DestroyMagickRegistry) +#define DestroyMontageInfo PrependMagickMethod(DestroyMontageInfo) +#define DestroyPixelCacheNexus PrependMagickMethod(DestroyPixelCacheNexus) +#define DestroyPixelCache PrependMagickMethod(DestroyPixelCache) +#define DestroyQuantizeInfo PrependMagickMethod(DestroyQuantizeInfo) +#define DestroyQuantumInfo PrependMagickMethod(DestroyQuantumInfo) +#define DestroyRandomInfo PrependMagickMethod(DestroyRandomInfo) +#define DestroyResampleFilter PrependMagickMethod(DestroyResampleFilter) +#define DestroyResizeFilter PrependMagickMethod(DestroyResizeFilter) +#define DestroySemaphoreInfo PrependMagickMethod(DestroySemaphoreInfo) +#define DestroySignatureInfo PrependMagickMethod(DestroySignatureInfo) +#define DestroySplayTree PrependMagickMethod(DestroySplayTree) +#define DestroyStreamInfo PrependMagickMethod(DestroyStreamInfo) +#define DestroyStringInfo PrependMagickMethod(DestroyStringInfo) +#define DestroyStringList PrependMagickMethod(DestroyStringList) +#define DestroyString PrependMagickMethod(DestroyString) +#define DestroyThresholdMap PrependMagickMethod(DestroyThresholdMap) +#define DestroyTimerInfo PrependMagickMethod(DestroyTimerInfo) +#define DestroyTokenInfo PrependMagickMethod(DestroyTokenInfo) +#define DestroyXMLTree PrependMagickMethod(DestroyXMLTree) +#define DestroyXResources PrependMagickMethod(DestroyXResources) +#define DestroyXWidget PrependMagickMethod(DestroyXWidget) +#define DetachBlob PrependMagickMethod(DetachBlob) +#define DisassociateImageStream PrependMagickMethod(DisassociateImageStream) +#define DispatchImage PrependMagickMethod(DispatchImage) +#define DisplayImages PrependMagickMethod(DisplayImages) +#define DisposeImages PrependMagickMethod(DisposeImages) +#define DistortImage PrependMagickMethod(DistortImage) +#define DrawAffineImage PrependMagickMethod(DrawAffineImage) +#define DrawClipPath PrependMagickMethod(DrawClipPath) +#define DrawGradientImage PrependMagickMethod(DrawGradientImage) +#define DrawImage PrependMagickMethod(DrawImage) +#define DrawPatternPath PrependMagickMethod(DrawPatternPath) +#define DrawPrimitive PrependMagickMethod(DrawPrimitive) +#define DuplicateBlob PrependMagickMethod(DuplicateBlob) +#define EdgeImage PrependMagickMethod(EdgeImage) +#define EmbossImage PrependMagickMethod(EmbossImage) +#define EncipherImage PrependMagickMethod(EncipherImage) +#define EnhanceImage PrependMagickMethod(EnhanceImage) +#define EOFBlob PrependMagickMethod(EOFBlob) +#define EqualizeImage PrependMagickMethod(EqualizeImage) +#define EqualizeImage PrependMagickMethod(EqualizeImage) +#define EscapeString PrependMagickMethod(EscapeString) +#define EvaluateImage PrependMagickMethod(EvaluateImage) +#define EvaluateImage PrependMagickMethod(EvaluateImage) +#define ExcerptImage PrependMagickMethod(ExcerptImage) +#define ExpandAffine PrependMagickMethod(ExpandAffine) +#define ExpandFilename PrependMagickMethod(ExpandFilename) +#define ExpandFilenames PrependMagickMethod(ExpandFilenames) +#define ExportImagePixels PrependMagickMethod(ExportImagePixels) +#define ExportQuantumPixels PrependMagickMethod(ExportQuantumPixels) +#define ExtentImage PrependMagickMethod(ExtentImage) +#define ExtractSubimageFromImage PrependMagickMethod(ExtractSubimageFromImage) +#define FileToBlob PrependMagickMethod(FileToBlob) +#define FileToImage PrependMagickMethod(FileToImage) +#define FileToStringInfo PrependMagickMethod(FileToStringInfo) +#define FileToString PrependMagickMethod(FileToString) +#define ConvolveImage PrependMagickMethod(ConvolveImage) +#define ConvolveImage PrependMagickMethod(ConvolveImage) +#define FinalizeSignature PrependMagickMethod(FinalizeSignature) +#define FlattenImages PrependMagickMethod(FlattenImages) +#define FlipImage PrependMagickMethod(FlipImage) +#define FloodfillPaintImage PrependMagickMethod(FloodfillPaintImage) +#define FlopImage PrependMagickMethod(FlopImage) +#define FormatImageAttributeList PrependMagickMethod(FormatImageAttributeList) +#define FormatImageAttribute PrependMagickMethod(FormatImageAttribute) +#define FormatImagePropertyList PrependMagickMethod(FormatImagePropertyList) +#define FormatImageProperty PrependMagickMethod(FormatImageProperty) +#define FormatMagickCaption PrependMagickMethod(FormatMagickCaption) +#define FormatMagickSize PrependMagickMethod(FormatMagickSize) +#define FormatLocaleStringList PrependMagickMethod(FormatLocaleStringList) +#define FormatLocaleString PrependMagickMethod(FormatLocaleString) +#define FormatMagickTime PrependMagickMethod(FormatMagickTime) +#define FormatStringList PrependMagickMethod(FormatStringList) +#define FormatString PrependMagickMethod(FormatString) +#define ForwardFourierTransformImage PrependMagickMethod(ForwardFourierTransformImage) +#define FrameImage PrependMagickMethod(FrameImage) +#define FunctionImage PrependMagickMethod(FunctionImage) +#define FunctionImage PrependMagickMethod(FunctionImage) +#define FuzzyColorCompare PrependMagickMethod(FuzzyColorCompare) +#define FuzzyColorMatch PrependMagickMethod(FuzzyColorMatch) +#define FuzzyOpacityCompare PrependMagickMethod(FuzzyOpacityCompare) +#define FxEvaluateChannelExpression PrependMagickMethod(FxEvaluateChannelExpression) +#define FxEvaluateExpression PrependMagickMethod(FxEvaluateExpression) +#define FxImage PrependMagickMethod(FxImage) +#define FxImage PrependMagickMethod(FxImage) +#define FxPreprocessExpression PrependMagickMethod(FxPreprocessExpression) +#define GammaImage PrependMagickMethod(GammaImage) +#define GammaImage PrependMagickMethod(GammaImage) +#define GaussianBlurImage PrependMagickMethod(GaussianBlurImage) +#define GaussianBlurImage PrependMagickMethod(GaussianBlurImage) +#define GaussJordanElimination PrependMagickMethod(GaussJordanElimination) +#define GenerateDifferentialNoise PrependMagickMethod(GenerateDifferentialNoise) +#define GetAffineMatrix PrependMagickMethod(GetAffineMatrix) +#define GetAuthenticMetacontent PrependMagickMethod(GetAuthenticMetacontent) +#define GetAuthenticPixelCacheNexus PrependMagickMethod(GetAuthenticPixelCacheNexus) +#define GetAuthenticPixelQueue PrependMagickMethod(GetAuthenticPixelQueue) +#define GetAuthenticPixels PrependMagickMethod(GetAuthenticPixels) +#define GetBlobError PrependMagickMethod(GetBlobError) +#define GetBlobFileHandle PrependMagickMethod(GetBlobFileHandle) +#define GetBlobInfo PrependMagickMethod(GetBlobInfo) +#define GetBlobProperties PrependMagickMethod(GetBlobProperties) +#define GetBlobSize PrependMagickMethod(GetBlobSize) +#define GetBlobStreamData PrependMagickMethod(GetBlobStreamData) +#define GetBlobStreamHandler PrependMagickMethod(GetBlobStreamHandler) +#define GetCacheViewAuthenticMetacontent PrependMagickMethod(GetCacheViewAuthenticMetacontent) +#define GetCacheViewAuthenticPixelQueue PrependMagickMethod(GetCacheViewAuthenticPixelQueue) +#define GetCacheViewAuthenticPixels PrependMagickMethod(GetCacheViewAuthenticPixels) +#define GetCacheViewColorspace PrependMagickMethod(GetCacheViewColorspace) +#define GetCacheViewException PrependMagickMethod(GetCacheViewException) +#define GetCacheViewExtent PrependMagickMethod(GetCacheViewExtent) +#define GetCacheViewIndexes PrependMagickMethod(GetCacheViewIndexes) +#define GetCacheViewPixels PrependMagickMethod(GetCacheViewPixels) +#define GetCacheView PrependMagickMethod(GetCacheView) +#define GetCacheViewStorageClass PrependMagickMethod(GetCacheViewStorageClass) +#define GetCacheViewVirtualMetacontent PrependMagickMethod(GetCacheViewVirtualMetacontent) +#define GetCacheViewVirtualPixelQueue PrependMagickMethod(GetCacheViewVirtualPixelQueue) +#define GetCacheViewVirtualPixels PrependMagickMethod(GetCacheViewVirtualPixels) +#define GetClientName PrependMagickMethod(GetClientName) +#define GetClientPath PrependMagickMethod(GetClientPath) +#define GetCoderInfoList PrependMagickMethod(GetCoderInfoList) +#define GetCoderInfo PrependMagickMethod(GetCoderInfo) +#define GetCoderList PrependMagickMethod(GetCoderList) +#define GetColorInfoList PrependMagickMethod(GetColorInfoList) +#define GetColorInfo PrependMagickMethod(GetColorInfo) +#define GetColorList PrependMagickMethod(GetColorList) +#define GetColorTuple PrependMagickMethod(GetColorTuple) +#define GetConfigureBlob PrependMagickMethod(GetConfigureBlob) +#define GetConfigureInfoList PrependMagickMethod(GetConfigureInfoList) +#define GetConfigureInfo PrependMagickMethod(GetConfigureInfo) +#define GetConfigureList PrependMagickMethod(GetConfigureList) +#define GetConfigureOption PrependMagickMethod(GetConfigureOption) +#define GetConfigureOptions PrependMagickMethod(GetConfigureOptions) +#define GetConfigurePaths PrependMagickMethod(GetConfigurePaths) +#define GetConfigureValue PrependMagickMethod(GetConfigureValue) +#define GetDelegateCommand PrependMagickMethod(GetDelegateCommand) +#define GetDelegateCommands PrependMagickMethod(GetDelegateCommands) +#define GetDelegateInfoList PrependMagickMethod(GetDelegateInfoList) +#define GetDelegateInfo PrependMagickMethod(GetDelegateInfo) +#define GetDelegateList PrependMagickMethod(GetDelegateList) +#define GetDelegateMode PrependMagickMethod(GetDelegateMode) +#define GetDelegateThreadSupport PrependMagickMethod(GetDelegateThreadSupport) +#define GetDrawInfo PrependMagickMethod(GetDrawInfo) +#define GetElapsedTime PrependMagickMethod(GetElapsedTime) +#define GetEnvironmentValue PrependMagickMethod(GetEnvironmentValue) +#define GetExceptionMessage PrependMagickMethod(GetExceptionMessage) +#define GetExecutionPath PrependMagickMethod(GetExecutionPath) +#define GetFirstImageInList PrependMagickMethod(GetFirstImageInList) +#define GetGeometry PrependMagickMethod(GetGeometry) +#define GetImageAlphaChannel PrependMagickMethod(GetImageAlphaChannel) +#define GetImageArtifact PrependMagickMethod(GetImageArtifact) +#define GetImageAttribute PrependMagickMethod(GetImageAttribute) +#define GetImageBoundingBox PrependMagickMethod(GetImageBoundingBox) +#define GetImageDepth PrependMagickMethod(GetImageDepth) +#define GetImageDistortion PrependMagickMethod(GetImageDistortion) +#define GetImageDistortions PrependMagickMethod(GetImageDistortions) +#define GetImageExtrema PrependMagickMethod(GetImageExtrema) +#define GetImageKurtosis PrependMagickMethod(GetImageKurtosis) +#define GetImageMean PrependMagickMethod(GetImageMean) +#define GetImageRange PrependMagickMethod(GetImageRange) +#define GetImageStatistics PrependMagickMethod(GetImageStatistics) +#define GetImageClippingPathAttribute PrependMagickMethod(GetImageClippingPathAttribute) +#define GetImageDecoder PrependMagickMethod(GetImageDecoder) +#define GetImageDepth PrependMagickMethod(GetImageDepth) +#define GetImageDistortion PrependMagickMethod(GetImageDistortion) +#define GetImageDynamicThreshold PrependMagickMethod(GetImageDynamicThreshold) +#define GetImageEncoder PrependMagickMethod(GetImageEncoder) +#define GetImageException PrependMagickMethod(GetImageException) +#define GetImageExtent PrependMagickMethod(GetImageExtent) +#define GetImageExtrema PrependMagickMethod(GetImageExtrema) +#define GetImageFromList PrependMagickMethod(GetImageFromList) +#define GetImageFromMagickRegistry PrependMagickMethod(GetImageFromMagickRegistry) +#define GetImageGeometry PrependMagickMethod(GetImageGeometry) +#define GetImageHistogram PrependMagickMethod(GetImageHistogram) +#define GetImageIndexInList PrependMagickMethod(GetImageIndexInList) +#define GetImageInfoFile PrependMagickMethod(GetImageInfoFile) +#define GetImageInfo PrependMagickMethod(GetImageInfo) +#define GetImageKurtosis PrependMagickMethod(GetImageKurtosis) +#define GetImageListIndex PrependMagickMethod(GetImageListIndex) +#define GetImageListLength PrependMagickMethod(GetImageListLength) +#define GetImageList PrependMagickMethod(GetImageList) +#define GetImageListSize PrependMagickMethod(GetImageListSize) +#define GetImageMagick PrependMagickMethod(GetImageMagick) +#define GetImageMask PrependMagickMethod(GetImageMask) +#define GetImageMean PrependMagickMethod(GetImageMean) +#define GetImageOption PrependMagickMethod(GetImageOption) +#define GetImagePixelCache PrependMagickMethod(GetImagePixelCache) +#define GetImagePixels PrependMagickMethod(GetImagePixels) +#define GetImageProfile PrependMagickMethod(GetImageProfile) +#define GetImageProperty PrependMagickMethod(GetImageProperty) +#define GetImageQuantizeError PrependMagickMethod(GetImageQuantizeError) +#define GetImageQuantumDepth PrependMagickMethod(GetImageQuantumDepth) +#define GetImageRange PrependMagickMethod(GetImageRange) +#define GetImageReferenceCount PrependMagickMethod(GetImageReferenceCount) +#define GetImageRegistry PrependMagickMethod(GetImageRegistry) +#define GetImageTotalInkDensity PrependMagickMethod(GetImageTotalInkDensity) +#define GetImageType PrependMagickMethod(GetImageType) +#define GetImageVirtualPixelMethod PrependMagickMethod(GetImageVirtualPixelMethod) +#define GetIndexes PrependMagickMethod(GetIndexes) +#define GetLastImageInList PrependMagickMethod(GetLastImageInList) +#define GetLastValueInLinkedList PrependMagickMethod(GetLastValueInLinkedList) +#define GetLocaleExceptionMessage PrependMagickMethod(GetLocaleExceptionMessage) +#define GetLocaleInfoList PrependMagickMethod(GetLocaleInfoList) +#define GetLocaleInfo_ PrependMagickMethod(GetLocaleInfo_) +#define GetLocaleList PrependMagickMethod(GetLocaleList) +#define GetLocaleMessage PrependMagickMethod(GetLocaleMessage) +#define GetLocaleOptions PrependMagickMethod(GetLocaleOptions) +#define GetLocaleValue PrependMagickMethod(GetLocaleValue) +#define GetLogInfoList PrependMagickMethod(GetLogInfoList) +#define GetLogList PrependMagickMethod(GetLogList) +#define GetLogName PrependMagickMethod(GetLogName) +#define GetMagicInfoList PrependMagickMethod(GetMagicInfoList) +#define GetMagicInfo PrependMagickMethod(GetMagicInfo) +#define GetMagickAdjoin PrependMagickMethod(GetMagickAdjoin) +#define GetMagickBlobSupport PrependMagickMethod(GetMagickBlobSupport) +#define GetMagickCopyright PrependMagickMethod(GetMagickCopyright) +#define GetMagickDescription PrependMagickMethod(GetMagickDescription) +#define GetMagickEndianSupport PrependMagickMethod(GetMagickEndianSupport) +#define GetMagickFeatures PrependMagickMethod(GetMagickFeatures) +#define GetMagickGeometry PrependMagickMethod(GetMagickGeometry) +#define GetMagickHomeURL PrependMagickMethod(GetMagickHomeURL) +#define GetMagickInfoList PrependMagickMethod(GetMagickInfoList) +#define GetMagickInfo PrependMagickMethod(GetMagickInfo) +#define GetMagickList PrependMagickMethod(GetMagickList) +#define GetMagickMemoryMethods PrependMagickMethod(GetMagickMemoryMethods) +#define GetCommandOptions PrependMagickMethod(GetCommandOptions) +#define GetMagickPackageName PrependMagickMethod(GetMagickPackageName) +#define GetMagickPageSize PrependMagickMethod(GetMagickPageSize) +#define GetPixelInfo PrependMagickMethod(GetPixelInfo) +#define GetMagickProperty PrependMagickMethod(GetMagickProperty) +#define GetMagickQuantumDepth PrependMagickMethod(GetMagickQuantumDepth) +#define GetMagickQuantumRange PrependMagickMethod(GetMagickQuantumRange) +#define GetMagickRawSupport PrependMagickMethod(GetMagickRawSupport) +#define GetMagickRegistry PrependMagickMethod(GetMagickRegistry) +#define GetMagickReleaseDate PrependMagickMethod(GetMagickReleaseDate) +#define GetMagickResourceLimit PrependMagickMethod(GetMagickResourceLimit) +#define GetMagickResource PrependMagickMethod(GetMagickResource) +#define GetMagickSeekableStream PrependMagickMethod(GetMagickSeekableStream) +#define GetMagickThreadSupport PrependMagickMethod(GetMagickThreadSupport) +#define GetNextToken PrependMagickMethod(GetNextToken) +#define GetMagickVersion PrependMagickMethod(GetMagickVersion) +#define GetMagicList PrependMagickMethod(GetMagicList) +#define GetMagicName PrependMagickMethod(GetMagicName) +#define GetMimeDescription PrependMagickMethod(GetMimeDescription) +#define GetMimeInfoList PrependMagickMethod(GetMimeInfoList) +#define GetMimeInfo PrependMagickMethod(GetMimeInfo) +#define GetMimeList PrependMagickMethod(GetMimeList) +#define GetMimeType PrependMagickMethod(GetMimeType) +#define GetMonitorHandler PrependMagickMethod(GetMonitorHandler) +#define GetMontageInfo PrependMagickMethod(GetMontageInfo) +#define GetMultilineTypeMetrics PrependMagickMethod(GetMultilineTypeMetrics) +#define GetNextImageArtifact PrependMagickMethod(GetNextImageArtifact) +#define GetNextImageAttribute PrependMagickMethod(GetNextImageAttribute) +#define GetNextImageInList PrependMagickMethod(GetNextImageInList) +#define GetNextImageOption PrependMagickMethod(GetNextImageOption) +#define GetNextImage PrependMagickMethod(GetNextImage) +#define GetNextImageProfile PrependMagickMethod(GetNextImageProfile) +#define GetNextImageProperty PrependMagickMethod(GetNextImageProperty) +#define GetNextImageRegistry PrependMagickMethod(GetNextImageRegistry) +#define GetNextKeyInHashmap PrependMagickMethod(GetNextKeyInHashmap) +#define GetNextKeyInSplayTree PrependMagickMethod(GetNextKeyInSplayTree) +#define GetNextValueInHashmap PrependMagickMethod(GetNextValueInHashmap) +#define GetNextValueInLinkedList PrependMagickMethod(GetNextValueInLinkedList) +#define GetNextValueInSplayTree PrependMagickMethod(GetNextValueInSplayTree) +#define GetNextXMLTreeTag PrependMagickMethod(GetNextXMLTreeTag) +#define GetNumberColors PrependMagickMethod(GetNumberColors) +#define GetNumberOfElementsInLinkedList PrependMagickMethod(GetNumberOfElementsInLinkedList) +#define GetNumberOfEntriesInHashmap PrependMagickMethod(GetNumberOfEntriesInHashmap) +#define GetNumberOfNodesInSplayTree PrependMagickMethod(GetNumberOfNodesInSplayTree) +#define GetNumberScenes PrependMagickMethod(GetNumberScenes) +#define GetOneAuthenticPixel PrependMagickMethod(GetOneAuthenticPixel) +#define GetOneCacheViewAuthenticPixel PrependMagickMethod(GetOneCacheViewAuthenticPixel) +#define GetOneCacheViewVirtualMethodPixel PrependMagickMethod(GetOneCacheViewVirtualMethodPixel) +#define GetOneCacheViewVirtualPixel PrependMagickMethod(GetOneCacheViewVirtualPixel) +#define GetOnePixel PrependMagickMethod(GetOnePixel) +#define GetOneVirtualPixelInfo PrependMagickMethod(GetOneVirtualPixelInfo) +#define GetOneVirtualMethodPixel PrependMagickMethod(GetOneVirtualMethodPixel) +#define GetOneVirtualPixel PrependMagickMethod(GetOneVirtualPixel) +#define GetOptimalKernelWidth1D PrependMagickMethod(GetOptimalKernelWidth1D) +#define GetOptimalKernelWidth2D PrependMagickMethod(GetOptimalKernelWidth2D) +#define GetOptimalKernelWidth PrependMagickMethod(GetOptimalKernelWidth) +#define GetPageGeometry PrependMagickMethod(GetPageGeometry) +#define GetPathAttributes PrependMagickMethod(GetPathAttributes) +#define GetPathComponent PrependMagickMethod(GetPathComponent) +#define GetPathComponents PrependMagickMethod(GetPathComponents) +#define GetPixelCacheColorspace PrependMagickMethod(GetPixelCacheColorspace) +#define GetPixelCacheMethods PrependMagickMethod(GetPixelCacheMethods) +#define GetPixelCacheNexusExtent PrependMagickMethod(GetPixelCacheNexusExtent) +#define GetPixelCacheNexusMetacontent PrependMagickMethod(GetPixelCacheNexusMetacontent) +#define GetPixelCacheNexusPixels PrependMagickMethod(GetPixelCacheNexusPixels) +#define GetPixelCachePixels PrependMagickMethod(GetPixelCachePixels) +#define GetPixelCacheStorageClass PrependMagickMethod(GetPixelCacheStorageClass) +#define GetPixelCacheTileSize PrependMagickMethod(GetPixelCacheTileSize) +#define GetPixelCacheType PrependMagickMethod(GetPixelCacheType) +#define GetPixelCacheVirtualMethod PrependMagickMethod(GetPixelCacheVirtualMethod) +#define GetPixels PrependMagickMethod(GetPixels) +#define GetPolicyInfoList PrependMagickMethod(GetPolicyInfoList) +#define GetPolicyList PrependMagickMethod(GetPolicyList) +#define GetPolicyValue PrependMagickMethod(GetPolicyValue) +#define GetPreviousImageInList PrependMagickMethod(GetPreviousImageInList) +#define GetPreviousImage PrependMagickMethod(GetPreviousImage) +#define GetPseudoRandomValue PrependMagickMethod(GetPseudoRandomValue) +#define GetQuantizeInfo PrependMagickMethod(GetQuantizeInfo) +#define GetQuantumExtent PrependMagickMethod(GetQuantumExtent) +#define GetQuantumInfo PrependMagickMethod(GetQuantumInfo) +#define GetQuantumPixels PrependMagickMethod(GetQuantumPixels) +#define GetQuantumType PrependMagickMethod(GetQuantumType) +#define GetRandomKey PrependMagickMethod(GetRandomKey) +#define GetRandomValue PrependMagickMethod(GetRandomValue) +#define GetResizeFilterSupport PrependMagickMethod(GetResizeFilterSupport) +#define GetResizeFilterWeight PrependMagickMethod(GetResizeFilterWeight) +#define GetSignatureBlocksize PrependMagickMethod(GetSignatureBlocksize) +#define GetSignatureDigest PrependMagickMethod(GetSignatureDigest) +#define GetSignatureDigestsize PrependMagickMethod(GetSignatureDigestsize) +#define GetStreamInfoClientData PrependMagickMethod(GetStreamInfoClientData) +#define GetStringInfoDatum PrependMagickMethod(GetStringInfoDatum) +#define GetStringInfoLength PrependMagickMethod(GetStringInfoLength) +#define GetStringInfoPath PrependMagickMethod(GetStringInfoPath) +#define GetThresholdMapFile PrependMagickMethod(GetThresholdMapFile) +#define GetThresholdMap PrependMagickMethod(GetThresholdMap) +#define GetTimerInfo PrependMagickMethod(GetTimerInfo) +#define GetTypeInfoByFamily PrependMagickMethod(GetTypeInfoByFamily) +#define GetTypeInfoList PrependMagickMethod(GetTypeInfoList) +#define GetTypeInfo PrependMagickMethod(GetTypeInfo) +#define GetTypeList PrependMagickMethod(GetTypeList) +#define GetTypeMetrics PrependMagickMethod(GetTypeMetrics) +#define GetUserTime PrependMagickMethod(GetUserTime) +#define GetValueFromHashmap PrependMagickMethod(GetValueFromHashmap) +#define GetValueFromLinkedList PrependMagickMethod(GetValueFromLinkedList) +#define GetValueFromSplayTree PrependMagickMethod(GetValueFromSplayTree) +#define GetVirtualMetacontentFromNexus PrependMagickMethod(GetVirtualMetacontentFromNexus) +#define GetVirtualMetacontent PrependMagickMethod(GetVirtualMetacontent) +#define GetVirtualPixelQueue PrependMagickMethod(GetVirtualPixelQueue) +#define GetVirtualPixelsFromNexus PrependMagickMethod(GetVirtualPixelsFromNexus) +#define GetVirtualPixelsNexus PrependMagickMethod(GetVirtualPixelsNexus) +#define GetVirtualPixels PrependMagickMethod(GetVirtualPixels) +#define GetXMLTreeAttribute PrependMagickMethod(GetXMLTreeAttribute) +#define GetXMLTreeAttributes PrependMagickMethod(GetXMLTreeAttributes) +#define GetXMLTreeChild PrependMagickMethod(GetXMLTreeChild) +#define GetXMLTreeContent PrependMagickMethod(GetXMLTreeContent) +#define GetXMLTreeOrdered PrependMagickMethod(GetXMLTreeOrdered) +#define GetXMLTreePath PrependMagickMethod(GetXMLTreePath) +#define GetXMLTreeProcessingInstructions PrependMagickMethod(GetXMLTreeProcessingInstructions) +#define GetXMLTreeSibling PrependMagickMethod(GetXMLTreeSibling) +#define GetXMLTreeTag PrependMagickMethod(GetXMLTreeTag) +#define GlobExpression PrependMagickMethod(GlobExpression) +#define GradientImage PrependMagickMethod(GradientImage) +#define GravityAdjustGeometry PrependMagickMethod(GravityAdjustGeometry) +#define HaldClutImage PrependMagickMethod(HaldClutImage) +#define HaldClutImage PrependMagickMethod(HaldClutImage) +#define HashPointerType PrependMagickMethod(HashPointerType) +#define HashStringInfoType PrependMagickMethod(HashStringInfoType) +#define HashStringType PrependMagickMethod(HashStringType) +#define HSLTransform PrependMagickMethod(HSLTransform) +#define HuffmanDecodeImage PrependMagickMethod(HuffmanDecodeImage) +#define HuffmanEncodeImage PrependMagickMethod(HuffmanEncodeImage) +#define IdentifyImage PrependMagickMethod(IdentifyImage) +#define IdentityAffine PrependMagickMethod(IdentityAffine) +#define ImageListToArray PrependMagickMethod(ImageListToArray) +#define ImagesToBlob PrependMagickMethod(ImagesToBlob) +#define ImageToBlob PrependMagickMethod(ImageToBlob) +#define ImageToFile PrependMagickMethod(ImageToFile) +#define ImplodeImage PrependMagickMethod(ImplodeImage) +#define ImportImagePixels PrependMagickMethod(ImportImagePixels) +#define ImportQuantumPixels PrependMagickMethod(ImportQuantumPixels) +#define increase PrependMagickMethod(increase) +#define InheritException PrependMagickMethod(InheritException) +#define InitializeExceptionInfo PrependMagickMethod(InitializeExceptionInfo) +#define InitializeMagick PrependMagickMethod(InitializeMagick) +#define InitializeSignature PrependMagickMethod(InitializeSignature) +#define InjectImageBlob PrependMagickMethod(InjectImageBlob) +#define InsertImageInList PrependMagickMethod(InsertImageInList) +#define InsertTagIntoXMLTree PrependMagickMethod(InsertTagIntoXMLTree) +#define InsertValueInLinkedList PrependMagickMethod(InsertValueInLinkedList) +#define InsertValueInSortedLinkedList PrependMagickMethod(InsertValueInSortedLinkedList) +#define InterpolatePixelColor PrependMagickMethod(InterpolatePixelColor) +#define InterpretImageAttributes PrependMagickMethod(InterpretImageAttributes) +#define InterpretImageFilename PrependMagickMethod(InterpretImageFilename) +#define InterpretImageProperties PrependMagickMethod(InterpretImageProperties) +#define InverseFourierTransformImage PrependMagickMethod(InverseFourierTransformImage) +#define InvokeDelegate PrependMagickMethod(InvokeDelegate) +#define InvokeDynamicImageFilter PrependMagickMethod(InvokeDynamicImageFilter) +#define IsBlobExempt PrependMagickMethod(IsBlobExempt) +#define IsBlobSeekable PrependMagickMethod(IsBlobSeekable) +#define IsBlobTemporary PrependMagickMethod(IsBlobTemporary) +#define IsFuzzyEquivalencePixelInfo PrependMagickMethod(IsFuzzyEquivalencePixelInfo) +#define IsEventLogging PrependMagickMethod(IsEventLogging) +#define IsGeometry PrependMagickMethod(IsGeometry) +#define IsGlob PrependMagickMethod(IsGlob) +#define IsImageGray PrependMagickMethod(IsImageGray) +#define IsHashmapEmpty PrependMagickMethod(IsHashmapEmpty) +#define IsHighDynamicRangeImage PrependMagickMethod(IsHighDynamicRangeImage) +#define IsHistogramImage PrependMagickMethod(IsHistogramImage) +#define IsImageObject PrependMagickMethod(IsImageObject) +#define IsImagesEqual PrependMagickMethod(IsImagesEqual) +#define IsEquivalentImage PrependMagickMethod(IsEquivalentImage) +#define IsLinkedListEmpty PrependMagickMethod(IsLinkedListEmpty) +#define IsFuzzyEquivalencePixelInfo PrependMagickMethod(IsFuzzyEquivalencePixelInfo) +#define IsMagickConflict PrependMagickMethod(IsMagickConflict) +#define IsMagickInstantiated PrependMagickMethod(IsMagickInstantiated) +#define IsCommandOption PrependMagickMethod(IsCommandOption) +#define IsImageMonochrome PrependMagickMethod(IsImageMonochrome) +#define IsEquivalentAlpha PrependMagickMethod(IsEquivalentAlpha) +#define IsImageOpaque PrependMagickMethod(IsImageOpaque) +#define IsPaletteImage PrependMagickMethod(IsPaletteImage) +#define IsPathAccessible PrependMagickMethod(IsPathAccessible) +#define IsRightsAuthorized PrependMagickMethod(IsRightsAuthorized) +#define IsSceneGeometry PrependMagickMethod(IsSceneGeometry) +#define IsSubimage PrependMagickMethod(IsSubimage) +#define IsTaintImage PrependMagickMethod(IsTaintImage) +#define KernelNormalize PrependMagickMethod(KernelNormalize) +#define KernelPrint PrependMagickMethod(KernelPrint) +#define KernelRotate PrependMagickMethod(KernelRotate) +#define LeastSquaresAddTerms PrependMagickMethod(LeastSquaresAddTerms) +#define LevelImageColors PrependMagickMethod(LevelImageColors) +#define LevelImageColors PrependMagickMethod(LevelImageColors) +#define LevelImage PrependMagickMethod(LevelImage) +#define LevelImageColors PrependMagickMethod(LevelImageColors) +#define LevelImage PrependMagickMethod(LevelImage) +#define LevelizeImage PrependMagickMethod(LevelizeImage) +#define LevelizeImage PrependMagickMethod(LevelizeImage) +#define LiberateMemory PrependMagickMethod(LiberateMemory) +#define LiberateSemaphoreInfo PrependMagickMethod(LiberateSemaphoreInfo) +#define LinearStretchImage PrependMagickMethod(LinearStretchImage) +#define LinkedListToArray PrependMagickMethod(LinkedListToArray) +#define LiquidRescaleImage PrependMagickMethod(LiquidRescaleImage) +#define ListCoderInfo PrependMagickMethod(ListCoderInfo) +#define ListColorInfo PrependMagickMethod(ListColorInfo) +#define ListConfigureInfo PrependMagickMethod(ListConfigureInfo) +#define ListDelegateInfo PrependMagickMethod(ListDelegateInfo) +#define ListFiles PrependMagickMethod(ListFiles) +#define ListLocaleInfo PrependMagickMethod(ListLocaleInfo) +#define ListLogInfo PrependMagickMethod(ListLogInfo) +#define ListMagicInfo PrependMagickMethod(ListMagicInfo) +#define ListMagickInfo PrependMagickMethod(ListMagickInfo) +#define ListCommandOptions PrependMagickMethod(ListCommandOptions) +#define ListMagickResourceInfo PrependMagickMethod(ListMagickResourceInfo) +#define ListMimeInfo PrependMagickMethod(ListMimeInfo) +#define ListModuleInfo PrependMagickMethod(ListModuleInfo) +#define ListPolicyInfo PrependMagickMethod(ListPolicyInfo) +#define ListThresholdMapFile PrependMagickMethod(ListThresholdMapFile) +#define ListThresholdMaps PrependMagickMethod(ListThresholdMaps) +#define ListTypeInfo PrependMagickMethod(ListTypeInfo) +#define LoadFontConfigFonts PrependMagickMethod(LoadFontConfigFonts) +#define LoadMimeLists PrependMagickMethod(LoadMimeLists) +#define LocaleCompare PrependMagickMethod(LocaleCompare) +#define LocaleComponentGenesis PrependMagickMethod(LocaleComponentGenesis) +#define LocaleComponentTerminus PrependMagickMethod(LocaleComponentTerminus) +#define LocaleLower PrependMagickMethod(LocaleLower) +#define LocaleNCompare PrependMagickMethod(LocaleNCompare) +#define LocaleUpper PrependMagickMethod(LocaleUpper) +#define LockSemaphoreInfo PrependMagickMethod(LockSemaphoreInfo) +#define LogComponentGenesis PrependMagickMethod(LogComponentGenesis) +#define LogComponentTerminus PrependMagickMethod(LogComponentTerminus) +#define LogMagickEventList PrependMagickMethod(LogMagickEventList) +#define LogMagickEvent PrependMagickMethod(LogMagickEvent) +#define LZWEncodeImage PrependMagickMethod(LZWEncodeImage) +#define MagicComponentGenesis PrependMagickMethod(MagicComponentGenesis) +#define MagicComponentTerminus PrependMagickMethod(MagicComponentTerminus) +#define MagickComponentGenesis PrependMagickMethod(MagickComponentGenesis) +#define MagickComponentTerminus PrependMagickMethod(MagickComponentTerminus) +#define MagickCoreGenesis PrependMagickMethod(MagickCoreGenesis) +#define MagickCoreTerminus PrependMagickMethod(MagickCoreTerminus) +#define MagickCreateThreadKey PrependMagickMethod(MagickCreateThreadKey) +#define MagickDeleteThreadKey PrependMagickMethod(MagickDeleteThreadKey) +#define MagickError PrependMagickMethod(MagickError) +#define MagickFatalError PrependMagickMethod(MagickFatalError) +#define MagickGetThreadValue PrependMagickMethod(MagickGetThreadValue) +#define MagickIncarnate PrependMagickMethod(MagickIncarnate) +#define MagickMonitor PrependMagickMethod(MagickMonitor) +#define CommandOptionToMnemonic PrependMagickMethod(CommandOptionToMnemonic) +#define MagickSetThreadValue PrependMagickMethod(MagickSetThreadValue) +#define MagickToMime PrependMagickMethod(MagickToMime) +#define MagickWarning PrependMagickMethod(MagickWarning) +#define MagnifyImage PrependMagickMethod(MagnifyImage) +#define MapBlob PrependMagickMethod(MapBlob) +#define MapImage PrependMagickMethod(MapImage) +#define MapImages PrependMagickMethod(MapImages) +#define MatteFloodfillImage PrependMagickMethod(MatteFloodfillImage) +#define MedianConvolveImage PrependMagickMethod(MedianConvolveImage) +#define MergeImageLayers PrependMagickMethod(MergeImageLayers) +#define MimeComponentGenesis PrependMagickMethod(MimeComponentGenesis) +#define MimeComponentTerminus PrependMagickMethod(MimeComponentTerminus) +#define MinifyImage PrependMagickMethod(MinifyImage) +#define MinMaxStretchImage PrependMagickMethod(MinMaxStretchImage) +#define ModifyImage PrependMagickMethod(ModifyImage) +#define ModulateImage PrependMagickMethod(ModulateImage) +#define MontageImageList PrependMagickMethod(MontageImageList) +#define MontageImages PrependMagickMethod(MontageImages) +#define MorphImages PrependMagickMethod(MorphImages) +#define MorphologyImage PrependMagickMethod(MorphologyImage) +#define MosaicImages PrependMagickMethod(MosaicImages) +#define MotionBlurImage PrependMagickMethod(MotionBlurImage) +#define MotionBlurImage PrependMagickMethod(MotionBlurImage) +#define MSBOrderLong PrependMagickMethod(MSBOrderLong) +#define MSBOrderShort PrependMagickMethod(MSBOrderShort) +#define MultilineCensus PrependMagickMethod(MultilineCensus) +#define NegateImage PrependMagickMethod(NegateImage) +#define NegateImage PrependMagickMethod(NegateImage) +#define NewHashmap PrependMagickMethod(NewHashmap) +#define NewImageList PrependMagickMethod(NewImageList) +#define NewLinkedList PrependMagickMethod(NewLinkedList) +#define NewMagickImage PrependMagickMethod(NewMagickImage) +#define NewSplayTree PrependMagickMethod(NewSplayTree) +#define NewXMLTree PrependMagickMethod(NewXMLTree) +#define NewXMLTreeTag PrependMagickMethod(NewXMLTreeTag) +#define NormalizeImage PrependMagickMethod(NormalizeImage) +#define NormalizeImage PrependMagickMethod(NormalizeImage) +#define OilPaintImage PrependMagickMethod(OilPaintImage) +#define OpaqueImage PrependMagickMethod(OpaqueImage) +#define OpaquePaintImage PrependMagickMethod(OpaquePaintImage) +#define OpaquePaintImage PrependMagickMethod(OpaquePaintImage) +#define OpenBlob PrependMagickMethod(OpenBlob) +#define OpenCacheView PrependMagickMethod(OpenCacheView) +#define OpenMagickStream PrependMagickMethod(OpenMagickStream) +#define OpenStream PrependMagickMethod(OpenStream) +#define OptimizeImageLayers PrependMagickMethod(OptimizeImageLayers) +#define OptimizeImageTransparency PrependMagickMethod(OptimizeImageTransparency) +#define OptimizePlusImageLayers PrependMagickMethod(OptimizePlusImageLayers) +#define OrderedDitherImage PrependMagickMethod(OrderedDitherImage) +#define PackbitsEncodeImage PrependMagickMethod(PackbitsEncodeImage) +#define PaintFloodfillImage PrependMagickMethod(PaintFloodfillImage) +#define PaintOpaqueImageChannel PrependMagickMethod(PaintOpaqueImageChannel) +#define PaintOpaqueImage PrependMagickMethod(PaintOpaqueImage) +#define PaintTransparentImage PrependMagickMethod(PaintTransparentImage) +#define ParseAbsoluteGeometry PrependMagickMethod(ParseAbsoluteGeometry) +#define ParseAffineGeometry PrependMagickMethod(ParseAffineGeometry) +#define ParseChannelOption PrependMagickMethod(ParseChannelOption) +#define ParseGeometry PrependMagickMethod(ParseGeometry) +#define ParseGravityGeometry PrependMagickMethod(ParseGravityGeometry) +#define ParseImageGeometry PrependMagickMethod(ParseImageGeometry) +#define ParseCommandOption PrependMagickMethod(ParseCommandOption) +#define ParseMetaGeometry PrependMagickMethod(ParseMetaGeometry) +#define ParsePageGeometry PrependMagickMethod(ParsePageGeometry) +#define ParseRegionGeometry PrependMagickMethod(ParseRegionGeometry) +#define ParseSizeGeometry PrependMagickMethod(ParseSizeGeometry) +#define PasskeyDecipherImage PrependMagickMethod(PasskeyDecipherImage) +#define PasskeyEncipherImage PrependMagickMethod(PasskeyEncipherImage) +#define PersistPixelCache PrependMagickMethod(PersistPixelCache) +#define PingBlob PrependMagickMethod(PingBlob) +#define PingImage PrependMagickMethod(PingImage) +#define PingImages PrependMagickMethod(PingImages) +#define PlasmaImage PrependMagickMethod(PlasmaImage) +#define PlasmaImageProxy PrependMagickMethod(PlasmaImageProxy) +#define PolaroidImage PrependMagickMethod(PolaroidImage) +#define PolicyComponentGenesis PrependMagickMethod(PolicyComponentGenesis) +#define PolicyComponentTerminus PrependMagickMethod(PolicyComponentTerminus) +#define PopImageList PrependMagickMethod(PopImageList) +#define PopImagePixels PrependMagickMethod(PopImagePixels) +#define PosterizeImage PrependMagickMethod(PosterizeImage) +#define PostscriptGeometry PrependMagickMethod(PostscriptGeometry) +#define PrependImageToList PrependMagickMethod(PrependImageToList) +#define PreviewImage PrependMagickMethod(PreviewImage) +#define PrintStringInfo PrependMagickMethod(PrintStringInfo) +#define process_message PrependMagickMethod(process_message) +#define ProfileImage PrependMagickMethod(ProfileImage) +#define PruneTagFromXMLTree PrependMagickMethod(PruneTagFromXMLTree) +#define PushImageList PrependMagickMethod(PushImageList) +#define PushImagePixels PrependMagickMethod(PushImagePixels) +#define PutEntryInHashmap PrependMagickMethod(PutEntryInHashmap) +#define QuantizationError PrependMagickMethod(QuantizationError) +#define QuantizeImage PrependMagickMethod(QuantizeImage) +#define QuantizeImages PrependMagickMethod(QuantizeImages) +#define QueryColorDatabase PrependMagickMethod(QueryColorDatabase) +#define QueryColorname PrependMagickMethod(QueryColorname) +#define QueryColorname PrependMagickMethod(QueryColorname) +#define QueryMagickColor PrependMagickMethod(QueryMagickColor) +#define QueueAuthenticPixelCacheNexus PrependMagickMethod(QueueAuthenticPixelCacheNexus) +#define QueueAuthenticPixels PrependMagickMethod(QueueAuthenticPixels) +#define QueueCacheViewAuthenticPixels PrependMagickMethod(QueueCacheViewAuthenticPixels) +#define RaiseImage PrependMagickMethod(RaiseImage) +#define RandomChannelThresholdImage PrependMagickMethod(RandomChannelThresholdImage) +#define RandomComponentGenesis PrependMagickMethod(RandomComponentGenesis) +#define RandomComponentTerminus PrependMagickMethod(RandomComponentTerminus) +#define RandomThresholdImage PrependMagickMethod(RandomThresholdImage) +#define RandomThresholdImage PrependMagickMethod(RandomThresholdImage) +#define ReacquireMemory PrependMagickMethod(ReacquireMemory) +#define ReadBlobByte PrependMagickMethod(ReadBlobByte) +#define ReadBlobDouble PrependMagickMethod(ReadBlobDouble) +#define ReadBlobFloat PrependMagickMethod(ReadBlobFloat) +#define ReadBlobLongLong PrependMagickMethod(ReadBlobLongLong) +#define ReadBlobLong PrependMagickMethod(ReadBlobLong) +#define ReadBlobLSBLong PrependMagickMethod(ReadBlobLSBLong) +#define ReadBlobLSBShort PrependMagickMethod(ReadBlobLSBShort) +#define ReadBlobMSBLong PrependMagickMethod(ReadBlobMSBLong) +#define ReadBlobMSBShort PrependMagickMethod(ReadBlobMSBShort) +#define ReadBlob PrependMagickMethod(ReadBlob) +#define ReadBlobShort PrependMagickMethod(ReadBlobShort) +#define ReadBlobString PrependMagickMethod(ReadBlobString) +#define ReadImage PrependMagickMethod(ReadImage) +#define ReadImages PrependMagickMethod(ReadImages) +#define ReadInlineImage PrependMagickMethod(ReadInlineImage) +#define ReadStream PrependMagickMethod(ReadStream) +#define RecolorImage PrependMagickMethod(RecolorImage) +#define ReduceNoiseImage PrependMagickMethod(ReduceNoiseImage) +#define ReferenceBlob PrependMagickMethod(ReferenceBlob) +#define ReferenceImage PrependMagickMethod(ReferenceImage) +#define ReferencePixelCache PrependMagickMethod(ReferencePixelCache) +#define RegisterARTImage PrependMagickMethod(RegisterARTImage) +#define RegisterAVSImage PrependMagickMethod(RegisterAVSImage) +#define RegisterBGRImage PrependMagickMethod(RegisterBGRImage) +#define RegisterBMPImage PrependMagickMethod(RegisterBMPImage) +#define RegisterBRAILLEImage PrependMagickMethod(RegisterBRAILLEImage) +#define RegisterCALSImage PrependMagickMethod(RegisterCALSImage) +#define RegisterCAPTIONImage PrependMagickMethod(RegisterCAPTIONImage) +#define RegisterCINImage PrependMagickMethod(RegisterCINImage) +#define RegisterCIPImage PrependMagickMethod(RegisterCIPImage) +#define RegisterCLIPImage PrependMagickMethod(RegisterCLIPImage) +#define RegisterCMYKImage PrependMagickMethod(RegisterCMYKImage) +#define RegisterCUTImage PrependMagickMethod(RegisterCUTImage) +#define RegisterDCMImage PrependMagickMethod(RegisterDCMImage) +#define RegisterDDSImage PrependMagickMethod(RegisterDDSImage) +#define RegisterDIBImage PrependMagickMethod(RegisterDIBImage) +#define RegisterDJVUImage PrependMagickMethod(RegisterDJVUImage) +#define RegisterDNGImage PrependMagickMethod(RegisterDNGImage) +#define RegisterDOTImage PrependMagickMethod(RegisterDOTImage) +#define RegisterDPXImage PrependMagickMethod(RegisterDPXImage) +#define RegisterEPTImage PrependMagickMethod(RegisterEPTImage) +#define RegisterFAXImage PrependMagickMethod(RegisterFAXImage) +#define RegisterFITSImage PrependMagickMethod(RegisterFITSImage) +#define RegisterGIFImage PrependMagickMethod(RegisterGIFImage) +#define RegisterGRADIENTImage PrependMagickMethod(RegisterGRADIENTImage) +#define RegisterGRAYImage PrependMagickMethod(RegisterGRAYImage) +#define RegisterHALDImage PrependMagickMethod(RegisterHALDImage) +#define RegisterHISTOGRAMImage PrependMagickMethod(RegisterHISTOGRAMImage) +#define RegisterHRZImage PrependMagickMethod(RegisterHRZImage) +#define RegisterHTMLImage PrependMagickMethod(RegisterHTMLImage) +#define RegisterICONImage PrependMagickMethod(RegisterICONImage) +#define RegisterINFOImage PrependMagickMethod(RegisterINFOImage) +#define RegisterINLINEImage PrependMagickMethod(RegisterINLINEImage) +#define RegisterIPLImage PrependMagickMethod(RegisterIPLImage) +#define RegisterJP2Image PrependMagickMethod(RegisterJP2Image) +#define RegisterJPEGImage PrependMagickMethod(RegisterJPEGImage) +#define RegisterJSONImage PrependMagickMethod(RegisterJSONImage) +#define RegisterLABELImage PrependMagickMethod(RegisterLABELImage) +#define RegisterMCPImage PrependMagickMethod(RegisterMACImage) +#define RegisterMAGICKImage PrependMagickMethod(RegisterMAGICKImage) +#define RegisterMagickInfo PrependMagickMethod(RegisterMagickInfo) +#define RegisterMAPImage PrependMagickMethod(RegisterMAPImage) +#define RegisterMASKImage PrependMagickMethod(RegisterMASKImage) +#define RegisterMATImage PrependMagickMethod(RegisterMATImage) +#define RegisterMATTEImage PrependMagickMethod(RegisterMATTEImage) +#define RegisterMETAImage PrependMagickMethod(RegisterMETAImage) +#define RegisterMIFFImage PrependMagickMethod(RegisterMIFFImage) +#define RegisterMONOImage PrependMagickMethod(RegisterMONOImage) +#define RegisterMPCImage PrependMagickMethod(RegisterMPCImage) +#define RegisterMPEGImage PrependMagickMethod(RegisterMPEGImage) +#define RegisterMPRImage PrependMagickMethod(RegisterMPRImage) +#define RegisterMSLImage PrependMagickMethod(RegisterMSLImage) +#define RegisterMTVImage PrependMagickMethod(RegisterMTVImage) +#define RegisterMVGImage PrependMagickMethod(RegisterMVGImage) +#define RegisterNULLImage PrependMagickMethod(RegisterNULLImage) +#define RegisterOTBImage PrependMagickMethod(RegisterOTBImage) +#define RegisterPALMImage PrependMagickMethod(RegisterPALMImage) +#define RegisterPATTERNImage PrependMagickMethod(RegisterPATTERNImage) +#define RegisterPCDImage PrependMagickMethod(RegisterPCDImage) +#define RegisterPCLImage PrependMagickMethod(RegisterPCLImage) +#define RegisterPCXImage PrependMagickMethod(RegisterPCXImage) +#define RegisterPDBImage PrependMagickMethod(RegisterPDBImage) +#define RegisterPDFImage PrependMagickMethod(RegisterPDFImage) +#define RegisterPICTImage PrependMagickMethod(RegisterPICTImage) +#define RegisterPIXImage PrependMagickMethod(RegisterPIXImage) +#define RegisterPLASMAImage PrependMagickMethod(RegisterPLASMAImage) +#define RegisterPNGImage PrependMagickMethod(RegisterPNGImage) +#define RegisterPNMImage PrependMagickMethod(RegisterPNMImage) +#define RegisterPREVIEWImage PrependMagickMethod(RegisterPREVIEWImage) +#define RegisterPS2Image PrependMagickMethod(RegisterPS2Image) +#define RegisterPS3Image PrependMagickMethod(RegisterPS3Image) +#define RegisterPSDImage PrependMagickMethod(RegisterPSDImage) +#define RegisterPSImage PrependMagickMethod(RegisterPSImage) +#define RegisterPWPImage PrependMagickMethod(RegisterPWPImage) +#define RegisterRAWImage PrependMagickMethod(RegisterRAWImage) +#define RegisterRGBImage PrependMagickMethod(RegisterRGBImage) +#define RegisterRLAImage PrependMagickMethod(RegisterRLAImage) +#define RegisterRLEImage PrependMagickMethod(RegisterRLEImage) +#define RegisterSCRImage PrependMagickMethod(RegisterSCRImage) +#define RegisterSREENSHOTImage PrependMagickMethod(RegisterSCREENSHOTImage) +#define RegisterSCTImage PrependMagickMethod(RegisterSCTImage) +#define RegisterSFWImage PrependMagickMethod(RegisterSFWImage) +#define RegisterSGIImage PrependMagickMethod(RegisterSGIImage) +#define RegisterStaticModules PrependMagickMethod(RegisterStaticModules) +#define RegisterSTEGANOImage PrependMagickMethod(RegisterSTEGANOImage) +#define RegisterSUNImage PrependMagickMethod(RegisterSUNImage) +#define RegisterSVGImage PrependMagickMethod(RegisterSVGImage) +#define RegisterTGAImage PrependMagickMethod(RegisterTGAImage) +#define RegisterTHUMBNAILImage PrependMagickMethod(RegisterTHUMBNAILImage) +#define RegisterTIFFImage PrependMagickMethod(RegisterTIFFImage) +#define RegisterTILEImage PrependMagickMethod(RegisterTILEImage) +#define RegisterTIMImage PrependMagickMethod(RegisterTIMImage) +#define RegisterTTFImage PrependMagickMethod(RegisterTTFImage) +#define RegisterTXTImage PrependMagickMethod(RegisterTXTImage) +#define RegisterUILImage PrependMagickMethod(RegisterUILImage) +#define RegisterURLImage PrependMagickMethod(RegisterURLImage) +#define RegisterUYVYImage PrependMagickMethod(RegisterUYVYImage) +#define RegisterVICARImage PrependMagickMethod(RegisterVICARImage) +#define RegisterVIDImage PrependMagickMethod(RegisterVIDImage) +#define RegisterVIFFImage PrependMagickMethod(RegisterVIFFImage) +#define RegisterVIPSImage PrependMagickMethod(RegisterVIPSImage) +#define RegisterWBMPImage PrependMagickMethod(RegisterWBMPImage) +#define RegisterWMFImage PrependMagickMethod(RegisterWMFImage) +#define RegisterWPGImage PrependMagickMethod(RegisterWPGImage) +#define RegisterXBMImage PrependMagickMethod(RegisterXBMImage) +#define RegisterXCFImage PrependMagickMethod(RegisterXCFImage) +#define RegisterXCImage PrependMagickMethod(RegisterXCImage) +#define RegisterXImage PrependMagickMethod(RegisterXImage) +#define RegisterXPMImage PrependMagickMethod(RegisterXPMImage) +#define RegisterXPSImage PrependMagickMethod(RegisterXPSImage) +#define RegisterXWDImage PrependMagickMethod(RegisterXWDImage) +#define RegisterYCBCRImage PrependMagickMethod(RegisterYCBCRImage) +#define RegisterYUVImage PrependMagickMethod(RegisterYUVImage) +#define RegistryComponentGenesis PrependMagickMethod(RegistryComponentGenesis) +#define RegistryComponentTerminus PrependMagickMethod(RegistryComponentTerminus) +#define RelinquishMagickMemory PrependMagickMethod(RelinquishMagickMemory) +#define RelinquishMagickMatrix PrependMagickMethod(RelinquishMagickMatrix) +#define RelinquishMagickMemory PrependMagickMethod(RelinquishMagickMemory) +#define RelinquishMagickResource PrependMagickMethod(RelinquishMagickResource) +#define RelinquishSemaphoreInfo PrependMagickMethod(RelinquishSemaphoreInfo) +#define RelinquishUniqueFileResource PrependMagickMethod(RelinquishUniqueFileResource) +#define RemapImage PrependMagickMethod(RemapImage) +#define RemapImages PrependMagickMethod(RemapImages) +#define RemoteDisplayCommand PrependMagickMethod(RemoteDisplayCommand) +#define RemoveDuplicateLayers PrependMagickMethod(RemoveDuplicateLayers) +#define RemoveElementByValueFromLinkedList PrependMagickMethod(RemoveElementByValueFromLinkedList) +#define RemoveElementFromLinkedList PrependMagickMethod(RemoveElementFromLinkedList) +#define RemoveEntryFromHashmap PrependMagickMethod(RemoveEntryFromHashmap) +#define RemoveFirstImageFromList PrependMagickMethod(RemoveFirstImageFromList) +#define RemoveImageArtifact PrependMagickMethod(RemoveImageArtifact) +#define RemoveImageFromList PrependMagickMethod(RemoveImageFromList) +#define RemoveImageOption PrependMagickMethod(RemoveImageOption) +#define RemoveImageProfile PrependMagickMethod(RemoveImageProfile) +#define RemoveImageProperty PrependMagickMethod(RemoveImageProperty) +#define RemoveImageRegistry PrependMagickMethod(RemoveImageRegistry) +#define RemoveLastElementFromLinkedList PrependMagickMethod(RemoveLastElementFromLinkedList) +#define RemoveLastImageFromList PrependMagickMethod(RemoveLastImageFromList) +#define RemoveNodeByValueFromSplayTree PrependMagickMethod(RemoveNodeByValueFromSplayTree) +#define RemoveNodeFromSplayTree PrependMagickMethod(RemoveNodeFromSplayTree) +#define RemoveZeroDelayLayers PrependMagickMethod(RemoveZeroDelayLayers) +#define ReplaceImageInList PrependMagickMethod(ReplaceImageInList) +#define ResampleImage PrependMagickMethod(ResampleImage) +#define ResamplePixelColor PrependMagickMethod(ResamplePixelColor) +#define ResetHashmapIterator PrependMagickMethod(ResetHashmapIterator) +#define ResetImageArtifactIterator PrependMagickMethod(ResetImageArtifactIterator) +#define ResetImageAttributeIterator PrependMagickMethod(ResetImageAttributeIterator) +#define ResetImageOptionIterator PrependMagickMethod(ResetImageOptionIterator) +#define ResetImageOptions PrependMagickMethod(ResetImageOptions) +#define ResetImagePage PrependMagickMethod(ResetImagePage) +#define ResetImageProfileIterator PrependMagickMethod(ResetImageProfileIterator) +#define ResetImagePropertyIterator PrependMagickMethod(ResetImagePropertyIterator) +#define ResetImageRegistryIterator PrependMagickMethod(ResetImageRegistryIterator) +#define ResetLinkedListIterator PrependMagickMethod(ResetLinkedListIterator) +#define ResetMagickMemory PrependMagickMethod(ResetMagickMemory) +#define ResetSplayTreeIterator PrependMagickMethod(ResetSplayTreeIterator) +#define ResetSplayTree PrependMagickMethod(ResetSplayTree) +#define ResetStringInfo PrependMagickMethod(ResetStringInfo) +#define ResetTimer PrependMagickMethod(ResetTimer) +#define ResizeImage PrependMagickMethod(ResizeImage) +#define ResizeMagickMemory PrependMagickMethod(ResizeMagickMemory) +#define ResizeQuantumMemory PrependMagickMethod(ResizeQuantumMemory) +#define ResourceComponentGenesis PrependMagickMethod(ResourceComponentGenesis) +#define ResourceComponentTerminus PrependMagickMethod(ResourceComponentTerminus) +#define ReverseImageList PrependMagickMethod(ReverseImageList) +#define sRGBTransformImage PrependMagickMethod(sRGBTransformImage) +#define RollImage PrependMagickMethod(RollImage) +#define RotateImage PrependMagickMethod(RotateImage) +#define RotationalBlurImage PrependMagickMethod(RotationalBlurImage) +#define SampleImage PrependMagickMethod(SampleImage) +#define ScaleImage PrependMagickMethod(ScaleImage) +#define ScaleResampleFilter PrependMagickMethod(ScaleResampleFilter) +#define SetRandomSecretKey PrependMagickMethod(SetRandomSecretKey) +#define SeekBlob PrependMagickMethod(SeekBlob) +#define SegmentImage PrependMagickMethod(SegmentImage) +#define SelectiveBlurImage PrependMagickMethod(SelectiveBlurImage) +#define SelectiveBlurImage PrependMagickMethod(SelectiveBlurImage) +#define SemaphoreComponentGenesis PrependMagickMethod(SemaphoreComponentGenesis) +#define SemaphoreComponentTerminus PrependMagickMethod(SemaphoreComponentTerminus) +#define SeparateImage PrependMagickMethod(SeparateImage) +#define SeparateImages PrependMagickMethod(SeparateImages) +#define SepiaToneImage PrependMagickMethod(SepiaToneImage) +#define SetBlobExempt PrependMagickMethod(SetBlobExempt) +#define SetBlobExtent PrependMagickMethod(SetBlobExtent) +#define SetCacheThreshold PrependMagickMethod(SetCacheThreshold) +#define SetCacheViewPixels PrependMagickMethod(SetCacheViewPixels) +#define SetCacheViewStorageClass PrependMagickMethod(SetCacheViewStorageClass) +#define SetCacheViewVirtualPixelMethod PrependMagickMethod(SetCacheViewVirtualPixelMethod) +#define SetClientName PrependMagickMethod(SetClientName) +#define SetClientPath PrependMagickMethod(SetClientPath) +#define SetErrorHandler PrependMagickMethod(SetErrorHandler) +#define SetExceptionInfo PrependMagickMethod(SetExceptionInfo) +#define SetFatalErrorHandler PrependMagickMethod(SetFatalErrorHandler) +#define SetGeometryInfo PrependMagickMethod(SetGeometryInfo) +#define SetGeometry PrependMagickMethod(SetGeometry) +#define SetHeaderFromIPL PrependMagickMethod(SetHeaderFromIPL) +#define SetImageAlphaChannel PrependMagickMethod(SetImageAlphaChannel) +#define SetImageArtifact PrependMagickMethod(SetImageArtifact) +#define SetImageAttribute PrependMagickMethod(SetImageAttribute) +#define SetImageBackgroundColor PrependMagickMethod(SetImageBackgroundColor) +#define SetImageDepth PrependMagickMethod(SetImageDepth) +#define SetImageColorspace PrependMagickMethod(SetImageColorspace) +#define SetImageDepth PrependMagickMethod(SetImageDepth) +#define SetImageExtent PrependMagickMethod(SetImageExtent) +#define SetImageGray PrependMagickMethod(SetImageGray) +#define SetImageInfoBlob PrependMagickMethod(SetImageInfoBlob) +#define SetImageInfoFile PrependMagickMethod(SetImageInfoFile) +#define SetImageInfo PrependMagickMethod(SetImageInfo) +#define SetImageInfoProgressMonitor PrependMagickMethod(SetImageInfoProgressMonitor) +#define SetImageList PrependMagickMethod(SetImageList) +#define SetImageMask PrependMagickMethod(SetImageMask) +#define SetImageMonochrome PrependMagickMethod(SetImageMonochrome) +#define SetImageOpacity PrependMagickMethod(SetImageOpacity) +#define SetImageOption PrependMagickMethod(SetImageOption) +#define SetImagePixels PrependMagickMethod(SetImagePixels) +#define SetImage PrependMagickMethod(SetImage) +#define SetImageProfile PrependMagickMethod(SetImageProfile) +#define SetImageProgressMonitor PrependMagickMethod(SetImageProgressMonitor) +#define SetImageProperty PrependMagickMethod(SetImageProperty) +#define SetImageRegistry PrependMagickMethod(SetImageRegistry) +#define SetImageStorageClass PrependMagickMethod(SetImageStorageClass) +#define SetImageType PrependMagickMethod(SetImageType) +#define SetImageVirtualPixelMethod PrependMagickMethod(SetImageVirtualPixelMethod) +#define SetLogEventMask PrependMagickMethod(SetLogEventMask) +#define SetLogFormat PrependMagickMethod(SetLogFormat) +#define SetLogName PrependMagickMethod(SetLogName) +#define AcquireMagickInfo PrependMagickMethod(AcquireMagickInfo) +#define SetMagickMemoryMethods PrependMagickMethod(SetMagickMemoryMethods) +#define SetMagickRegistry PrependMagickMethod(SetMagickRegistry) +#define SetMagickResourceLimit PrependMagickMethod(SetMagickResourceLimit) +#define SetMonitorHandler PrependMagickMethod(SetMonitorHandler) +#define SetPixelCacheMethods PrependMagickMethod(SetPixelCacheMethods) +#define SetPixelCacheVirtualMethod PrependMagickMethod(SetPixelCacheVirtualMethod) +#define SetQuantumAlphaType PrependMagickMethod(SetQuantumAlphaType) +#define SetQuantumDepth PrependMagickMethod(SetQuantumDepth) +#define SetQuantumFormat PrependMagickMethod(SetQuantumFormat) +#define SetQuantumImageType PrependMagickMethod(SetQuantumImageType) +#define SetQuantumMinIsWhite PrependMagickMethod(SetQuantumMinIsWhite) +#define SetQuantumPack PrependMagickMethod(SetQuantumPack) +#define SetQuantumPad PrependMagickMethod(SetQuantumPad) +#define SetQuantumQuantum PrependMagickMethod(SetQuantumQuantum) +#define SetQuantumScale PrependMagickMethod(SetQuantumScale) +#define SetRandomKey PrependMagickMethod(SetRandomKey) +#define SetRandomTrueRandom PrependMagickMethod(SetRandomTrueRandom) +#define SetResampleFilterInterpolateMethod PrependMagickMethod(SetResampleFilterInterpolateMethod) +#define SetResampleFilter PrependMagickMethod(SetResampleFilter) +#define SetResampleFilterVirtualPixelMethod PrependMagickMethod(SetResampleFilterVirtualPixelMethod) +#define SetResizeFilterSupport PrependMagickMethod(SetResizeFilterSupport) +#define SetSignatureDigest PrependMagickMethod(SetSignatureDigest) +#define SetStreamInfoClientData PrependMagickMethod(SetStreamInfoClientData) +#define SetStreamInfoMap PrependMagickMethod(SetStreamInfoMap) +#define SetStreamInfoStorageType PrependMagickMethod(SetStreamInfoStorageType) +#define SetStringInfoDatum PrependMagickMethod(SetStringInfoDatum) +#define SetStringInfoLength PrependMagickMethod(SetStringInfoLength) +#define SetStringInfoPath PrependMagickMethod(SetStringInfoPath) +#define SetStringInfo PrependMagickMethod(SetStringInfo) +#define SetWarningHandler PrependMagickMethod(SetWarningHandler) +#define SetXMLTreeAttribute PrependMagickMethod(SetXMLTreeAttribute) +#define SetXMLTreeContent PrependMagickMethod(SetXMLTreeContent) +#define ShadeImage PrependMagickMethod(ShadeImage) +#define ShadowImage PrependMagickMethod(ShadowImage) +#define SharpenImage PrependMagickMethod(SharpenImage) +#define SharpenImage PrependMagickMethod(SharpenImage) +#define ShaveImage PrependMagickMethod(ShaveImage) +#define ShearImage PrependMagickMethod(ShearImage) +#define ShiftImageList PrependMagickMethod(ShiftImageList) +#define SigmoidalContrastImage PrependMagickMethod(SigmoidalContrastImage) +#define SigmoidalContrastImage PrependMagickMethod(SigmoidalContrastImage) +#define SignatureImage PrependMagickMethod(SignatureImage) +#define SimilarityImage PrependMagickMethod(SimilarityImage) +#define SizeBlob PrependMagickMethod(SizeBlob) +#define SketchImage PrependMagickMethod(SketchImage) +#define SolarizeImage PrependMagickMethod(SolarizeImage) +#define SortColormapByIntensity PrependMagickMethod(SortColormapByIntensity) +#define SparseColorImage PrependMagickMethod(SparseColorImage) +#define SpliceImageIntoList PrependMagickMethod(SpliceImageIntoList) +#define SpliceImageList PrependMagickMethod(SpliceImageList) +#define SpliceImage PrependMagickMethod(SpliceImage) +#define SplitImageList PrependMagickMethod(SplitImageList) +#define SplitStringInfo PrependMagickMethod(SplitStringInfo) +#define SpreadImage PrependMagickMethod(SpreadImage) +#define StartTimer PrependMagickMethod(StartTimer) +#define SteganoImage PrependMagickMethod(SteganoImage) +#define StereoAnaglyphImage PrependMagickMethod(StereoAnaglyphImage) +#define StereoImage PrependMagickMethod(StereoImage) +#define StreamImage PrependMagickMethod(StreamImage) +#define StringInfoToHexString PrependMagickMethod(StringInfoToHexString) +#define StringInfoToString PrependMagickMethod(StringInfoToString) +#define StringToArgv PrependMagickMethod(StringToArgv) +#define StringToken PrependMagickMethod(StringToken) +#define StringToList PrependMagickMethod(StringToList) +#define StringToStringInfo PrependMagickMethod(StringToStringInfo) +#define StripImage PrependMagickMethod(StripImage) +#define Strip PrependMagickMethod(Strip) +#define StripString PrependMagickMethod(StripString) +#define SubstituteString PrependMagickMethod(SubstituteString) +#define SwirlImage PrependMagickMethod(SwirlImage) +#define SyncAuthenticPixelCacheNexus PrependMagickMethod(SyncAuthenticPixelCacheNexus) +#define SyncAuthenticPixels PrependMagickMethod(SyncAuthenticPixels) +#define SyncCacheViewAuthenticPixels PrependMagickMethod(SyncCacheViewAuthenticPixels) +#define SyncCacheViewPixels PrependMagickMethod(SyncCacheViewPixels) +#define SyncCacheView PrependMagickMethod(SyncCacheView) +#define SyncImageList PrependMagickMethod(SyncImageList) +#define SyncImagePixels PrependMagickMethod(SyncImagePixels) +#define SyncImage PrependMagickMethod(SyncImage) +#define SyncImageProfiles PrependMagickMethod(SyncImageProfiles) +#define SyncImageSettings PrependMagickMethod(SyncImageSettings) +#define SyncImagesSettings PrependMagickMethod(SyncImagesSettings) +#define SyncNextImageInList PrependMagickMethod(SyncNextImageInList) +#define SystemCommand PrependMagickMethod(SystemCommand) +#define TellBlob PrependMagickMethod(TellBlob) +#define TemporaryFilename PrependMagickMethod(TemporaryFilename) +#define TextureImage PrependMagickMethod(TextureImage) +#define ThresholdImageChannel PrependMagickMethod(ThresholdImageChannel) +#define ThresholdImage PrependMagickMethod(ThresholdImage) +#define ThrowException PrependMagickMethod(ThrowException) +#define ThrowMagickExceptionList PrependMagickMethod(ThrowMagickExceptionList) +#define ThrowMagickException PrependMagickMethod(ThrowMagickException) +#define ThumbnailImage PrependMagickMethod(ThumbnailImage) +#define TintImage PrependMagickMethod(TintImage) +#define Tokenizer PrependMagickMethod(Tokenizer) +#define TransformColorspace PrependMagickMethod(TransformColorspace) +#define TransformHSL PrependMagickMethod(TransformHSL) +#define TransformImageColorspace PrependMagickMethod(TransformImageColorspace) +#define TransformImage PrependMagickMethod(TransformImage) +#define TransformImages PrependMagickMethod(TransformImages) +#define TransformsRGBImage PrependMagickMethod(TransformsRGBImage) +#define TranslateText PrependMagickMethod(TranslateText) +#define TransparentImage PrependMagickMethod(TransparentImage) +#define TransparentPaintImageChroma PrependMagickMethod(TransparentPaintImageChroma) +#define TransparentPaintImage PrependMagickMethod(TransparentPaintImage) +#define TransposeImage PrependMagickMethod(TransposeImage) +#define TransverseImage PrependMagickMethod(TransverseImage) +#define TrimImage PrependMagickMethod(TrimImage) +#define TypeComponentGenesis PrependMagickMethod(TypeComponentGenesis) +#define TypeComponentTerminus PrependMagickMethod(TypeComponentTerminus) +#define UniqueImageColors PrependMagickMethod(UniqueImageColors) +#define UnlockSemaphoreInfo PrependMagickMethod(UnlockSemaphoreInfo) +#define UnmapBlob PrependMagickMethod(UnmapBlob) +#define UnregisterARTImage PrependMagickMethod(UnregisterARTImage) +#define UnregisterAVSImage PrependMagickMethod(UnregisterAVSImage) +#define UnregisterBMPImage PrependMagickMethod(UnregisterBMPImage) +#define UnregisterBGRImage PrependMagickMethod(UnregisterBGRImage) +#define UnregisterBRAILLEImage PrependMagickMethod(UnregisterBRAILLEImage) +#define UnregisterCALSImage PrependMagickMethod(UnregisterCALSImage) +#define UnregisterCAPTIONImage PrependMagickMethod(UnregisterCAPTIONImage) +#define UnregisterCINImage PrependMagickMethod(UnregisterCINImage) +#define UnregisterCIPImage PrependMagickMethod(UnregisterCIPImage) +#define UnregisterCLIPImage PrependMagickMethod(UnregisterCLIPImage) +#define UnregisterCMYKImage PrependMagickMethod(UnregisterCMYKImage) +#define UnregisterCUTImage PrependMagickMethod(UnregisterCUTImage) +#define UnregisterDCMImage PrependMagickMethod(UnregisterDCMImage) +#define UnregisterDDSImage PrependMagickMethod(UnregisterDDSImage) +#define UnregisterDIBImage PrependMagickMethod(UnregisterDIBImage) +#define UnregisterDJVUImage PrependMagickMethod(UnregisterDJVUImage) +#define UnregisterDNGImage PrependMagickMethod(UnregisterDNGImage) +#define UnregisterDOTImage PrependMagickMethod(UnregisterDOTImage) +#define UnregisterDPXImage PrependMagickMethod(UnregisterDPXImage) +#define UnregisterEPTImage PrependMagickMethod(UnregisterEPTImage) +#define UnregisterFAXImage PrependMagickMethod(UnregisterFAXImage) +#define UnregisterFITSImage PrependMagickMethod(UnregisterFITSImage) +#define UnregisterGIFImage PrependMagickMethod(UnregisterGIFImage) +#define UnregisterGRADIENTImage PrependMagickMethod(UnregisterGRADIENTImage) +#define UnregisterGRAYImage PrependMagickMethod(UnregisterGRAYImage) +#define UnregisterHALDImage PrependMagickMethod(UnregisterHALDImage) +#define UnregisterHISTOGRAMImage PrependMagickMethod(UnregisterHISTOGRAMImage) +#define UnregisterHRZImage PrependMagickMethod(UnregisterHRZImage) +#define UnregisterHTMLImage PrependMagickMethod(UnregisterHTMLImage) +#define UnregisterICONImage PrependMagickMethod(UnregisterICONImage) +#define UnregisterINFOImage PrependMagickMethod(UnregisterINFOImage) +#define UnregisterINLINEImage PrependMagickMethod(UnregisterINLINEImage) +#define UnregisterIPLImage PrependMagickMethod(UnregisterIPLImage) +#define UnregisterJP2Image PrependMagickMethod(UnregisterJP2Image) +#define UnregisterJPEGImage PrependMagickMethod(UnregisterJPEGImage) +#define UnregisterJSONImage PrependMagickMethod(UnregisterJSONImage) +#define UnregisterLABELImage PrependMagickMethod(UnregisterLABELImage) +#define UnregisterMACImage PrependMagickMethod(UnregisterMACImage) +#define UnregisterMAGICKImage PrependMagickMethod(UnregisterMAGICKImage) +#define UnregisterMagickInfo PrependMagickMethod(UnregisterMagickInfo) +#define UnregisterMAPImage PrependMagickMethod(UnregisterMAPImage) +#define UnregisterMASKImage PrependMagickMethod(UnregisterMASKImage) +#define UnregisterMATImage PrependMagickMethod(UnregisterMATImage) +#define UnregisterMATTEImage PrependMagickMethod(UnregisterMATTEImage) +#define UnregisterMETAImage PrependMagickMethod(UnregisterMETAImage) +#define UnregisterMIFFImage PrependMagickMethod(UnregisterMIFFImage) +#define UnregisterMONOImage PrependMagickMethod(UnregisterMONOImage) +#define UnregisterMPCImage PrependMagickMethod(UnregisterMPCImage) +#define UnregisterMPEGImage PrependMagickMethod(UnregisterMPEGImage) +#define UnregisterMPRImage PrependMagickMethod(UnregisterMPRImage) +#define UnregisterMSLImage PrependMagickMethod(UnregisterMSLImage) +#define UnregisterMTVImage PrependMagickMethod(UnregisterMTVImage) +#define UnregisterMVGImage PrependMagickMethod(UnregisterMVGImage) +#define UnregisterNULLImage PrependMagickMethod(UnregisterNULLImage) +#define UnregisterOTBImage PrependMagickMethod(UnregisterOTBImage) +#define UnregisterPALMImage PrependMagickMethod(UnregisterPALMImage) +#define UnregisterPATTERNImage PrependMagickMethod(UnregisterPATTERNImage) +#define UnregisterPCDImage PrependMagickMethod(UnregisterPCDImage) +#define UnregisterPCLImage PrependMagickMethod(UnregisterPCLImage) +#define UnregisterPCXImage PrependMagickMethod(UnregisterPCXImage) +#define UnregisterPDBImage PrependMagickMethod(UnregisterPDBImage) +#define UnregisterPDFImage PrependMagickMethod(UnregisterPDFImage) +#define UnregisterPICTImage PrependMagickMethod(UnregisterPICTImage) +#define UnregisterPIXImage PrependMagickMethod(UnregisterPIXImage) +#define UnregisterPLASMAImage PrependMagickMethod(UnregisterPLASMAImage) +#define UnregisterPNGImage PrependMagickMethod(UnregisterPNGImage) +#define UnregisterPNMImage PrependMagickMethod(UnregisterPNMImage) +#define UnregisterPREVIEWImage PrependMagickMethod(UnregisterPREVIEWImage) +#define UnregisterPS2Image PrependMagickMethod(UnregisterPS2Image) +#define UnregisterPS3Image PrependMagickMethod(UnregisterPS3Image) +#define UnregisterPSDImage PrependMagickMethod(UnregisterPSDImage) +#define UnregisterPSImage PrependMagickMethod(UnregisterPSImage) +#define UnregisterPWPImage PrependMagickMethod(UnregisterPWPImage) +#define UnregisterRAWImage PrependMagickMethod(UnregisterRAWImage) +#define UnregisterRGBImage PrependMagickMethod(UnregisterRGBImage) +#define UnregisterRLAImage PrependMagickMethod(UnregisterRLAImage) +#define UnregisterRLEImage PrependMagickMethod(UnregisterRLEImage) +#define UnregisterSCREENSHOTImage PrependMagickMethod(UnregisterSCREENSHOTImage) +#define UnregisterSCRImage PrependMagickMethod(UnregisterSCRImage) +#define UnregisterSCTImage PrependMagickMethod(UnregisterSCTImage) +#define UnregisterSFWImage PrependMagickMethod(UnregisterSFWImage) +#define UnregisterSGIImage PrependMagickMethod(UnregisterSGIImage) +#define UnregisterStaticModules PrependMagickMethod(UnregisterStaticModules) +#define UnregisterSTEGANOImage PrependMagickMethod(UnregisterSTEGANOImage) +#define UnregisterSUNImage PrependMagickMethod(UnregisterSUNImage) +#define UnregisterSVGImage PrependMagickMethod(UnregisterSVGImage) +#define UnregisterTGAImage PrependMagickMethod(UnregisterTGAImage) +#define UnregisterTHUMBNAILImage PrependMagickMethod(UnregisterTHUMBNAILImage) +#define UnregisterTIFFImage PrependMagickMethod(UnregisterTIFFImage) +#define UnregisterTILEImage PrependMagickMethod(UnregisterTILEImage) +#define UnregisterTIMImage PrependMagickMethod(UnregisterTIMImage) +#define UnregisterTTFImage PrependMagickMethod(UnregisterTTFImage) +#define UnregisterTXTImage PrependMagickMethod(UnregisterTXTImage) +#define UnregisterUILImage PrependMagickMethod(UnregisterUILImage) +#define UnregisterURLImage PrependMagickMethod(UnregisterURLImage) +#define UnregisterUYVYImage PrependMagickMethod(UnregisterUYVYImage) +#define UnregisterVICARImage PrependMagickMethod(UnregisterVICARImage) +#define UnregisterVIDImage PrependMagickMethod(UnregisterVIDImage) +#define UnregisterVIFFImage PrependMagickMethod(UnregisterVIFFImage) +#define UnregisterVIPSImage PrependMagickMethod(UnregisterVIPSImage) +#define UnregisterWBMPImage PrependMagickMethod(UnregisterWBMPImage) +#define UnregisterWMFImage PrependMagickMethod(UnregisterWMFImage) +#define UnregisterWPGImage PrependMagickMethod(UnregisterWPGImage) +#define UnregisterXBMImage PrependMagickMethod(UnregisterXBMImage) +#define UnregisterXCFImage PrependMagickMethod(UnregisterXCFImage) +#define UnregisterXCImage PrependMagickMethod(UnregisterXCImage) +#define UnregisterXImage PrependMagickMethod(UnregisterXImage) +#define UnregisterXPMImage PrependMagickMethod(UnregisterXPMImage) +#define UnregisterXPSImage PrependMagickMethod(UnregisterXPSImage) +#define UnregisterXWDImage PrependMagickMethod(UnregisterXWDImage) +#define UnregisterYCBCRImage PrependMagickMethod(UnregisterYCBCRImage) +#define UnregisterYUVImage PrependMagickMethod(UnregisterYUVImage) +#define UnsharpMaskImage PrependMagickMethod(UnsharpMaskImage) +#define UnsharpMaskImage PrependMagickMethod(UnsharpMaskImage) +#define UnshiftImageList PrependMagickMethod(UnshiftImageList) +#define UpdateSignature PrependMagickMethod(UpdateSignature) +#define ValidateColormapIndex PrependMagickMethod(ValidateColormapIndex) +#define VignetteImage PrependMagickMethod(VignetteImage) +#define WaveImage PrependMagickMethod(WaveImage) +#define WhiteThresholdImage PrependMagickMethod(WhiteThresholdImage) +#define WhiteThresholdImage PrependMagickMethod(WhiteThresholdImage) +#define WriteBlobByte PrependMagickMethod(WriteBlobByte) +#define WriteBlobFloat PrependMagickMethod(WriteBlobFloat) +#define WriteBlobLong PrependMagickMethod(WriteBlobLong) +#define WriteBlobLSBLong PrependMagickMethod(WriteBlobLSBLong) +#define WriteBlobLSBShort PrependMagickMethod(WriteBlobLSBShort) +#define WriteBlobMSBLong PrependMagickMethod(WriteBlobMSBLong) +#define WriteBlobMSBShort PrependMagickMethod(WriteBlobMSBShort) +#define WriteBlob PrependMagickMethod(WriteBlob) +#define WriteBlobShort PrependMagickMethod(WriteBlobShort) +#define WriteBlobString PrependMagickMethod(WriteBlobString) +#define WriteImage PrependMagickMethod(WriteImage) +#define WriteImages PrependMagickMethod(WriteImages) +#define WriteStream PrependMagickMethod(WriteStream) +#define XAnimateBackgroundImage PrependMagickMethod(XAnimateBackgroundImage) +#define XAnimateImages PrependMagickMethod(XAnimateImages) +#define XAnnotateImage PrependMagickMethod(XAnnotateImage) +#define XBestFont PrependMagickMethod(XBestFont) +#define XBestIconSize PrependMagickMethod(XBestIconSize) +#define XBestPixel PrependMagickMethod(XBestPixel) +#define XBestVisualInfo PrependMagickMethod(XBestVisualInfo) +#define XCheckDefineCursor PrependMagickMethod(XCheckDefineCursor) +#define XCheckRefreshWindows PrependMagickMethod(XCheckRefreshWindows) +#define XClientMessage PrependMagickMethod(XClientMessage) +#define XColorBrowserWidget PrependMagickMethod(XColorBrowserWidget) +#define XCommandWidget PrependMagickMethod(XCommandWidget) +#define XComponentGenesis PrependMagickMethod(XComponentGenesis) +#define XComponentTerminus PrependMagickMethod(XComponentTerminus) +#define XConfigureImageColormap PrependMagickMethod(XConfigureImageColormap) +#define XConfirmWidget PrependMagickMethod(XConfirmWidget) +#define XConstrainWindowPosition PrependMagickMethod(XConstrainWindowPosition) +#define XDelay PrependMagickMethod(XDelay) +#define XDestroyResourceInfo PrependMagickMethod(XDestroyResourceInfo) +#define XDestroyWindowColors PrependMagickMethod(XDestroyWindowColors) +#define XDialogWidget PrependMagickMethod(XDialogWidget) +#define XDisplayBackgroundImage PrependMagickMethod(XDisplayBackgroundImage) +#define XDisplayImageInfo PrependMagickMethod(XDisplayImageInfo) +#define XDisplayImage PrependMagickMethod(XDisplayImage) +#define XDrawImage PrependMagickMethod(XDrawImage) +#define XError PrependMagickMethod(XError) +#define XFileBrowserWidget PrependMagickMethod(XFileBrowserWidget) +#define XFontBrowserWidget PrependMagickMethod(XFontBrowserWidget) +#define XFreeResources PrependMagickMethod(XFreeResources) +#define XFreeStandardColormap PrependMagickMethod(XFreeStandardColormap) +#define XGetAnnotateInfo PrependMagickMethod(XGetAnnotateInfo) +#define XGetImportInfo PrependMagickMethod(XGetImportInfo) +#define XGetMapInfo PrependMagickMethod(XGetMapInfo) +#define XGetPixelInfo PrependMagickMethod(XGetPixelInfo) +#define XGetResourceClass PrependMagickMethod(XGetResourceClass) +#define XGetResourceDatabase PrependMagickMethod(XGetResourceDatabase) +#define XGetResourceInfo PrependMagickMethod(XGetResourceInfo) +#define XGetResourceInstance PrependMagickMethod(XGetResourceInstance) +#define XGetScreenDensity PrependMagickMethod(XGetScreenDensity) +#define XGetWindowColor PrependMagickMethod(XGetWindowColor) +#define XGetWindowInfo PrependMagickMethod(XGetWindowInfo) +#define XHighlightEllipse PrependMagickMethod(XHighlightEllipse) +#define XHighlightLine PrependMagickMethod(XHighlightLine) +#define XHighlightRectangle PrependMagickMethod(XHighlightRectangle) +#define XImportImage PrependMagickMethod(XImportImage) +#define XInfoWidget PrependMagickMethod(XInfoWidget) +#define XInitializeWindows PrependMagickMethod(XInitializeWindows) +#define XListBrowserWidget PrependMagickMethod(XListBrowserWidget) +#define XMagickProgressMonitor PrependMagickMethod(XMagickProgressMonitor) +#define XMakeCursor PrependMagickMethod(XMakeCursor) +#define XMakeImage PrependMagickMethod(XMakeImage) +#define XMakeMagnifyImage PrependMagickMethod(XMakeMagnifyImage) +#define XMakeStandardColormap PrependMagickMethod(XMakeStandardColormap) +#define XMakeWindow PrependMagickMethod(XMakeWindow) +#define XMenuWidget PrependMagickMethod(XMenuWidget) +#define XMLTreeInfoToXML PrependMagickMethod(XMLTreeInfoToXML) +#define XNoticeWidget PrependMagickMethod(XNoticeWidget) +#define XPreferencesWidget PrependMagickMethod(XPreferencesWidget) +#define XProgressMonitorWidget PrependMagickMethod(XProgressMonitorWidget) +#define XQueryColorDatabase PrependMagickMethod(XQueryColorDatabase) +#define XQueryPosition PrependMagickMethod(XQueryPosition) +#define XRefreshWindow PrependMagickMethod(XRefreshWindow) +#define XRemoteCommand PrependMagickMethod(XRemoteCommand) +#define XRetainWindowColors PrependMagickMethod(XRetainWindowColors) +#define XSetCursorState PrependMagickMethod(XSetCursorState) +#define XSetWindows PrependMagickMethod(XSetWindows) +#define XTextViewWidget PrependMagickMethod(XTextViewWidget) +#define XUserPreferences PrependMagickMethod(XUserPreferences) +#define XWarning PrependMagickMethod(XWarning) +#define XWindowByID PrependMagickMethod(XWindowByID) +#define XWindowByName PrependMagickMethod(XWindowByName) +#define XWindowByProperty PrependMagickMethod(XWindowByProperty) +#define ZLIBEncodeImage PrependMagickMethod(ZLIBEncodeImage) +#define ZoomImage PrependMagickMethod(ZoomImage) +#endif + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/mime.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/mime.h new file mode 100755 index 0000000..8589b4d --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/module.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/module.h new file mode 100755 index 0000000..1282d56 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/monitor.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/monitor.h new file mode 100755 index 0000000..3bbc7f5 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/montage.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/montage.h new file mode 100755 index 0000000..850b164 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/morphology.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/morphology.h new file mode 100755 index 0000000..904422f --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/nt-base.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/nt-base.h new file mode 100755 index 0000000..21186cb --- /dev/null +++ b/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 +#include +#include +#include +#include +#include +#include +#include +#include +#if defined(_DEBUG) && !defined(__MINGW32__) && !defined(__MINGW64__) +#include +#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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/opencl.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/opencl.h new file mode 100755 index 0000000..c03fc04 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/option.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/option.h new file mode 100755 index 0000000..16f8fb8 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/paint.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/paint.h new file mode 100755 index 0000000..cd36ef7 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/pixel-accessor.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/pixel-accessor.h new file mode 100755 index 0000000..6c46236 --- /dev/null +++ b/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 +#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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/pixel.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/pixel.h new file mode 100755 index 0000000..9029195 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/policy.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/policy.h new file mode 100755 index 0000000..44a733f --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/prepress.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/prepress.h new file mode 100755 index 0000000..f6eefc5 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/profile.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/profile.h new file mode 100755 index 0000000..8fccd4e --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/property.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/property.h new file mode 100755 index 0000000..d7cc006 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/quantize.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/quantize.h new file mode 100755 index 0000000..9e643ad --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/quantum.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/quantum.h new file mode 100755 index 0000000..5295394 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/random_.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/random_.h new file mode 100755 index 0000000..31558c8 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/registry.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/registry.h new file mode 100755 index 0000000..0b23797 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/resample.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/resample.h new file mode 100755 index 0000000..fe97e91 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/resize.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/resize.h new file mode 100755 index 0000000..990068a --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/resource_.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/resource_.h new file mode 100755 index 0000000..7bae0ae --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/segment.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/segment.h new file mode 100755 index 0000000..b6cf22a --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/semaphore.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/semaphore.h new file mode 100755 index 0000000..d8dc994 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/shear.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/shear.h new file mode 100755 index 0000000..41510ff --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/signature.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/signature.h new file mode 100755 index 0000000..c5b566f --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/splay-tree.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/splay-tree.h new file mode 100755 index 0000000..222a2a5 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/statistic.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/statistic.h new file mode 100755 index 0000000..c201989 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/stream.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/stream.h new file mode 100755 index 0000000..b7cce2f --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/string_.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/string_.h new file mode 100755 index 0000000..201bc70 --- /dev/null +++ b/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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/studio.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/studio.h new file mode 100755 index 0000000..08940ed --- /dev/null +++ b/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 +#include +#if defined(MAGICKCORE_HAVE_SYS_STAT_H) +# include +#endif +#if defined(MAGICKCORE_STDC_HEADERS) +# include +# include +#else +# if defined(MAGICKCORE_HAVE_STDLIB_H) +# include +# 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 +# endif +# include +#endif +#if defined(MAGICKCORE_HAVE_STRINGS_H) +# include +#endif +#if defined(MAGICKCORE_HAVE_INTTYPES_H) +# include +#endif +#if defined(MAGICKCORE_HAVE_STDINT_H) +# include +#endif +#if defined(MAGICKCORE_HAVE_UNISTD_H) +# include +#endif +#if defined(MAGICKCORE_WINDOWS_SUPPORT) && defined(_DEBUG) +#define _CRTDBG_MAP_ALLOC +#endif +#if defined(MAGICKCORE_WINDOWS_SUPPORT) +# include +# include +# if !defined(MAGICKCORE_HAVE_STRERROR) +# define HAVE_STRERROR +# endif +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(MAGICKCORE_HAVE_XLOCALE_H) +# include +#endif +#if defined(MAGICKCORE_THREAD_SUPPORT) +# include +#elif defined(MAGICKCORE_WINDOWS_SUPPORT) +#include +#include +#include +#pragma comment (lib, "ws2_32.lib") +#endif +#if defined(MAGICKCORE_HAVE_SYS_SYSLIMITS_H) +# include +#endif +#if defined(MAGICKCORE_HAVE_ARM_LIMITS_H) +# include +#endif + +#if defined(MAGICKCORE__OPENCL) +#if defined(MAGICKCORE_HAVE_CL_CL_H) +# include +#endif +#if defined(MAGICKCORE_HAVE_OPENCL_CL_H) +# include +#endif +# define MAGICKCORE_OPENCL_SUPPORT 1 +#endif + +#if defined(_OPENMP) && ((_OPENMP >= 200203) || defined(__OPENCC__)) +# include +# 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 +# include +# if defined(MAGICKCORE_HAVE_SYS_TIMEB_H) +# include +# 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 +# endif +# if defined(MAGICKCORE_HAVE_SYS_DIR_H) +# include +# endif +# if defined(MAGICKCORE_HAVE_NDIR_H) +# include +# endif +# else +# include +# define NAMLEN(dirent) strlen((dirent)->d_name) +# endif +# include +# include +# 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 +# if defined(MAGICKCORE_HAVE_SYS_TIMES_H) +# include +# endif +# if defined(MAGICKCORE_HAVE_SYS_RESOURCE_H) +# include +# endif +# if defined(MAGICKCORE_HAVE_SYS_MMAN_H) +# include +# endif +# if defined(MAGICKCORE_HAVE_SYS_SENDFILE_H) +# include +# endif +#endif +#else +# include +# include +# if defined(macintosh) +# if !defined(DISABLE_SIOUX) +# include +# include +# endif +# include +# 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 diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/threshold.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/threshold.h new file mode 100755 index 0000000..4f702ce --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/threshold.h @@ -0,0 +1,50 @@ +/* + 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 threshold methods. +*/ +#ifndef MAGICKCORE_THRESHOLD_H +#define MAGICKCORE_THRESHOLD_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +typedef struct _ThresholdMap + ThresholdMap; + +extern MagickExport Image + *AdaptiveThresholdImage(const Image *,const size_t,const size_t,const double, + ExceptionInfo *); + +extern MagickExport ThresholdMap + *DestroyThresholdMap(ThresholdMap *), + *GetThresholdMap(const char *,ExceptionInfo *); + +extern MagickExport MagickBooleanType + BilevelImage(Image *,const double,ExceptionInfo *), + BlackThresholdImage(Image *,const char *,ExceptionInfo *), + ClampImage(Image *,ExceptionInfo *), + ListThresholdMaps(FILE *,ExceptionInfo *), + OrderedDitherImage(Image *,const char *,ExceptionInfo *), + PerceptibleImage(Image *,const double,ExceptionInfo *), + RandomThresholdImage(Image *,const double,const double,ExceptionInfo *), + WhiteThresholdImage(Image *,const char *,ExceptionInfo *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/timer.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/timer.h new file mode 100755 index 0000000..61b80d8 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/timer.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 timer methods. +*/ +#ifndef MAGICKCORE_TIMER_H +#define MAGICKCORE_TIMER_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +typedef enum +{ + UndefinedTimerState, + StoppedTimerState, + RunningTimerState +} TimerState; + +typedef struct _Timer +{ + double + start, + stop, + total; +} Timer; + +typedef struct _TimerInfo +{ + Timer + user, + elapsed; + + TimerState + state; + + size_t + signature; +} TimerInfo; + +extern MagickExport double + GetElapsedTime(TimerInfo *), + GetUserTime(TimerInfo *); + +extern MagickExport MagickBooleanType + ContinueTimer(TimerInfo *); + +extern MagickExport TimerInfo + *AcquireTimerInfo(void), + *DestroyTimerInfo(TimerInfo *); + +extern MagickExport void + GetTimerInfo(TimerInfo *), + ResetTimer(TimerInfo *), + StartTimer(TimerInfo *,const MagickBooleanType); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/token.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/token.h new file mode 100755 index 0000000..d84f3c9 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/token.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 token methods. +*/ +#ifndef MAGICKCORE_TOKEN_H +#define MAGICKCORE_TOKEN_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +/* + Typedef declarations. +*/ +typedef struct _TokenInfo + TokenInfo; + +extern MagickExport int + Tokenizer(TokenInfo *,const unsigned int,char *,const size_t,const char *, + const char *,const char *,const char *,const char,char *,int *,char *); + +extern MagickExport MagickBooleanType + GlobExpression(const char *,const char *,const MagickBooleanType); + +extern MagickExport TokenInfo + *AcquireTokenInfo(void), + *DestroyTokenInfo(TokenInfo *); + +extern MagickExport void + GetNextToken(const char *,const char **,const size_t,char *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/transform.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/transform.h new file mode 100755 index 0000000..3ef86bf --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/transform.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 image transform methods. +*/ +#ifndef MAGICKCORE_TRANSFORM_H +#define MAGICKCORE_TRANSFORM_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern MagickExport Image + *AutoOrientImage(const Image *,const OrientationType,ExceptionInfo *), + *ChopImage(const Image *,const RectangleInfo *,ExceptionInfo *), + *ConsolidateCMYKImages(const Image *,ExceptionInfo *), + *CropImage(const Image *,const RectangleInfo *,ExceptionInfo *), + *CropImageToTiles(const Image *,const char *, ExceptionInfo *), + *ExcerptImage(const Image *,const RectangleInfo *,ExceptionInfo *), + *ExtentImage(const Image *,const RectangleInfo *,ExceptionInfo *), + *FlipImage(const Image *,ExceptionInfo *), + *FlopImage(const Image *,ExceptionInfo *), + *RollImage(const Image *,const ssize_t,const ssize_t,ExceptionInfo *), + *ShaveImage(const Image *,const RectangleInfo *,ExceptionInfo *), + *SpliceImage(const Image *,const RectangleInfo *,ExceptionInfo *), + *TransposeImage(const Image *,ExceptionInfo *), + *TransverseImage(const Image *,ExceptionInfo *), + *TrimImage(const Image *,ExceptionInfo *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/type.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/type.h new file mode 100755 index 0000000..419cf7d --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/type.h @@ -0,0 +1,99 @@ +/* + 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 type methods. +*/ +#ifndef MAGICKCORE_TYPE_H +#define MAGICKCORE_TYPE_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +typedef enum +{ + UndefinedStretch, + NormalStretch, + UltraCondensedStretch, + ExtraCondensedStretch, + CondensedStretch, + SemiCondensedStretch, + SemiExpandedStretch, + ExpandedStretch, + ExtraExpandedStretch, + UltraExpandedStretch, + AnyStretch +} StretchType; + +typedef enum +{ + UndefinedStyle, + NormalStyle, + ItalicStyle, + ObliqueStyle, + AnyStyle +} StyleType; + +typedef struct _TypeInfo +{ + size_t + face; + + char + *path, + *name, + *description, + *family; + + StyleType + style; + + StretchType + stretch; + + size_t + weight; + + char + *encoding, + *foundry, + *format, + *metrics, + *glyphs; + + MagickBooleanType + stealth; + + size_t + signature; +} TypeInfo; + +extern MagickExport char + **GetTypeList(const char *,size_t *,ExceptionInfo *); + +extern MagickExport MagickBooleanType + ListTypeInfo(FILE *,ExceptionInfo *); + +extern MagickExport const TypeInfo + *GetTypeInfo(const char *,ExceptionInfo *), + *GetTypeInfoByFamily(const char *,const StyleType,const StretchType, + const size_t,ExceptionInfo *), + **GetTypeInfoList(const char *,size_t *,ExceptionInfo *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/utility.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/utility.h new file mode 100755 index 0000000..1ffaf26 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/utility.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 utility methods. +*/ +#ifndef MAGICKCORE_UTILITY_H +#define MAGICKCORE_UTILITY_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +typedef enum +{ + UndefinedPath, + MagickPath, + RootPath, + HeadPath, + TailPath, + BasePath, + ExtensionPath, + SubimagePath, + CanonicalPath +} PathType; + +extern MagickExport char + *Base64Encode(const unsigned char *,const size_t,size_t *); + +extern MagickExport MagickBooleanType + AcquireUniqueFilename(char *), + AcquireUniqueSymbolicLink(const char *,char *), + ExpandFilenames(int *,char ***), + GetPathAttributes(const char *,void *), + IsPathAccessible(const char *); + +extern MagickExport size_t + MultilineCensus(const char *); + +extern MagickExport unsigned char + *Base64Decode(const char *, size_t *); + +extern MagickExport void + AppendImageFormat(const char *,char *), + GetPathComponent(const char *,PathType,char *), + MagickDelay(const MagickSizeType); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/version.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/version.h new file mode 100755 index 0000000..80414a4 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/version.h @@ -0,0 +1,97 @@ +/* + 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 + + http://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 version methods. +*/ +#ifndef _MAGICKCORE_VERSION_H +#define _MAGICKCORE_VERSION_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +/* + Define declarations. +*/ +#define MagickPackageName "ImageMagick" +#define MagickCopyright "© 1999-2017 ImageMagick Studio LLC" +#define MagickLibVersion 0x705 +#define MagickLibVersionText "7.0.5" +#define MagickLibVersionNumber 2,0,0 +#define MagickLibAddendum "-5" +#define MagickLibInterface 2 +#define MagickLibMinInterface 2 +#if defined(_WINDOWS) +# if defined(_WIN64) +# define MagickPlatform "x64" +# else +# define MagickPlatform "x86" +# endif +#else +#define MagickPlatform "x86_64" +#endif +#define MagickppLibVersionText "7.0.5" +#define MagickppLibVersionNumber 2:0:0 +#define MagickppLibAddendum "-5" +#define MagickppLibInterface 2 +#define MagickppLibMinInterface 2 +#define MagickReleaseDate "2017-05-03" +#define MagickAuthoritativeLicense \ + "http://www.imagemagick.org/script/license.php" +#define MagickAuthoritativeURL "http://www.imagemagick.org" +#define MagickHomeURL "file:///Users/johannespichler/Downloads/newTest/build/share/doc/ImageMagick-7/index.html" +#if (MAGICKCORE_QUANTUM_DEPTH == 8) +#define MagickQuantumDepth "Q8" +#define MagickQuantumRange "255" +#elif (MAGICKCORE_QUANTUM_DEPTH == 16) +#define MagickQuantumDepth "Q16" +#define MagickQuantumRange "65535" +#elif (MAGICKCORE_QUANTUM_DEPTH == 32) +#define MagickQuantumDepth "Q32" +#define MagickQuantumRange "4294967295" +#elif (MAGICKCORE_QUANTUM_DEPTH == 64) +#define MagickQuantumDepth "Q64" +#define MagickQuantumRange "65535" +#else +#define MagickQuantumDepth "Q?" +#define MagickQuantumRange "?" +#endif +#define MagickVersion \ + MagickPackageName " " MagickLibVersionText MagickLibAddendum " " \ + MagickQuantumDepth " " MagickPlatform " " MagickReleaseDate " " \ + MagickAuthoritativeURL + +extern MagickExport char + *GetMagickHomeURL(void); + +extern MagickExport const char + *GetMagickCopyright(void), + *GetMagickDelegates(void), + *GetMagickFeatures(void), + *GetMagickLicense(void), + *GetMagickPackageName(void), + *GetMagickQuantumDepth(size_t *), + *GetMagickQuantumRange(size_t *), + *GetMagickReleaseDate(void), + *GetMagickVersion(size_t *); + +extern MagickExport void + ListMagickVersion(FILE *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/vision.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/vision.h new file mode 100755 index 0000000..16f18dc --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/vision.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 computer vision methods. +*/ +#ifndef MAGICKCORE_VISION_H +#define MAGICKCORE_VISION_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +typedef struct _CCObjectInfo +{ + ssize_t + id; + + RectangleInfo + bounding_box; + + PixelInfo + color; + + PointInfo + centroid; + + double + area, + census; +} CCObjectInfo; + +extern MagickExport Image + *ConnectedComponentsImage(const Image *,const size_t,CCObjectInfo **, + ExceptionInfo *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/widget.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/widget.h new file mode 100755 index 0000000..34f41c7 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/widget.h @@ -0,0 +1,29 @@ +/* + 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 X11 widget methods. +*/ +#ifndef MAGICKCORE_WIDGET_H +#define MAGICKCORE_WIDGET_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/xml-tree.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/xml-tree.h new file mode 100755 index 0000000..e44a84d --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/xml-tree.h @@ -0,0 +1,50 @@ +/* + 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 + + http://www.imagemagick.org/MagicksToolkit/script/license.php + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + Magick's toolkit xml-tree methods. +*/ +#ifndef MAGICKCORE_XML_TREE_H +#define MAGICKCORE_XML_TREE_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +typedef struct _XMLTreeInfo + XMLTreeInfo; + +extern MagickExport char + *XMLTreeInfoToXML(XMLTreeInfo *); + +extern MagickExport const char + *GetXMLTreeAttribute(XMLTreeInfo *,const char *), + *GetXMLTreeContent(XMLTreeInfo *), + *GetXMLTreeTag(XMLTreeInfo *); + +extern MagickExport XMLTreeInfo + *AddChildToXMLTree(XMLTreeInfo *,const char *,const size_t), + *DestroyXMLTree(XMLTreeInfo *), + *GetNextXMLTreeTag(XMLTreeInfo *), + *GetXMLTreeChild(XMLTreeInfo *,const char *), + *GetXMLTreeSibling(XMLTreeInfo *), + *NewXMLTree(const char *,ExceptionInfo *), + *NewXMLTreeTag(const char *), + *SetXMLTreeContent(XMLTreeInfo *,const char *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickCore/xwindow.h b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/xwindow.h new file mode 100755 index 0000000..b7d532c --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickCore/xwindow.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 X11 window methods. +*/ +#ifndef MAGICKCORE_XWINDOW_H +#define MAGICKCORE_XWINDOW_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +typedef struct _XImportInfo +{ + MagickBooleanType + frame, + borders, + screen, + descend, + silent; +} XImportInfo; + +extern MagickExport Image + *XImportImage(const ImageInfo *,XImportInfo *,ExceptionInfo *); + +extern MagickExport void + XGetImportInfo(XImportInfo *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/MagickWand.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/MagickWand.h new file mode 100755 index 0000000..ceb6559 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/MagickWand.h @@ -0,0 +1,136 @@ +/* + 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. + + MagickWand Application Programming Interface declarations. +*/ + +#ifndef MAGICKWAND_MAGICKWAND_H +#define MAGICKWAND_MAGICKWAND_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +#if !defined(MAGICKWAND_CONFIG_H) +# define MAGICKWAND_CONFIG_H +# if !defined(vms) && !defined(macintosh) +# include "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 MAGICKWAND_CHECK_VERSION(major,minor,micro) \ + ((MAGICKWAND_MAJOR_VERSION > (major)) || \ + ((MAGICKWAND_MAJOR_VERSION == (major)) && \ + (MAGICKWAND_MINOR_VERSION > (minor))) || \ + ((MAGICKWAND_MAJOR_VERSION == (major)) && \ + (MAGICKWAND_MINOR_VERSION == (minor)) && \ + (MAGICKWAND_MICRO_VERSION >= (micro)))) + +#include +#include +#include +#include +#include +#include + +#if defined(WIN32) || defined(WIN64) +# define MAGICKWAND_WINDOWS_SUPPORT +#else +# define MAGICKWAND_POSIX_SUPPORT +#endif + +typedef struct _MagickWand + MagickWand; + +#include "MagickWand/method-attribute.h" +#include "MagickCore/MagickCore.h" +#include "MagickWand/animate.h" +#include "MagickWand/compare.h" +#include "MagickWand/composite.h" +#include "MagickWand/conjure.h" +#include "MagickWand/convert.h" +#include "MagickWand/deprecate.h" +#include "MagickWand/display.h" +#include "MagickWand/drawing-wand.h" +#include "MagickWand/identify.h" +#include "MagickWand/import.h" +#include "MagickWand/wandcli.h" +#include "MagickWand/operation.h" +#include "MagickWand/magick-cli.h" +#include "MagickWand/magick-property.h" +#include "MagickWand/magick-image.h" +#include "MagickWand/mogrify.h" +#include "MagickWand/montage.h" +#include "MagickWand/pixel-iterator.h" +#include "MagickWand/pixel-wand.h" +#include "MagickWand/stream.h" +#include "MagickWand/wand-view.h" + +extern WandExport char + *MagickGetException(const MagickWand *,ExceptionType *); + +extern WandExport ExceptionType + MagickGetExceptionType(const MagickWand *); + +extern WandExport MagickBooleanType + IsMagickWand(const MagickWand *), + IsMagickWandInstantiated(void), + MagickClearException(MagickWand *), + MagickSetIteratorIndex(MagickWand *,const ssize_t); + +extern WandExport MagickWand + *CloneMagickWand(const MagickWand *), + *DestroyMagickWand(MagickWand *), + *NewMagickWand(void), + *NewMagickWandFromImage(const Image *); + +extern WandExport ssize_t + MagickGetIteratorIndex(MagickWand *); + +extern WandExport void + ClearMagickWand(MagickWand *), + MagickWandGenesis(void), + MagickWandTerminus(void), + *MagickRelinquishMemory(void *), + MagickResetIterator(MagickWand *), + MagickSetFirstIterator(MagickWand *), + MagickSetLastIterator(MagickWand *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/animate.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/animate.h new file mode 100755 index 0000000..32ff68e --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/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. + + MagickWand animate command-line methods. +*/ +#ifndef MAGICKWAND_ANIMATE_H +#define MAGICKWAND_ANIMATE_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern WandExport MagickBooleanType + AnimateImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/compare.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/compare.h new file mode 100755 index 0000000..199ea3d --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/compare.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. + + MagickWand compare command-line method. +*/ +#ifndef MAGICKWAND_COMPARE_H +#define MAGICKWAND_COMPARE_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern WandExport MagickBooleanType + CompareImagesCommand(ImageInfo *,int,char **,char **,ExceptionInfo *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/composite.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/composite.h new file mode 100755 index 0000000..5c56bbd --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/composite.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. + + MagickWand composite command-line method. +*/ +#ifndef MAGICKWAND_COMPOSITE_H +#define MAGICKWAND_COMPOSITE_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern WandExport MagickBooleanType + CompositeImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/conjure.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/conjure.h new file mode 100755 index 0000000..2361532 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/conjure.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. + + MagickWand conjure command-line method. +*/ +#ifndef MAGICKWAND_CONJURE_H +#define MAGICKWAND_CONJURE_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern WandExport MagickBooleanType + ConjureImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/convert.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/convert.h new file mode 100755 index 0000000..a533113 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/convert.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. + + MagickWand convert command-line method. +*/ +#ifndef MAGICKWAND_CONVERT_H +#define MAGICKWAND_CONVERT_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern WandExport MagickBooleanType + ConvertImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/deprecate.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/deprecate.h new file mode 100755 index 0000000..09b595d --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/deprecate.h @@ -0,0 +1,39 @@ +/* + 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 MAGICKWAND_DEPRECATE_H +#define MAGICKWAND_DEPRECATE_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +#include "MagickWand/pixel-wand.h" + +#if !defined(MAGICKCORE_EXCLUDE_DEPRECATED) + +extern WandExport MagickBooleanType + MagickGetImageAlphaColor(MagickWand *,PixelWand *), + MagickSetImageAlphaColor(MagickWand *,const PixelWand *); + +#endif + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/display.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/display.h new file mode 100755 index 0000000..794dc5b --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/display.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. + + MagickWand display command-line method. +*/ +#ifndef MAGICKWAND_DISPLAY_H +#define MAGICKWAND_DISPLAY_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern WandExport MagickBooleanType + DisplayImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/drawing-wand.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/drawing-wand.h new file mode 100755 index 0000000..1c6f550 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/drawing-wand.h @@ -0,0 +1,228 @@ +/* + 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. + + MagickWand drawing wand methods. +*/ +#ifndef MAGICKWAND_DRAWING_WAND_H +#define MAGICKWAND_DRAWING_WAND_H + +#include "MagickWand/pixel-wand.h" + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +typedef struct _DrawingWand + DrawingWand; + +extern WandExport AlignType + DrawGetTextAlignment(const DrawingWand *); + +extern WandExport char + *DrawGetClipPath(const DrawingWand *), + *DrawGetDensity(const DrawingWand *), + *DrawGetException(const DrawingWand *,ExceptionType *), + *DrawGetFont(const DrawingWand *), + *DrawGetFontFamily(const DrawingWand *), + *DrawGetTextEncoding(const DrawingWand *), + *DrawGetVectorGraphics(DrawingWand *); + +extern WandExport ClipPathUnits + DrawGetClipUnits(const DrawingWand *); + +extern WandExport DecorationType + DrawGetTextDecoration(const DrawingWand *); + +extern WandExport DirectionType + DrawGetTextDirection(const DrawingWand *); + +extern WandExport double + DrawGetFillOpacity(const DrawingWand *), + DrawGetFontSize(const DrawingWand *), + DrawGetOpacity(const DrawingWand *), + *DrawGetStrokeDashArray(const DrawingWand *,size_t *), + DrawGetStrokeDashOffset(const DrawingWand *), + DrawGetStrokeOpacity(const DrawingWand *), + DrawGetStrokeWidth(const DrawingWand *), + DrawGetTextKerning(DrawingWand *), + DrawGetTextInterlineSpacing(DrawingWand *), + DrawGetTextInterwordSpacing(DrawingWand *); + +extern WandExport DrawInfo + *PeekDrawingWand(const DrawingWand *); + +extern WandExport DrawingWand + *AcquireDrawingWand(const DrawInfo *,Image *), + *CloneDrawingWand(const DrawingWand *), + *DestroyDrawingWand(DrawingWand *), + *NewDrawingWand(void); + +extern WandExport ExceptionInfo + *DrawCloneExceptionInfo(const DrawingWand *wand); + +extern WandExport ExceptionType + DrawGetExceptionType(const DrawingWand *); + +extern WandExport FillRule + DrawGetClipRule(const DrawingWand *), + DrawGetFillRule(const DrawingWand *); + +extern WandExport GravityType + DrawGetGravity(const DrawingWand *); + +extern WandExport LineCap + DrawGetStrokeLineCap(const DrawingWand *); + +extern WandExport LineJoin + DrawGetStrokeLineJoin(const DrawingWand *); + +extern WandExport MagickBooleanType + DrawClearException(DrawingWand *), + DrawComposite(DrawingWand *,const CompositeOperator,const double,const double, + const double,const double,MagickWand *), + DrawGetFontResolution(const DrawingWand *,double *,double *), + DrawGetStrokeAntialias(const DrawingWand *), + DrawGetTextAntialias(const DrawingWand *), + DrawPopPattern(DrawingWand *), + DrawPushPattern(DrawingWand *,const char *,const double,const double, + const double,const double), + DrawRender(DrawingWand *), + DrawSetClipPath(DrawingWand *,const char *), + DrawSetDensity(DrawingWand *,const char *), + DrawSetFillPatternURL(DrawingWand *,const char *), + DrawSetFont(DrawingWand *,const char *), + DrawSetFontFamily(DrawingWand *,const char *), + DrawSetFontResolution(DrawingWand *,const double,const double), + DrawSetStrokeDashArray(DrawingWand *,const size_t,const double *), + DrawSetStrokePatternURL(DrawingWand *,const char *), + DrawSetVectorGraphics(DrawingWand *,const char *), + IsDrawingWand(const DrawingWand *), + PopDrawingWand(DrawingWand *), + PushDrawingWand(DrawingWand *); + +extern WandExport StretchType + DrawGetFontStretch(const DrawingWand *); + +extern WandExport StyleType + DrawGetFontStyle(const DrawingWand *); + +extern WandExport size_t + DrawGetFontWeight(const DrawingWand *), + DrawGetStrokeMiterLimit(const DrawingWand *); + +extern WandExport void + ClearDrawingWand(DrawingWand *), + DrawAffine(DrawingWand *,const AffineMatrix *), + DrawAlpha(DrawingWand *,const double,const double,const PaintMethod), + DrawAnnotation(DrawingWand *,const double,const double,const unsigned char *), + DrawArc(DrawingWand *,const double,const double,const double,const double, + const double,const double), + DrawBezier(DrawingWand *,const size_t,const PointInfo *), + DrawGetBorderColor(const DrawingWand *,PixelWand *), + DrawCircle(DrawingWand *,const double,const double,const double,const double), + DrawColor(DrawingWand *,const double,const double,const PaintMethod), + DrawComment(DrawingWand *,const char *), + DrawEllipse(DrawingWand *,const double,const double,const double,const double, + const double,const double), + DrawGetFillColor(const DrawingWand *,PixelWand *), + DrawGetStrokeColor(const DrawingWand *,PixelWand *), + DrawSetTextKerning(DrawingWand *,const double), + DrawSetTextInterlineSpacing(DrawingWand *,const double), + DrawSetTextInterwordSpacing(DrawingWand *,const double), + DrawGetTextUnderColor(const DrawingWand *,PixelWand *), + DrawLine(DrawingWand *,const double, const double,const double,const double), + DrawPathClose(DrawingWand *), + DrawPathCurveToAbsolute(DrawingWand *,const double,const double,const double, + const double,const double,const double), + DrawPathCurveToRelative(DrawingWand *,const double,const double,const double, + const double,const double, const double), + DrawPathCurveToQuadraticBezierAbsolute(DrawingWand *,const double, + const double,const double,const double), + DrawPathCurveToQuadraticBezierRelative(DrawingWand *,const double, + const double,const double,const double), + DrawPathCurveToQuadraticBezierSmoothAbsolute(DrawingWand *,const double, + const double), + DrawPathCurveToQuadraticBezierSmoothRelative(DrawingWand *,const double, + const double), + DrawPathCurveToSmoothAbsolute(DrawingWand *,const double,const double, + const double,const double), + DrawPathCurveToSmoothRelative(DrawingWand *,const double,const double, + const double,const double), + DrawPathEllipticArcAbsolute(DrawingWand *,const double,const double, + const double,const MagickBooleanType,const MagickBooleanType,const double, + const double), + DrawPathEllipticArcRelative(DrawingWand *,const double,const double, + const double,const MagickBooleanType,const MagickBooleanType,const double, + const double), + DrawPathFinish(DrawingWand *), + DrawPathLineToAbsolute(DrawingWand *,const double,const double), + DrawPathLineToRelative(DrawingWand *,const double,const double), + DrawPathLineToHorizontalAbsolute(DrawingWand *,const double), + DrawPathLineToHorizontalRelative(DrawingWand *,const double), + DrawPathLineToVerticalAbsolute(DrawingWand *,const double), + DrawPathLineToVerticalRelative(DrawingWand *,const double), + DrawPathMoveToAbsolute(DrawingWand *,const double,const double), + DrawPathMoveToRelative(DrawingWand *,const double,const double), + DrawPathStart(DrawingWand *), + DrawPoint(DrawingWand *,const double,const double), + DrawPolygon(DrawingWand *,const size_t,const PointInfo *), + DrawPolyline(DrawingWand *,const size_t,const PointInfo *), + DrawPopClipPath(DrawingWand *), + DrawPopDefs(DrawingWand *), + DrawPushClipPath(DrawingWand *,const char *), + DrawPushDefs(DrawingWand *), + DrawRectangle(DrawingWand *,const double,const double,const double, + const double), + DrawResetVectorGraphics(DrawingWand *), + DrawRotate(DrawingWand *,const double), + DrawRoundRectangle(DrawingWand *,double,double,double,double,double,double), + DrawScale(DrawingWand *,const double,const double), + DrawSetBorderColor(DrawingWand *,const PixelWand *), + DrawSetClipRule(DrawingWand *,const FillRule), + DrawSetClipUnits(DrawingWand *,const ClipPathUnits), + DrawSetFillColor(DrawingWand *,const PixelWand *), + DrawSetFillOpacity(DrawingWand *,const double), + DrawSetFillRule(DrawingWand *,const FillRule), + DrawSetFontSize(DrawingWand *,const double), + DrawSetFontStretch(DrawingWand *,const StretchType), + DrawSetFontStyle(DrawingWand *,const StyleType), + DrawSetFontWeight(DrawingWand *,const size_t), + DrawSetGravity(DrawingWand *,const GravityType), + DrawSetOpacity(DrawingWand *,const double), + DrawSetStrokeAntialias(DrawingWand *,const MagickBooleanType), + DrawSetStrokeColor(DrawingWand *,const PixelWand *), + DrawSetStrokeDashOffset(DrawingWand *,const double dashoffset), + DrawSetStrokeLineCap(DrawingWand *,const LineCap), + DrawSetStrokeLineJoin(DrawingWand *,const LineJoin), + DrawSetStrokeMiterLimit(DrawingWand *,const size_t), + DrawSetStrokeOpacity(DrawingWand *, const double), + DrawSetStrokeWidth(DrawingWand *,const double), + DrawSetTextAlignment(DrawingWand *,const AlignType), + DrawSetTextAntialias(DrawingWand *,const MagickBooleanType), + DrawSetTextDecoration(DrawingWand *,const DecorationType), + DrawSetTextDirection(DrawingWand *,const DirectionType), + DrawSetTextEncoding(DrawingWand *,const char *), + DrawSetTextUnderColor(DrawingWand *,const PixelWand *), + DrawSetViewbox(DrawingWand *,const double,const double,const double, + const double), + DrawSkewX(DrawingWand *,const double), + DrawSkewY(DrawingWand *,const double), + DrawTranslate(DrawingWand *,const double,const double); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/identify.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/identify.h new file mode 100755 index 0000000..c0667e8 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/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. + + MagickWand identify command-line method. +*/ +#ifndef MAGICKWAND_IDENTIFY_H +#define MAGICKWAND_IDENTIFY_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern WandExport MagickBooleanType + IdentifyImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/import.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/import.h new file mode 100755 index 0000000..fe1c7de --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/import.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. + + MagickWand import command-line method. +*/ +#ifndef MAGICKWAND_IMPORT_H +#define MAGICKWAND_IMPORT_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern WandExport MagickBooleanType + ImportImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/magick-cli.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/magick-cli.h new file mode 100755 index 0000000..84dc240 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/magick-cli.h @@ -0,0 +1,38 @@ +/* + 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. + + MagickWand convert command-line method. +*/ +#ifndef MAGICKWAND_MAGICK_CLI_H +#define MAGICKWAND_MAGICK_CLI_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern WandExport void + ProcessScriptOptions(MagickCLI *,const char *,int,char **,int); + +extern WandExport int + ProcessCommandOptions(MagickCLI *,int,char **,int); + +extern WandExport MagickBooleanType + MagickImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/magick-image.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/magick-image.h new file mode 100755 index 0000000..47b1432 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/magick-image.h @@ -0,0 +1,398 @@ +/* + 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. + + MagickWand image Methods. +*/ + +#ifndef MAGICKWAND_MAGICK_IMAGE_H +#define MAGICKWAND_MAGICK_IMAGE_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern WandExport ChannelFeatures + *MagickGetImageFeatures(MagickWand *,const size_t); + +extern WandExport ChannelType + MagickSetImageChannelMask(MagickWand *,const ChannelType); + +extern WandExport ChannelStatistics + *MagickGetImageStatistics(MagickWand *); + +extern WandExport char + *MagickGetImageFilename(MagickWand *), + *MagickGetImageFormat(MagickWand *), + *MagickGetImageSignature(MagickWand *), + *MagickIdentifyImage(MagickWand *); + +extern WandExport ColorspaceType + MagickGetImageColorspace(MagickWand *); + +extern WandExport CompositeOperator + MagickGetImageCompose(MagickWand *); + +extern WandExport CompressionType + MagickGetImageCompression(MagickWand *); + +extern WandExport DisposeType + MagickGetImageDispose(MagickWand *); + +extern WandExport double + *MagickGetImageDistortions(MagickWand *,const MagickWand *, + const MetricType), + MagickGetImageFuzz(MagickWand *), + MagickGetImageGamma(MagickWand *), + MagickGetImageTotalInkDensity(MagickWand *); + +extern WandExport EndianType + MagickGetImageEndian(MagickWand *); + +extern WandExport GravityType + MagickGetImageGravity(MagickWand *); + +extern WandExport Image + *MagickDestroyImage(Image *), + *GetImageFromMagickWand(const MagickWand *); + +extern WandExport ImageType + MagickGetImageType(MagickWand *), + MagickIdentifyImageType(MagickWand *); + +extern WandExport InterlaceType + MagickGetImageInterlaceScheme(MagickWand *); + +extern WandExport PixelInterpolateMethod + MagickGetImageInterpolateMethod(MagickWand *); + +extern WandExport MagickBooleanType + MagickAdaptiveBlurImage(MagickWand *,const double,const double), + MagickAdaptiveResizeImage(MagickWand *,const size_t,const size_t), + MagickAdaptiveSharpenImage(MagickWand *,const double,const double), + MagickAdaptiveThresholdImage(MagickWand *,const size_t,const size_t, + const double), + MagickAddImage(MagickWand *,const MagickWand *), + MagickAddNoiseImage(MagickWand *,const NoiseType,const double), + MagickAffineTransformImage(MagickWand *,const DrawingWand *), + MagickAnnotateImage(MagickWand *,const DrawingWand *,const double, + const double,const double,const char *), + MagickAnimateImages(MagickWand *,const char *), + MagickAutoGammaImage(MagickWand *), + MagickAutoLevelImage(MagickWand *), + MagickAutoOrientImage(MagickWand *), + MagickBlackThresholdImage(MagickWand *,const PixelWand *), + MagickBlueShiftImage(MagickWand *,const double), + MagickBlurImage(MagickWand *,const double,const double), + MagickBorderImage(MagickWand *,const PixelWand *,const size_t,const size_t, + const CompositeOperator compose), + MagickBrightnessContrastImage(MagickWand *,const double,const double), + MagickCharcoalImage(MagickWand *,const double,const double), + MagickChopImage(MagickWand *,const size_t,const size_t,const ssize_t, + const ssize_t), + MagickClampImage(MagickWand *), + MagickClipImage(MagickWand *), + MagickClipImagePath(MagickWand *,const char *,const MagickBooleanType), + MagickClutImage(MagickWand *,const MagickWand *,const PixelInterpolateMethod), + MagickColorDecisionListImage(MagickWand *,const char *), + MagickColorizeImage(MagickWand *,const PixelWand *,const PixelWand *), + MagickColorMatrixImage(MagickWand *,const KernelInfo *), + MagickCommentImage(MagickWand *,const char *), + MagickCompositeImage(MagickWand *,const MagickWand *,const CompositeOperator, + const MagickBooleanType,const ssize_t,const ssize_t), + MagickCompositeImageGravity(MagickWand *,const MagickWand *, + const CompositeOperator,const GravityType), + MagickCompositeLayers(MagickWand *,const MagickWand *,const CompositeOperator, + const ssize_t,const ssize_t), + MagickConstituteImage(MagickWand *,const size_t,const size_t,const char *, + const StorageType,const void *), + MagickContrastImage(MagickWand *,const MagickBooleanType), + MagickContrastStretchImage(MagickWand *,const double,const double), + MagickConvolveImage(MagickWand *,const KernelInfo *), + MagickCropImage(MagickWand *,const size_t,const size_t,const ssize_t, + const ssize_t), + MagickCycleColormapImage(MagickWand *,const ssize_t), + MagickDecipherImage(MagickWand *,const char *), + MagickDeskewImage(MagickWand *,const double), + MagickDespeckleImage(MagickWand *), + MagickDisplayImage(MagickWand *,const char *), + MagickDisplayImages(MagickWand *,const char *), + MagickDistortImage(MagickWand *,const DistortMethod,const size_t, + const double *,const MagickBooleanType), + MagickDrawImage(MagickWand *,const DrawingWand *), + MagickEdgeImage(MagickWand *,const double), + MagickEmbossImage(MagickWand *,const double,const double), + MagickEncipherImage(MagickWand *,const char *), + MagickEnhanceImage(MagickWand *), + MagickEqualizeImage(MagickWand *), + MagickEvaluateImage(MagickWand *,const MagickEvaluateOperator,const double), + MagickExportImagePixels(MagickWand *,const ssize_t,const ssize_t, + const size_t,const size_t,const char *,const StorageType,void *), + MagickExtentImage(MagickWand *,const size_t,const size_t,const ssize_t, + const ssize_t), + MagickFlipImage(MagickWand *), + MagickFloodfillPaintImage(MagickWand *,const PixelWand *,const double, + const PixelWand *,const ssize_t,const ssize_t,const MagickBooleanType), + MagickFlopImage(MagickWand *), + MagickForwardFourierTransformImage(MagickWand *,const MagickBooleanType), + MagickFrameImage(MagickWand *,const PixelWand *,const size_t,const size_t, + const ssize_t,const ssize_t,const CompositeOperator), + MagickFunctionImage(MagickWand *,const MagickFunction,const size_t, + const double *), + MagickGammaImage(MagickWand *,const double), + MagickGaussianBlurImage(MagickWand *,const double,const double), + MagickGetImageAlphaChannel(MagickWand *), + MagickGetImageBackgroundColor(MagickWand *,PixelWand *), + MagickGetImageBluePrimary(MagickWand *,double *,double *,double *), + MagickGetImageBorderColor(MagickWand *,PixelWand *), + MagickGetImageKurtosis(MagickWand *,double *,double *), + MagickGetImageMean(MagickWand *,double *,double *), + MagickGetImageRange(MagickWand *,double *,double *), + MagickGetImageColormapColor(MagickWand *,const size_t,PixelWand *), + MagickGetImageDistortion(MagickWand *,const MagickWand *,const MetricType, + double *), + MagickGetImageGreenPrimary(MagickWand *,double *,double *,double *), + MagickGetImageLength(MagickWand *,MagickSizeType *), + MagickGetImageMatteColor(MagickWand *,PixelWand *), + MagickGetImagePage(MagickWand *,size_t *,size_t *,ssize_t *, + ssize_t *), + MagickGetImagePixelColor(MagickWand *,const ssize_t,const ssize_t, + PixelWand *), + MagickGetImageRange(MagickWand *,double *,double *), + MagickGetImageRedPrimary(MagickWand *,double *,double *,double *), + MagickGetImageResolution(MagickWand *,double *,double *), + MagickGetImageWhitePoint(MagickWand *,double *,double *,double *), + MagickHaldClutImage(MagickWand *,const MagickWand *), + MagickHasNextImage(MagickWand *), + MagickHasPreviousImage(MagickWand *), + MagickImplodeImage(MagickWand *,const double,const PixelInterpolateMethod), + MagickImportImagePixels(MagickWand *,const ssize_t,const ssize_t,const size_t, + const size_t,const char *,const StorageType,const void *), + MagickInterpolativeResizeImage(MagickWand *,const size_t,const size_t, + const PixelInterpolateMethod), + MagickInverseFourierTransformImage(MagickWand *,MagickWand *, + const MagickBooleanType), + MagickLabelImage(MagickWand *,const char *), + MagickLevelImage(MagickWand *,const double,const double,const double), + MagickLinearStretchImage(MagickWand *,const double,const double), + MagickLiquidRescaleImage(MagickWand *,const size_t,const size_t,const double, + const double), + MagickLocalContrastImage(MagickWand *,const double,const double), + MagickMagnifyImage(MagickWand *), + MagickMedianConvolveImage(MagickWand *,const double), + MagickMinifyImage(MagickWand *), + MagickModeImage(MagickWand *,const double), + MagickModulateImage(MagickWand *,const double,const double,const double), + MagickMorphologyImage(MagickWand *,MorphologyMethod,const ssize_t, + KernelInfo *), + MagickMotionBlurImage(MagickWand *,const double,const double,const double), + MagickNegateImage(MagickWand *,const MagickBooleanType), + MagickNewImage(MagickWand *,const size_t,const size_t,const PixelWand *), + MagickNextImage(MagickWand *), + MagickNormalizeImage(MagickWand *), + MagickOilPaintImage(MagickWand *,const double,const double), + MagickOpaquePaintImage(MagickWand *,const PixelWand *,const PixelWand *, + const double,const MagickBooleanType), + MagickOptimizeImageTransparency(MagickWand *), + MagickOrderedDitherImage(MagickWand *,const char *), + MagickTransparentPaintImage(MagickWand *,const PixelWand *, + const double,const double,const MagickBooleanType invert), + MagickPingImage(MagickWand *,const char *), + MagickPingImageBlob(MagickWand *,const void *,const size_t), + MagickPingImageFile(MagickWand *,FILE *), + MagickPolaroidImage(MagickWand *,const DrawingWand *,const char *, + const double,const PixelInterpolateMethod), + MagickPosterizeImage(MagickWand *,const size_t,const DitherMethod), + MagickPreviousImage(MagickWand *), + MagickQuantizeImage(MagickWand *,const size_t,const ColorspaceType, + const size_t,const DitherMethod,const MagickBooleanType), + MagickQuantizeImages(MagickWand *,const size_t,const ColorspaceType, + const size_t,const DitherMethod,const MagickBooleanType), + MagickRotationalBlurImage(MagickWand *,const double), + MagickRaiseImage(MagickWand *,const size_t,const size_t,const ssize_t, + const ssize_t,const MagickBooleanType), + MagickRandomThresholdImage(MagickWand *,const double,const double), + MagickReadImage(MagickWand *,const char *), + MagickReadImageBlob(MagickWand *,const void *,const size_t), + MagickReadImageFile(MagickWand *,FILE *), + MagickReduceNoiseImage(MagickWand *,const double), + MagickRemapImage(MagickWand *,const MagickWand *,const DitherMethod), + MagickRemoveImage(MagickWand *), + MagickResampleImage(MagickWand *,const double,const double,const FilterType), + MagickResetImagePage(MagickWand *,const char *), + MagickResizeImage(MagickWand *,const size_t,const size_t,const FilterType), + MagickRollImage(MagickWand *,const ssize_t,const ssize_t), + MagickRotateImage(MagickWand *,const PixelWand *,const double), + MagickSampleImage(MagickWand *,const size_t,const size_t), + MagickScaleImage(MagickWand *,const size_t,const size_t), + MagickSegmentImage(MagickWand *,const ColorspaceType,const MagickBooleanType, + const double,const double), + MagickSelectiveBlurImage(MagickWand *,const double,const double, + const double), + MagickSeparateImage(MagickWand *,const ChannelType), + MagickSepiaToneImage(MagickWand *,const double), + MagickSetImage(MagickWand *,const MagickWand *), + MagickSetImageAlpha(MagickWand *,const double), + MagickSetImageAlphaChannel(MagickWand *,const AlphaChannelOption), + MagickSetImageBackgroundColor(MagickWand *,const PixelWand *), + MagickSetImageBluePrimary(MagickWand *,const double,const double, + const double), + MagickSetImageBorderColor(MagickWand *,const PixelWand *), + MagickSetImageColor(MagickWand *,const PixelWand *), + MagickSetImageColormapColor(MagickWand *,const size_t, + const PixelWand *), + MagickSetImageColorspace(MagickWand *,const ColorspaceType), + MagickSetImageCompose(MagickWand *,const CompositeOperator), + MagickSetImageCompression(MagickWand *,const CompressionType), + MagickSetImageDelay(MagickWand *,const size_t), + MagickSetImageDepth(MagickWand *,const size_t), + MagickSetImageDispose(MagickWand *,const DisposeType), + MagickSetImageCompressionQuality(MagickWand *,const size_t), + MagickSetImageEndian(MagickWand *,const EndianType), + MagickSetImageExtent(MagickWand *,const size_t,const size_t), + MagickSetImageFilename(MagickWand *,const char *), + MagickSetImageFormat(MagickWand *,const char *), + MagickSetImageFuzz(MagickWand *,const double), + MagickSetImageGamma(MagickWand *,const double), + MagickSetImageGravity(MagickWand *,const GravityType), + MagickSetImageGreenPrimary(MagickWand *,const double,const double, + const double), + MagickSetImageInterlaceScheme(MagickWand *,const InterlaceType), + MagickSetImageInterpolateMethod(MagickWand *,const PixelInterpolateMethod), + MagickSetImageIterations(MagickWand *,const size_t), + MagickSetImageMatte(MagickWand *,const MagickBooleanType), + MagickSetImageMatteColor(MagickWand *,const PixelWand *), + MagickSetImageOrientation(MagickWand *,const OrientationType), + MagickSetImagePage(MagickWand *,const size_t,const size_t,const ssize_t, + const ssize_t), + MagickSetImageRedPrimary(MagickWand *,const double,const double, + const double), + MagickSetImageRenderingIntent(MagickWand *,const RenderingIntent), + MagickSetImageResolution(MagickWand *,const double,const double), + MagickSetImageScene(MagickWand *,const size_t), + MagickSetImageTicksPerSecond(MagickWand *,const ssize_t), + MagickSetImageType(MagickWand *,const ImageType), + MagickSetImageUnits(MagickWand *,const ResolutionType), + MagickSetImageWhitePoint(MagickWand *,const double,const double, + const double), + MagickShadeImage(MagickWand *,const MagickBooleanType,const double, + const double), + MagickShadowImage(MagickWand *,const double,const double,const ssize_t, + const ssize_t), + MagickSharpenImage(MagickWand *,const double,const double), + MagickShaveImage(MagickWand *,const size_t,const size_t), + MagickShearImage(MagickWand *,const PixelWand *,const double,const double), + MagickSigmoidalContrastImage(MagickWand *,const MagickBooleanType, + const double,const double), + MagickSketchImage(MagickWand *,const double,const double,const double), + MagickSolarizeImage(MagickWand *,const double), + MagickSparseColorImage(MagickWand *,const SparseColorMethod,const size_t, + const double *), + MagickSpliceImage(MagickWand *,const size_t,const size_t,const ssize_t, + const ssize_t), + MagickSpreadImage(MagickWand *,const PixelInterpolateMethod,const double), + MagickStatisticImage(MagickWand *,const StatisticType,const size_t, + const size_t), + MagickStripImage(MagickWand *), + MagickSwirlImage(MagickWand *,const double,const PixelInterpolateMethod), + MagickTintImage(MagickWand *,const PixelWand *,const PixelWand *), + MagickTransformImageColorspace(MagickWand *,const ColorspaceType), + MagickTransposeImage(MagickWand *), + MagickTransverseImage(MagickWand *), + MagickThresholdImage(MagickWand *,const double), + MagickThresholdImageChannel(MagickWand *,const ChannelType,const double), + MagickThumbnailImage(MagickWand *,const size_t,const size_t), + MagickTrimImage(MagickWand *,const double), + MagickUniqueImageColors(MagickWand *), + MagickUnsharpMaskImage(MagickWand *,const double,const double,const double, + const double), + MagickVignetteImage(MagickWand *,const double,const double,const ssize_t, + const ssize_t), + MagickWaveImage(MagickWand *,const double,const double, + const PixelInterpolateMethod), + MagickWhiteThresholdImage(MagickWand *,const PixelWand *), + MagickWriteImage(MagickWand *,const char *), + MagickWriteImageFile(MagickWand *,FILE *), + MagickWriteImages(MagickWand *,const char *,const MagickBooleanType), + MagickWriteImagesFile(MagickWand *,FILE *); + +extern WandExport MagickProgressMonitor + MagickSetImageProgressMonitor(MagickWand *,const MagickProgressMonitor, + void *); + +extern WandExport MagickWand + *MagickAppendImages(MagickWand *,const MagickBooleanType), + *MagickChannelFxImage(MagickWand *,const char *), + *MagickCoalesceImages(MagickWand *), + *MagickCombineImages(MagickWand *,const ColorspaceType), + *MagickCompareImages(MagickWand *,const MagickWand *,const MetricType, + double *), + *MagickCompareImagesLayers(MagickWand *,const LayerMethod), + *MagickDeconstructImages(MagickWand *), + *MagickEvaluateImages(MagickWand *,const MagickEvaluateOperator), + *MagickFxImage(MagickWand *,const char *), + *MagickGetImage(MagickWand *), + *MagickGetImageMask(MagickWand *,const PixelMask), + *MagickGetImageRegion(MagickWand *,const size_t,const size_t,const ssize_t, + const ssize_t), + *MagickMergeImageLayers(MagickWand *,const LayerMethod), + *MagickMorphImages(MagickWand *,const size_t), + *MagickMontageImage(MagickWand *,const DrawingWand *,const char *, + const char *,const MontageMode,const char *), + *MagickOptimizeImageLayers(MagickWand *), + *MagickPreviewImages(MagickWand *wand,const PreviewType), + *MagickSimilarityImage(MagickWand *,const MagickWand *,const MetricType, + const double,RectangleInfo *,double *), + *MagickSmushImages(MagickWand *,const MagickBooleanType,const ssize_t), + *MagickSteganoImage(MagickWand *,const MagickWand *,const ssize_t), + *MagickStereoImage(MagickWand *,const MagickWand *), + *MagickTextureImage(MagickWand *,const MagickWand *); + +extern WandExport OrientationType + MagickGetImageOrientation(MagickWand *); + +extern WandExport PixelWand + **MagickGetImageHistogram(MagickWand *,size_t *); + +extern WandExport RenderingIntent + MagickGetImageRenderingIntent(MagickWand *); + +extern WandExport ResolutionType + MagickGetImageUnits(MagickWand *); + +extern WandExport size_t + MagickGetImageColors(MagickWand *), + MagickGetImageCompressionQuality(MagickWand *), + MagickGetImageDelay(MagickWand *), + MagickGetImageDepth(MagickWand *), + MagickGetImageHeight(MagickWand *), + MagickGetImageIterations(MagickWand *), + MagickGetImageScene(MagickWand *), + MagickGetImageTicksPerSecond(MagickWand *), + MagickGetImageWidth(MagickWand *), + MagickGetNumberImages(MagickWand *); + +extern WandExport unsigned char + *MagickGetImageBlob(MagickWand *,size_t *), + *MagickGetImagesBlob(MagickWand *,size_t *); + +extern WandExport VirtualPixelMethod + MagickGetImageVirtualPixelMethod(MagickWand *), + MagickSetImageVirtualPixelMethod(MagickWand *,const VirtualPixelMethod); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/magick-property.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/magick-property.h new file mode 100755 index 0000000..7d1f71b --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/magick-property.h @@ -0,0 +1,142 @@ +/* + 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. + + MagickWand property, options, and profile methods. +*/ + +#ifndef MAGICKWAND_MAGICK_PROPERTY_H +#define MAGICKWAND_MAGICK_PROPERTY_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern WandExport char + *MagickGetFilename(const MagickWand *), + *MagickGetFormat(MagickWand *), + *MagickGetFont(MagickWand *), + *MagickGetHomeURL(void), + *MagickGetImageArtifact(MagickWand *,const char *), + **MagickGetImageArtifacts(MagickWand *,const char *,size_t *), + **MagickGetImageProfiles(MagickWand *,const char *,size_t *), + *MagickGetImageProperty(MagickWand *,const char *), + **MagickGetImageProperties(MagickWand *,const char *,size_t *), + *MagickGetOption(MagickWand *,const char *), + **MagickGetOptions(MagickWand *,const char *,size_t *), + *MagickQueryConfigureOption(const char *), + **MagickQueryConfigureOptions(const char *,size_t *), + **MagickQueryFonts(const char *,size_t *), + **MagickQueryFormats(const char *,size_t *); + +extern WandExport ColorspaceType + MagickGetColorspace(MagickWand *); + +extern WandExport CompressionType + MagickGetCompression(MagickWand *); + +extern WandExport const char + *MagickGetCopyright(void), + *MagickGetPackageName(void), + *MagickGetQuantumDepth(size_t *), + *MagickGetQuantumRange(size_t *), + *MagickGetReleaseDate(void), + *MagickGetVersion(size_t *); + +extern WandExport double + MagickGetPointsize(MagickWand *), + *MagickGetSamplingFactors(MagickWand *,size_t *), + *MagickQueryFontMetrics(MagickWand *,const DrawingWand *,const char *), + *MagickQueryMultilineFontMetrics(MagickWand *,const DrawingWand *, + const char *); + +extern WandExport GravityType + MagickGetGravity(MagickWand *); + +extern WandExport ImageType + MagickGetType(MagickWand *); + +extern WandExport InterlaceType + MagickGetInterlaceScheme(MagickWand *); + +extern WandExport PixelInterpolateMethod + MagickGetInterpolateMethod(MagickWand *); + +extern WandExport OrientationType + MagickGetOrientation(MagickWand *); + +extern WandExport MagickBooleanType + MagickDeleteImageArtifact(MagickWand *,const char *), + MagickDeleteImageProperty(MagickWand *,const char *), + MagickDeleteOption(MagickWand *,const char *), + MagickGetAntialias(const MagickWand *), + MagickGetPage(const MagickWand *,size_t *,size_t *,ssize_t *,ssize_t *), + MagickGetResolution(const MagickWand *,double *,double *), + MagickGetSize(const MagickWand *,size_t *,size_t *), + MagickGetSizeOffset(const MagickWand *,ssize_t *), + MagickProfileImage(MagickWand *,const char *,const void *,const size_t), + MagickSetAntialias(MagickWand *,const MagickBooleanType), + MagickSetBackgroundColor(MagickWand *,const PixelWand *), + MagickSetColorspace(MagickWand *,const ColorspaceType), + MagickSetCompression(MagickWand *,const CompressionType), + MagickSetCompressionQuality(MagickWand *,const size_t), + MagickSetDepth(MagickWand *,const size_t), + MagickSetExtract(MagickWand *,const char *), + MagickSetFilename(MagickWand *,const char *), + MagickSetFormat(MagickWand *,const char *), + MagickSetFont(MagickWand *,const char *), + MagickSetGravity(MagickWand *,const GravityType), + MagickSetImageArtifact(MagickWand *,const char *,const char *), + MagickSetImageProfile(MagickWand *,const char *,const void *,const size_t), + MagickSetImageProperty(MagickWand *,const char *,const char *), + MagickSetInterlaceScheme(MagickWand *,const InterlaceType), + MagickSetInterpolateMethod(MagickWand *,const PixelInterpolateMethod), + MagickSetOption(MagickWand *,const char *,const char *), + MagickSetOrientation(MagickWand *,const OrientationType), + MagickSetPage(MagickWand *,const size_t,const size_t,const ssize_t, + const ssize_t), + MagickSetPassphrase(MagickWand *,const char *), + MagickSetPointsize(MagickWand *,const double), + MagickSetResolution(MagickWand *,const double,const double), + MagickSetResourceLimit(const ResourceType type,const MagickSizeType limit), + MagickSetSamplingFactors(MagickWand *,const size_t,const double *), + MagickSetSize(MagickWand *,const size_t,const size_t), + MagickSetSizeOffset(MagickWand *,const size_t,const size_t,const ssize_t), + MagickSetType(MagickWand *,const ImageType); + +extern WandExport MagickProgressMonitor + MagickSetProgressMonitor(MagickWand *,const MagickProgressMonitor,void *); + +extern WandExport MagickSizeType + MagickGetResource(const ResourceType), + MagickGetResourceLimit(const ResourceType); + +extern WandExport PixelWand + *MagickGetBackgroundColor(MagickWand *); + +extern WandExport OrientationType + MagickGetOrientationType(MagickWand *); + +extern WandExport size_t + MagickGetCompressionQuality(MagickWand *); + +extern WandExport unsigned char + *MagickGetImageProfile(MagickWand *,const char *,size_t *), + *MagickRemoveImageProfile(MagickWand *,const char *,size_t *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/method-attribute.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/method-attribute.h new file mode 100755 index 0000000..074ec3e --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/method-attribute.h @@ -0,0 +1,139 @@ +/* + 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. + + MagickWand method attributes. +*/ +#ifndef MAGICKWAND_METHOD_ATTRIBUTE_H +#define MAGICKWAND_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(MAGICKWAND_WINDOWS_SUPPORT) && !defined(__CYGWIN__) +# define WandPrivate +# if defined(_MT) && defined(_DLL) && !defined(_MAGICKDLL_) && !defined(_LIB) +# define _MAGICKDLL_ +# endif +# if defined(_MAGICKDLL_) +# if defined(_VISUALC_) +# pragma warning( disable: 4273 ) /* Disable the dll linkage warnings */ +# endif +# if !defined(_MAGICKLIB_) +# if defined(__clang__) || defined(__GNUC__) +# define WandExport __attribute__ ((dllimport)) +# else +# define WandExport __declspec(dllimport) +# endif +# if defined(_VISUALC_) +# pragma message( "MagickCore lib DLL import interface" ) +# endif +# else +# if defined(__clang__) || defined(__GNUC__) +# define WandExport __attribute__ ((dllexport)) +# else +# define WandExport __declspec(dllexport) +# endif +# if defined(_VISUALC_) +# pragma message( "MagickCore lib DLL export interface" ) +# endif +# endif +# else +# define WandExport +# if defined(_VISUALC_) +# pragma message( "MagickCore lib static interface" ) +# endif +# endif + +# if defined(_DLL) && !defined(_LIB) +# if defined(_VISUALC_) +# pragma message( "MagickCore module DLL export interface" ) +# endif +# else +# 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 WandExport __attribute__ ((visibility ("default"))) +# define WandPrivate __attribute__ ((visibility ("hidden"))) +# else +# define WandExport +# define WandPrivate +# endif +#endif + +#define MagickWandSignature 0xabacadabUL +#if !defined(MagickPathExtent) +# define MagickPathExtent 4096 +#endif + +#if defined(MAGICKCORE_HAVE___ATTRIBUTE__) +# define wand_aligned(x) __attribute__((aligned(x))) +# define wand_attribute __attribute__ +# define wand_unused(x) wand_unused_ ## x __attribute__((unused)) +# define wand_unreferenced(x) /* nothing */ +#elif defined(MAGICKWAND_WINDOWS_SUPPORT) && !defined(__CYGWIN__) +# define wand_aligned(x) __declspec(align(x)) +# define wand_attribute(x) /* nothing */ +# define wand_unused(x) x +# define wand_unreferenced(x) (x) +#else +# define wand_aligned(x) /* nothing */ +# define wand_attribute(x) /* nothing */ +# define wand_unused(x) x +# define wand_unreferenced(x) /* nothing */ +#endif + +#if !defined(__clang__) && (((__GNUC__) > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3))) +# define wand_alloc_size(x) __attribute__((__alloc_size__(x))) +# define wand_alloc_sizes(x,y) __attribute__((__alloc_size__(x,y))) +#else +# define wand_alloc_size(x) /* nothing */ +# define wand_alloc_sizes(x,y) /* nothing */ +#endif + +#if defined(__clang__) || (((__GNUC__) > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3))) +# define wand_cold_spot __attribute__((__cold__)) +# define wand_hot_spot __attribute__((__hot__)) +#else +# define wand_cold_spot +# define wand_hot_spot +#endif + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/mogrify.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/mogrify.h new file mode 100755 index 0000000..39dc494 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/mogrify.h @@ -0,0 +1,43 @@ +/* + 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. + + MagickWand mogrify command-line method. +*/ +#ifndef MAGICKWAND_MOGRIFY_H +#define MAGICKWAND_MOGRIFY_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +typedef MagickBooleanType + (*MagickCommand)(ImageInfo *,int,char **,char **,ExceptionInfo *); + +extern WandExport MagickBooleanType + MagickCommandGenesis(ImageInfo *,MagickCommand,int,char **,char **, + ExceptionInfo *), + MogrifyImage(ImageInfo *,const int,const char **,Image **,ExceptionInfo *), + MogrifyImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *), + MogrifyImageInfo(ImageInfo *,const int,const char **,ExceptionInfo *), + MogrifyImageList(ImageInfo *,const int,const char **,Image **, + ExceptionInfo *), + MogrifyImages(ImageInfo *,const MagickBooleanType,const int,const char **, + Image **,ExceptionInfo *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/montage.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/montage.h new file mode 100755 index 0000000..c7df5ec --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/montage.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. + + MagickWand montage command-line method. +*/ +#ifndef MAGICKWAND_MONTAGE_H +#define MAGICKWAND_MONTAGE_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern WandExport MagickBooleanType + MontageImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/operation.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/operation.h new file mode 100755 index 0000000..3fb4e52 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/operation.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. + + MagickWand command-line option process. +*/ +#ifndef MAGICKWAND_OPERATION_H +#define MAGICKWAND_OPERATION_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern WandExport void + CLIOption(MagickCLI *,const char *,...); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/pixel-iterator.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/pixel-iterator.h new file mode 100755 index 0000000..b1e6098 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/pixel-iterator.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. + + Pixel Iterator Methods. +*/ +#ifndef MAGICKWAND_PIXEL_ITERATOR_H +#define MAGICKWAND_PIXEL_ITERATOR_H + +#include "MagickWand/MagickWand.h" +#include "MagickWand/pixel-wand.h" + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +typedef struct _PixelIterator + PixelIterator; + +extern WandExport char + *PixelGetIteratorException(const PixelIterator *,ExceptionType *); + +extern WandExport ExceptionType + PixelGetIteratorExceptionType(const PixelIterator *); + +extern WandExport MagickBooleanType + IsPixelIterator(const PixelIterator *), + PixelClearIteratorException(PixelIterator *), + PixelSetIteratorRow(PixelIterator *,const ssize_t), + PixelSyncIterator(PixelIterator *); + +extern WandExport PixelIterator + *ClonePixelIterator(const PixelIterator *), + *DestroyPixelIterator(PixelIterator *), + *NewPixelIterator(MagickWand *), + *NewPixelRegionIterator(MagickWand *,const ssize_t,const ssize_t,const size_t, + const size_t); + +extern WandExport PixelWand + **PixelGetCurrentIteratorRow(PixelIterator *,size_t *), + **PixelGetNextIteratorRow(PixelIterator *,size_t *), + **PixelGetPreviousIteratorRow(PixelIterator *,size_t *); + +extern WandExport ssize_t + PixelGetIteratorRow(PixelIterator *); + +extern WandExport void + ClearPixelIterator(PixelIterator *), + PixelResetIterator(PixelIterator *), + PixelSetFirstIteratorRow(PixelIterator *), + PixelSetLastIteratorRow(PixelIterator *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/pixel-wand.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/pixel-wand.h new file mode 100755 index 0000000..945b8c0 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/pixel-wand.h @@ -0,0 +1,117 @@ +/* + 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. + + MagickWand pixel wand methods. +*/ +#ifndef MAGICKWAND_PIXEL_WAND_H +#define MAGICKWAND_PIXEL_WAND_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +typedef struct _PixelWand + PixelWand; + +extern WandExport char + *PixelGetColorAsNormalizedString(const PixelWand *), + *PixelGetColorAsString(const PixelWand *), + *PixelGetException(const PixelWand *,ExceptionType *); + +extern WandExport double + PixelGetAlpha(const PixelWand *), + PixelGetBlack(const PixelWand *), + PixelGetBlue(const PixelWand *), + PixelGetCyan(const PixelWand *), + PixelGetFuzz(const PixelWand *), + PixelGetGreen(const PixelWand *), + PixelGetMagenta(const PixelWand *), + PixelGetAlpha(const PixelWand *), + PixelGetRed(const PixelWand *), + PixelGetYellow(const PixelWand *); + +extern WandExport ExceptionType + PixelGetExceptionType(const PixelWand *); + +extern WandExport MagickBooleanType + IsPixelWand(const PixelWand *), + IsPixelWandSimilar(PixelWand *,PixelWand *,const double), + PixelClearException(PixelWand *), + PixelSetColor(PixelWand *,const char *); + +extern WandExport PixelInfo + PixelGetPixel(const PixelWand *); + +extern WandExport PixelWand + *ClonePixelWand(const PixelWand *), + **ClonePixelWands(const PixelWand **,const size_t), + *DestroyPixelWand(PixelWand *), + **DestroyPixelWands(PixelWand **,const size_t), + *NewPixelWand(void), + **NewPixelWands(const size_t); + +extern WandExport Quantum + PixelGetAlphaQuantum(const PixelWand *), + PixelGetBlackQuantum(const PixelWand *), + PixelGetBlueQuantum(const PixelWand *), + PixelGetCyanQuantum(const PixelWand *), + PixelGetGreenQuantum(const PixelWand *), + PixelGetIndex(const PixelWand *), + PixelGetMagentaQuantum(const PixelWand *), + PixelGetAlphaQuantum(const PixelWand *), + PixelGetRedQuantum(const PixelWand *), + PixelGetYellowQuantum(const PixelWand *); + +extern WandExport size_t + PixelGetColorCount(const PixelWand *); + +extern WandExport void + ClearPixelWand(PixelWand *), + PixelGetHSL(const PixelWand *,double *,double *,double *), + PixelGetMagickColor(const PixelWand *,PixelInfo *), + PixelGetQuantumPacket(const PixelWand *,PixelInfo *), + PixelGetQuantumPixel(const Image *,const PixelWand *,Quantum *), + PixelSetAlpha(PixelWand *,const double), + PixelSetAlphaQuantum(PixelWand *,const Quantum), + PixelSetBlack(PixelWand *,const double), + PixelSetBlackQuantum(PixelWand *,const Quantum), + PixelSetBlue(PixelWand *,const double), + PixelSetBlueQuantum(PixelWand *,const Quantum), + PixelSetColorFromWand(PixelWand *,const PixelWand *), + PixelSetColorCount(PixelWand *,const size_t), + PixelSetCyan(PixelWand *,const double), + PixelSetCyanQuantum(PixelWand *,const Quantum), + PixelSetFuzz(PixelWand *,const double), + PixelSetGreen(PixelWand *,const double), + PixelSetGreenQuantum(PixelWand *,const Quantum), + PixelSetHSL(PixelWand *,const double,const double,const double), + PixelSetIndex(PixelWand *,const Quantum), + PixelSetMagenta(PixelWand *,const double), + PixelSetMagentaQuantum(PixelWand *,const Quantum), + PixelSetPixelColor(PixelWand *,const PixelInfo *), + PixelSetAlpha(PixelWand *,const double), + PixelSetAlphaQuantum(PixelWand *,const Quantum), + PixelSetPixelColor(PixelWand *,const PixelInfo *), + PixelSetQuantumPixel(const Image *,const Quantum *,PixelWand *), + PixelSetRed(PixelWand *,const double), + PixelSetRedQuantum(PixelWand *,const Quantum), + PixelSetYellow(PixelWand *,const double), + PixelSetYellowQuantum(PixelWand *,const Quantum); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/stream.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/stream.h new file mode 100755 index 0000000..81c0b6d --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/stream.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. + + MagickWand montage command-line method. +*/ +#ifndef MAGICKWAND_STREAM_H +#define MAGICKWAND_STREAM_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern WandExport MagickBooleanType + StreamImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/wand-view.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/wand-view.h new file mode 100755 index 0000000..6980294 --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/wand-view.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 CONDITTransferNS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + MagickWand wand view methods. +*/ +#ifndef MAGICKWAND_WAND_VIEW_H +#define MAGICKWAND_WAND_VIEW_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +typedef struct _WandView + WandView; + +typedef MagickBooleanType + (*DuplexTransferWandViewMethod)(const WandView *,const WandView *,WandView *, + const ssize_t,const int,void *), + (*GetWandViewMethod)(const WandView *,const ssize_t,const int,void *), + (*SetWandViewMethod)(WandView *,const ssize_t,const int,void *), + (*TransferWandViewMethod)(const WandView *,WandView *,const ssize_t, + const int,void *), + (*UpdateWandViewMethod)(WandView *,const ssize_t,const int,void *); + +extern WandExport char + *GetWandViewException(const WandView *,ExceptionType *); + +extern WandExport MagickBooleanType + DuplexTransferWandViewIterator(WandView *,WandView *,WandView *, + DuplexTransferWandViewMethod,void *), + GetWandViewIterator(WandView *,GetWandViewMethod,void *), + IsWandView(const WandView *), + SetWandViewIterator(WandView *,SetWandViewMethod,void *), + TransferWandViewIterator(WandView *,WandView *,TransferWandViewMethod,void *), + UpdateWandViewIterator(WandView *,UpdateWandViewMethod,void *); + +extern WandExport MagickWand + *GetWandViewWand(const WandView *); + +extern WandExport PixelWand + **GetWandViewPixels(const WandView *); + +extern WandExport RectangleInfo + GetWandViewExtent(const WandView *); + +extern WandExport void + SetWandViewDescription(WandView *,const char *), + SetWandViewThreads(WandView *,const size_t); + +extern WandExport WandView + *CloneWandView(const WandView *), + *DestroyWandView(WandView *), + *NewWandView(MagickWand *), + *NewWandViewExtent(MagickWand *,const ssize_t,const ssize_t,const size_t, + const size_t); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/include/ImageMagick-7/MagickWand/wandcli.h b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/wandcli.h new file mode 100755 index 0000000..a1a127e --- /dev/null +++ b/bin/7.0.5-5/include/ImageMagick-7/MagickWand/wandcli.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. + + MagickWand command-line option process. +*/ +#ifndef MAGICKWAND_WAND_CLI_H +#define MAGICKWAND_WAND_CLI_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +typedef struct _MagickCLI + MagickCLI; + +extern WandExport MagickCLI + *AcquireMagickCLI(ImageInfo *,ExceptionInfo *), + *DestroyMagickCLI(MagickCLI *); + +extern WandExport MagickBooleanType + CLICatchException(MagickCLI *,const MagickBooleanType), + CLILogEvent(MagickCLI *,const LogEventType,const char *,const char *, + const size_t, const char *,...) + magick_attribute((__format__ (__printf__,6,7))), + CLIThrowException(MagickCLI *,const char *,const char *,const size_t, + const ExceptionType,const char *,const char *,...) + magick_attribute((__format__ (__printf__,7,8))); + + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif diff --git a/bin/7.0.5-5/lib/ImageMagick-7.0.5/config-Q16HDRI/configure.xml b/bin/7.0.5-5/lib/ImageMagick-7.0.5/config-Q16HDRI/configure.xml new file mode 100755 index 0000000..06fcceb --- /dev/null +++ b/bin/7.0.5-5/lib/ImageMagick-7.0.5/config-Q16HDRI/configure.xml @@ -0,0 +1,46 @@ + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/bin/7.0.5-5/lib/libMagick++-7.Q16HDRI.a b/bin/7.0.5-5/lib/libMagick++-7.Q16HDRI.a new file mode 100755 index 0000000..ca64881 Binary files /dev/null and b/bin/7.0.5-5/lib/libMagick++-7.Q16HDRI.a differ diff --git a/bin/7.0.5-5/lib/libMagick++-7.Q16HDRI.la b/bin/7.0.5-5/lib/libMagick++-7.Q16HDRI.la new file mode 100755 index 0000000..71d2328 --- /dev/null +++ b/bin/7.0.5-5/lib/libMagick++-7.Q16HDRI.la @@ -0,0 +1,41 @@ +# libMagick++-7.Q16HDRI.la - a libtool library file +# Generated by libtool (GNU libtool) 2.4.6 +# +# Please DO NOT delete this file! +# It is necessary for linking the library. + +# The name that we can dlopen(3). +dlname='' + +# Names of this library. +library_names='' + +# The name of the static archive. +old_library='libMagick++-7.Q16HDRI.a' + +# Linker flags that cannot go in dependency_libs. +inherited_linker_flags=' -pthread' + +# Libraries that this one depends upon. +dependency_libs=' -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/fftw/.libs -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/fftw -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/jpeg/.libs -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/jpeg -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/png/.libs -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/png -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/tiff/libtiff/.libs -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/tiff/libtiff -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/webp -L/usr/local/Cellar/libpng/1.6.29/lib -L/usr/local/Cellar/fftw/3.3.6-pl2/lib -L/usr/local/Cellar/xz/5.2.3/lib /Users/johannespichler/Downloads/newTest/build/lib/libMagickWand-7.Q16HDRI.la /Users/johannespichler/Downloads/newTest/build/lib/libMagickCore-7.Q16HDRI.la /usr/local/lib/libjpeg.la /usr/local/lib/libpng16.la /usr/local/lib/libfftw3.la -lwebp -llzma -lbz2 -lxml2 -lz -lm' + +# Names of additional weak libraries provided by this library +weak_library_names='' + +# Version information for libMagick++-7.Q16HDRI. +current=2 +age=0 +revision=0 + +# Is this an already installed library? +installed=yes + +# Should we warn about portability when linking against -modules? +shouldnotlink=no + +# Files to dlopen/dlpreopen +dlopen='' +dlpreopen='' + +# Directory that this library needs to be installed in: +libdir='/Users/johannespichler/Downloads/newTest/build/lib' diff --git a/bin/7.0.5-5/lib/libMagickCore-7.Q16HDRI.a b/bin/7.0.5-5/lib/libMagickCore-7.Q16HDRI.a new file mode 100755 index 0000000..f8e47a5 Binary files /dev/null and b/bin/7.0.5-5/lib/libMagickCore-7.Q16HDRI.a differ diff --git a/bin/7.0.5-5/lib/libMagickCore-7.Q16HDRI.la b/bin/7.0.5-5/lib/libMagickCore-7.Q16HDRI.la new file mode 100755 index 0000000..9d96949 --- /dev/null +++ b/bin/7.0.5-5/lib/libMagickCore-7.Q16HDRI.la @@ -0,0 +1,41 @@ +# libMagickCore-7.Q16HDRI.la - a libtool library file +# Generated by libtool (GNU libtool) 2.4.6 +# +# Please DO NOT delete this file! +# It is necessary for linking the library. + +# The name that we can dlopen(3). +dlname='' + +# Names of this library. +library_names='' + +# The name of the static archive. +old_library='libMagickCore-7.Q16HDRI.a' + +# Linker flags that cannot go in dependency_libs. +inherited_linker_flags=' -pthread' + +# Libraries that this one depends upon. +dependency_libs=' -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/fftw/.libs -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/fftw -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/jpeg/.libs -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/jpeg -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/png/.libs -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/png -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/tiff/libtiff/.libs -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/tiff/libtiff -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/webp /usr/local/lib/libjpeg.la -L/usr/local/Cellar/libpng/1.6.29/lib /usr/local/lib/libpng16.la -L/usr/local/Cellar/fftw/3.3.6-pl2/lib /usr/local/lib/libfftw3.la -lwebp -L/usr/local/Cellar/xz/5.2.3/lib -llzma -lbz2 -lxml2 -lz -lm' + +# Names of additional weak libraries provided by this library +weak_library_names='' + +# Version information for libMagickCore-7.Q16HDRI. +current=2 +age=0 +revision=0 + +# Is this an already installed library? +installed=yes + +# Should we warn about portability when linking against -modules? +shouldnotlink=no + +# Files to dlopen/dlpreopen +dlopen='' +dlpreopen='' + +# Directory that this library needs to be installed in: +libdir='/Users/johannespichler/Downloads/newTest/build/lib' diff --git a/bin/7.0.5-5/lib/libMagickWand-7.Q16HDRI.a b/bin/7.0.5-5/lib/libMagickWand-7.Q16HDRI.a new file mode 100755 index 0000000..17de986 Binary files /dev/null and b/bin/7.0.5-5/lib/libMagickWand-7.Q16HDRI.a differ diff --git a/bin/7.0.5-5/lib/libMagickWand-7.Q16HDRI.la b/bin/7.0.5-5/lib/libMagickWand-7.Q16HDRI.la new file mode 100755 index 0000000..ab49c81 --- /dev/null +++ b/bin/7.0.5-5/lib/libMagickWand-7.Q16HDRI.la @@ -0,0 +1,41 @@ +# libMagickWand-7.Q16HDRI.la - a libtool library file +# Generated by libtool (GNU libtool) 2.4.6 +# +# Please DO NOT delete this file! +# It is necessary for linking the library. + +# The name that we can dlopen(3). +dlname='' + +# Names of this library. +library_names='' + +# The name of the static archive. +old_library='libMagickWand-7.Q16HDRI.a' + +# Linker flags that cannot go in dependency_libs. +inherited_linker_flags=' -pthread' + +# Libraries that this one depends upon. +dependency_libs=' -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/fftw/.libs -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/fftw -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/jpeg/.libs -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/jpeg -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/png/.libs -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/png -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/tiff/libtiff/.libs -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/tiff/libtiff -L/Users/johannespichler/Downloads/newTest/ImageMagick-7.0.5-5/webp /Users/johannespichler/Downloads/newTest/build/lib/libMagickCore-7.Q16HDRI.la -L/usr/local/Cellar/libpng/1.6.29/lib -L/usr/local/Cellar/fftw/3.3.6-pl2/lib -L/usr/local/Cellar/xz/5.2.3/lib /usr/local/lib/libjpeg.la /usr/local/lib/libpng16.la /usr/local/lib/libfftw3.la -lwebp -llzma -lbz2 -lxml2 -lz -lm' + +# Names of additional weak libraries provided by this library +weak_library_names='' + +# Version information for libMagickWand-7.Q16HDRI. +current=0 +age=0 +revision=0 + +# Is this an already installed library? +installed=yes + +# Should we warn about portability when linking against -modules? +shouldnotlink=no + +# Files to dlopen/dlpreopen +dlopen='' +dlpreopen='' + +# Directory that this library needs to be installed in: +libdir='/Users/johannespichler/Downloads/newTest/build/lib' diff --git a/bin/7.0.5-5/lib/liblzma.5.dylib b/bin/7.0.5-5/lib/liblzma.5.dylib new file mode 100755 index 0000000..ac3dabf Binary files /dev/null and b/bin/7.0.5-5/lib/liblzma.5.dylib differ diff --git a/bin/7.0.5-5/lib/liblzma.a b/bin/7.0.5-5/lib/liblzma.a new file mode 100755 index 0000000..1a609a2 Binary files /dev/null and b/bin/7.0.5-5/lib/liblzma.a differ diff --git a/bin/7.0.5-5/lib/liblzma.dylib b/bin/7.0.5-5/lib/liblzma.dylib new file mode 120000 index 0000000..ef65a98 --- /dev/null +++ b/bin/7.0.5-5/lib/liblzma.dylib @@ -0,0 +1 @@ +liblzma.5.dylib \ No newline at end of file diff --git a/bin/7.0.5-5/lib/libtiff.5.dylib b/bin/7.0.5-5/lib/libtiff.5.dylib new file mode 100755 index 0000000..0e37200 Binary files /dev/null and b/bin/7.0.5-5/lib/libtiff.5.dylib differ diff --git a/bin/7.0.5-5/lib/libtiff.a b/bin/7.0.5-5/lib/libtiff.a new file mode 100755 index 0000000..9e30b36 Binary files /dev/null and b/bin/7.0.5-5/lib/libtiff.a differ diff --git a/bin/7.0.5-5/lib/libtiff.dylib b/bin/7.0.5-5/lib/libtiff.dylib new file mode 120000 index 0000000..683845c --- /dev/null +++ b/bin/7.0.5-5/lib/libtiff.dylib @@ -0,0 +1 @@ +libtiff.5.dylib \ No newline at end of file diff --git a/bin/7.0.5-5/lib/libtiffxx.5.dylib b/bin/7.0.5-5/lib/libtiffxx.5.dylib new file mode 100755 index 0000000..7b7ad54 Binary files /dev/null and b/bin/7.0.5-5/lib/libtiffxx.5.dylib differ diff --git a/bin/7.0.5-5/lib/libtiffxx.a b/bin/7.0.5-5/lib/libtiffxx.a new file mode 100755 index 0000000..81ff2c9 Binary files /dev/null and b/bin/7.0.5-5/lib/libtiffxx.a differ diff --git a/bin/7.0.5-5/lib/libtiffxx.dylib b/bin/7.0.5-5/lib/libtiffxx.dylib new file mode 120000 index 0000000..bd09c26 --- /dev/null +++ b/bin/7.0.5-5/lib/libtiffxx.dylib @@ -0,0 +1 @@ +libtiffxx.5.dylib \ No newline at end of file diff --git a/bin/7.0.5-5/lib/libwebp.7.dylib b/bin/7.0.5-5/lib/libwebp.7.dylib new file mode 100755 index 0000000..8dadacc Binary files /dev/null and b/bin/7.0.5-5/lib/libwebp.7.dylib differ diff --git a/bin/7.0.5-5/lib/libwebp.a b/bin/7.0.5-5/lib/libwebp.a new file mode 100755 index 0000000..74ae1cf Binary files /dev/null and b/bin/7.0.5-5/lib/libwebp.a differ diff --git a/bin/7.0.5-5/lib/libwebp.dylib b/bin/7.0.5-5/lib/libwebp.dylib new file mode 120000 index 0000000..13b8c1e --- /dev/null +++ b/bin/7.0.5-5/lib/libwebp.dylib @@ -0,0 +1 @@ +libwebp.7.dylib \ No newline at end of file diff --git a/bin/7.0.5-5/lib/libwebpdecoder.3.dylib b/bin/7.0.5-5/lib/libwebpdecoder.3.dylib new file mode 100755 index 0000000..2d9efb8 Binary files /dev/null and b/bin/7.0.5-5/lib/libwebpdecoder.3.dylib differ diff --git a/bin/7.0.5-5/lib/libwebpdecoder.a b/bin/7.0.5-5/lib/libwebpdecoder.a new file mode 100755 index 0000000..0f4a358 Binary files /dev/null and b/bin/7.0.5-5/lib/libwebpdecoder.a differ diff --git a/bin/7.0.5-5/lib/libwebpdecoder.dylib b/bin/7.0.5-5/lib/libwebpdecoder.dylib new file mode 120000 index 0000000..64a2ae6 --- /dev/null +++ b/bin/7.0.5-5/lib/libwebpdecoder.dylib @@ -0,0 +1 @@ +libwebpdecoder.3.dylib \ No newline at end of file diff --git a/bin/7.0.5-5/lib/libwebpdemux.2.dylib b/bin/7.0.5-5/lib/libwebpdemux.2.dylib new file mode 100755 index 0000000..6cc3dbf Binary files /dev/null and b/bin/7.0.5-5/lib/libwebpdemux.2.dylib differ diff --git a/bin/7.0.5-5/lib/libwebpdemux.a b/bin/7.0.5-5/lib/libwebpdemux.a new file mode 100755 index 0000000..b6563d8 Binary files /dev/null and b/bin/7.0.5-5/lib/libwebpdemux.a differ diff --git a/bin/7.0.5-5/lib/libwebpdemux.dylib b/bin/7.0.5-5/lib/libwebpdemux.dylib new file mode 120000 index 0000000..9edf6d3 --- /dev/null +++ b/bin/7.0.5-5/lib/libwebpdemux.dylib @@ -0,0 +1 @@ +libwebpdemux.2.dylib \ No newline at end of file diff --git a/bin/7.0.5-5/lib/libwebpmux.3.dylib b/bin/7.0.5-5/lib/libwebpmux.3.dylib new file mode 100755 index 0000000..ed71674 Binary files /dev/null and b/bin/7.0.5-5/lib/libwebpmux.3.dylib differ diff --git a/bin/7.0.5-5/lib/libwebpmux.a b/bin/7.0.5-5/lib/libwebpmux.a new file mode 100755 index 0000000..dbd3f10 Binary files /dev/null and b/bin/7.0.5-5/lib/libwebpmux.a differ diff --git a/bin/7.0.5-5/lib/libwebpmux.dylib b/bin/7.0.5-5/lib/libwebpmux.dylib new file mode 120000 index 0000000..d641d92 --- /dev/null +++ b/bin/7.0.5-5/lib/libwebpmux.dylib @@ -0,0 +1 @@ +libwebpmux.3.dylib \ No newline at end of file diff --git a/bin/7.0.5-5/lib/pkgconfig/ImageMagick-7.Q16HDRI.pc b/bin/7.0.5-5/lib/pkgconfig/ImageMagick-7.Q16HDRI.pc new file mode 100755 index 0000000..4f3e838 --- /dev/null +++ b/bin/7.0.5-5/lib/pkgconfig/ImageMagick-7.Q16HDRI.pc @@ -0,0 +1,14 @@ +prefix=/Users/johannespichler/Downloads/newTest/build +exec_prefix=${prefix} +libdir=${exec_prefix}/lib +includedir=${prefix}/include/ImageMagick-7 +includearchdir=/Users/johannespichler/Downloads/newTest/build/include/ImageMagick-7 +libname=MagickCore-7.Q16HDRI + +Name: ImageMagick +Description: ImageMagick - convert, edit, and compose images (ABI Q16HDRI) +URL: https://www.imagemagick.org +Version: 7.0.5 +Cflags: -I${includearchdir} -I${includedir} -DMAGICKCORE_HDRI_ENABLE=1 -DMAGICKCORE_QUANTUM_DEPTH=16 +Libs: -L${libdir} -l${libname} +Libs.private: -L${libdir} -l${libname} -ljpeg -L/usr/local/Cellar/libpng/1.6.29/lib -lpng16 -L/usr/local/Cellar/fftw/3.3.6-pl2/lib -lfftw3 -lwebp -L/usr/local/Cellar/xz/5.2.3/lib -llzma -lbz2 -lxml2 -lz -lm -lm diff --git a/bin/7.0.5-5/lib/pkgconfig/ImageMagick.pc b/bin/7.0.5-5/lib/pkgconfig/ImageMagick.pc new file mode 100755 index 0000000..4f3e838 --- /dev/null +++ b/bin/7.0.5-5/lib/pkgconfig/ImageMagick.pc @@ -0,0 +1,14 @@ +prefix=/Users/johannespichler/Downloads/newTest/build +exec_prefix=${prefix} +libdir=${exec_prefix}/lib +includedir=${prefix}/include/ImageMagick-7 +includearchdir=/Users/johannespichler/Downloads/newTest/build/include/ImageMagick-7 +libname=MagickCore-7.Q16HDRI + +Name: ImageMagick +Description: ImageMagick - convert, edit, and compose images (ABI Q16HDRI) +URL: https://www.imagemagick.org +Version: 7.0.5 +Cflags: -I${includearchdir} -I${includedir} -DMAGICKCORE_HDRI_ENABLE=1 -DMAGICKCORE_QUANTUM_DEPTH=16 +Libs: -L${libdir} -l${libname} +Libs.private: -L${libdir} -l${libname} -ljpeg -L/usr/local/Cellar/libpng/1.6.29/lib -lpng16 -L/usr/local/Cellar/fftw/3.3.6-pl2/lib -lfftw3 -lwebp -L/usr/local/Cellar/xz/5.2.3/lib -llzma -lbz2 -lxml2 -lz -lm -lm diff --git a/bin/7.0.5-5/lib/pkgconfig/Magick++-7.Q16HDRI.pc b/bin/7.0.5-5/lib/pkgconfig/Magick++-7.Q16HDRI.pc new file mode 100755 index 0000000..242e4fe --- /dev/null +++ b/bin/7.0.5-5/lib/pkgconfig/Magick++-7.Q16HDRI.pc @@ -0,0 +1,14 @@ +prefix=/Users/johannespichler/Downloads/newTest/build +exec_prefix=${prefix} +libdir=${exec_prefix}/lib +includedir=${prefix}/include/ImageMagick-7 +includearchdir=/Users/johannespichler/Downloads/newTest/build/include/ImageMagick-7 +libname=Magick++-7.Q16HDRI + +Name: Magick++ +Description: Magick++ - C++ API for ImageMagick (ABI Q16HDRI) +Version: 7.0.5 +Requires: MagickWand +Libs: -L${libdir} -l${libname} +Libs.private: -L${libdir} -l${libname} -lm +Cflags: -I${includearchdir} -I${includedir} -DMAGICKCORE_HDRI_ENABLE=1 -DMAGICKCORE_QUANTUM_DEPTH=16 diff --git a/bin/7.0.5-5/lib/pkgconfig/Magick++.pc b/bin/7.0.5-5/lib/pkgconfig/Magick++.pc new file mode 100755 index 0000000..242e4fe --- /dev/null +++ b/bin/7.0.5-5/lib/pkgconfig/Magick++.pc @@ -0,0 +1,14 @@ +prefix=/Users/johannespichler/Downloads/newTest/build +exec_prefix=${prefix} +libdir=${exec_prefix}/lib +includedir=${prefix}/include/ImageMagick-7 +includearchdir=/Users/johannespichler/Downloads/newTest/build/include/ImageMagick-7 +libname=Magick++-7.Q16HDRI + +Name: Magick++ +Description: Magick++ - C++ API for ImageMagick (ABI Q16HDRI) +Version: 7.0.5 +Requires: MagickWand +Libs: -L${libdir} -l${libname} +Libs.private: -L${libdir} -l${libname} -lm +Cflags: -I${includearchdir} -I${includedir} -DMAGICKCORE_HDRI_ENABLE=1 -DMAGICKCORE_QUANTUM_DEPTH=16 diff --git a/bin/7.0.5-5/lib/pkgconfig/MagickCore-7.Q16HDRI.pc b/bin/7.0.5-5/lib/pkgconfig/MagickCore-7.Q16HDRI.pc new file mode 100755 index 0000000..cb089a4 --- /dev/null +++ b/bin/7.0.5-5/lib/pkgconfig/MagickCore-7.Q16HDRI.pc @@ -0,0 +1,15 @@ +prefix=/Users/johannespichler/Downloads/newTest/build +exec_prefix=${prefix} +libdir=${exec_prefix}/lib +includedir=${prefix}/include/ImageMagick-7 +includearchdir=/Users/johannespichler/Downloads/newTest/build/include/ImageMagick-7 +libname=MagickCore-7.Q16HDRI +moduledir=${exec_prefix}/lib/ImageMagick-7.0.5/modules-Q16HDRI + +Name: MagickCore +Description: MagickCore - C API for ImageMagick (ABI Q16HDRI) +URL: https://www.imagemagick.org +Version: 7.0.5 +Cflags: -I${includearchdir} -I${includedir} -DMAGICKCORE_HDRI_ENABLE=1 -DMAGICKCORE_QUANTUM_DEPTH=16 +Libs: -L${libdir} -l${libname} +Libs.private: -L${libdir} -l${libname} -ljpeg -L/usr/local/Cellar/libpng/1.6.29/lib -lpng16 -L/usr/local/Cellar/fftw/3.3.6-pl2/lib -lfftw3 -lwebp -L/usr/local/Cellar/xz/5.2.3/lib -llzma -lbz2 -lxml2 -lz -lm -lm diff --git a/bin/7.0.5-5/lib/pkgconfig/MagickCore.pc b/bin/7.0.5-5/lib/pkgconfig/MagickCore.pc new file mode 100755 index 0000000..cb089a4 --- /dev/null +++ b/bin/7.0.5-5/lib/pkgconfig/MagickCore.pc @@ -0,0 +1,15 @@ +prefix=/Users/johannespichler/Downloads/newTest/build +exec_prefix=${prefix} +libdir=${exec_prefix}/lib +includedir=${prefix}/include/ImageMagick-7 +includearchdir=/Users/johannespichler/Downloads/newTest/build/include/ImageMagick-7 +libname=MagickCore-7.Q16HDRI +moduledir=${exec_prefix}/lib/ImageMagick-7.0.5/modules-Q16HDRI + +Name: MagickCore +Description: MagickCore - C API for ImageMagick (ABI Q16HDRI) +URL: https://www.imagemagick.org +Version: 7.0.5 +Cflags: -I${includearchdir} -I${includedir} -DMAGICKCORE_HDRI_ENABLE=1 -DMAGICKCORE_QUANTUM_DEPTH=16 +Libs: -L${libdir} -l${libname} +Libs.private: -L${libdir} -l${libname} -ljpeg -L/usr/local/Cellar/libpng/1.6.29/lib -lpng16 -L/usr/local/Cellar/fftw/3.3.6-pl2/lib -lfftw3 -lwebp -L/usr/local/Cellar/xz/5.2.3/lib -llzma -lbz2 -lxml2 -lz -lm -lm diff --git a/bin/7.0.5-5/lib/pkgconfig/MagickWand-7.Q16HDRI.pc b/bin/7.0.5-5/lib/pkgconfig/MagickWand-7.Q16HDRI.pc new file mode 100755 index 0000000..472ab58 --- /dev/null +++ b/bin/7.0.5-5/lib/pkgconfig/MagickWand-7.Q16HDRI.pc @@ -0,0 +1,15 @@ +prefix=/Users/johannespichler/Downloads/newTest/build +exec_prefix=${prefix} +libdir=${exec_prefix}/lib +includedir=${prefix}/include/ImageMagick-7 +includearchdir=/Users/johannespichler/Downloads/newTest/build/include/ImageMagick-7 +libname=MagickWand-7.Q16HDRI + +Name: MagickWand +Description: MagickWand - C API for ImageMagick (ABI Q16HDRI) +URL: https://www.imagemagick.org +Version: 7.0.5 +Requires: MagickCore +Cflags: -I${includearchdir} -I${includedir} -DMAGICKCORE_HDRI_ENABLE=1 -DMAGICKCORE_QUANTUM_DEPTH=16 +Libs: -L${libdir} -l${libname} +Libs.private: -L${libdir} -l${libname} -ljpeg -L/usr/local/Cellar/libpng/1.6.29/lib -lpng16 -L/usr/local/Cellar/fftw/3.3.6-pl2/lib -lfftw3 -lwebp -L/usr/local/Cellar/xz/5.2.3/lib -llzma -lbz2 -lxml2 -lz -lm -lm diff --git a/bin/7.0.5-5/lib/pkgconfig/MagickWand.pc b/bin/7.0.5-5/lib/pkgconfig/MagickWand.pc new file mode 100755 index 0000000..472ab58 --- /dev/null +++ b/bin/7.0.5-5/lib/pkgconfig/MagickWand.pc @@ -0,0 +1,15 @@ +prefix=/Users/johannespichler/Downloads/newTest/build +exec_prefix=${prefix} +libdir=${exec_prefix}/lib +includedir=${prefix}/include/ImageMagick-7 +includearchdir=/Users/johannespichler/Downloads/newTest/build/include/ImageMagick-7 +libname=MagickWand-7.Q16HDRI + +Name: MagickWand +Description: MagickWand - C API for ImageMagick (ABI Q16HDRI) +URL: https://www.imagemagick.org +Version: 7.0.5 +Requires: MagickCore +Cflags: -I${includearchdir} -I${includedir} -DMAGICKCORE_HDRI_ENABLE=1 -DMAGICKCORE_QUANTUM_DEPTH=16 +Libs: -L${libdir} -l${libname} +Libs.private: -L${libdir} -l${libname} -ljpeg -L/usr/local/Cellar/libpng/1.6.29/lib -lpng16 -L/usr/local/Cellar/fftw/3.3.6-pl2/lib -lfftw3 -lwebp -L/usr/local/Cellar/xz/5.2.3/lib -llzma -lbz2 -lxml2 -lz -lm -lm diff --git a/bin/magick b/bin/magick new file mode 100755 index 0000000..dc03549 --- /dev/null +++ b/bin/magick @@ -0,0 +1,3 @@ +export MAGICK_HOME="./7.0.5-5/" +export DYLD_LIBRARY_PATH="./7.0.5-5/lib/" +./7.0.5-5/bin/magick $1