magick/widget.h 0000644 00000005103 14751151177 0007443 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore X11 widget methods.
*/
#ifndef MAGICKCORE_WIDGET_H
#define MAGICKCORE_WIDGET_H
#if defined(MAGICKCORE_X11_DELEGATE)
#include "magick/xwindow-private.h"
#endif
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if defined(MAGICKCORE_X11_DELEGATE)
extern MagickExport int
XCommandWidget(Display *,XWindows *,const char *const *,XEvent *),
XConfirmWidget(Display *,XWindows *,const char *,const char *),
XDialogWidget(Display *,XWindows *,const char *,const char *,char *),
XMenuWidget(Display *,XWindows *,const char *,const char *const *,char *);
extern MagickExport MagickBooleanType
XPreferencesWidget(Display *,XResourceInfo *,XWindows *);
extern MagickExport void
DestroyXWidget(void),
XColorBrowserWidget(Display *,XWindows *,const char *,char *),
XFileBrowserWidget(Display *,XWindows *,const char *,char *),
XFontBrowserWidget(Display *,XWindows *,const char *,char *),
XInfoWidget(Display *,XWindows *,const char *),
XListBrowserWidget(Display *,XWindows *,XWindowInfo *,const char *const *,
const char *,const char *,char *),
XNoticeWidget(Display *,XWindows *,const char *,const char *),
XProgressMonitorWidget(Display *,XWindows *,const char *,
const MagickOffsetType,const MagickSizeType),
XTextViewWidget(Display *,const XResourceInfo *,XWindows *,
const MagickBooleanType,const char *,const char **);
static inline void XTextViewHelp(Display *display,
const XResourceInfo *resource_info,XWindows *windows,
const MagickBooleanType mono,const char *title,const char *help)
{
char
**help_list;
ssize_t
i;
help_list=StringToList(help);
if (help_list == (char **) NULL)
return;
XTextViewWidget(display,resource_info,windows,mono,title,(const char **)
help_list);
for (i=0; help_list[i] != (char *) NULL; i++)
help_list[i]=DestroyString(help_list[i]);
help_list=(char **) RelinquishMagickMemory(help_list);
}
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/property.h 0000644 00000003130 14751151177 0010042 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore property methods.
*/
#ifndef MAGICKCORE_PROPERTY_H
#define MAGICKCORE_PROPERTY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport char
*GetNextImageProperty(const Image *),
*InterpretImageProperties(const ImageInfo *,Image *,const char *),
*RemoveImageProperty(Image *,const char *);
extern MagickExport const char
*GetImageProperty(const Image *,const char *),
*GetMagickProperty(const ImageInfo *,Image *,const char *);
extern MagickExport MagickBooleanType
CloneImageProperties(Image *,const Image *),
DefineImageProperty(Image *,const char *),
DeleteImageProperty(Image *,const char *),
FormatImageProperty(Image *,const char *,const char *,...)
magick_attribute((__format__ (__printf__,3,4))),
SetImageProperty(Image *,const char *,const char *);
extern MagickExport void
DestroyImageProperties(Image *),
ResetImagePropertyIterator(const Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/magic.h 0000644 00000003166 14751151177 0007247 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore magic methods.
*/
#ifndef MAGICKCORE_MAGIC_H
#define MAGICKCORE_MAGIC_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _MagicInfo
{
char
*path,
*name,
*target;
unsigned char
*magic;
size_t
length;
MagickOffsetType
offset;
MagickBooleanType
exempt,
stealth;
struct _MagicInfo
*previous,
*next; /* deprecated, use GetMagicInfoList() */
size_t
signature;
} MagicInfo;
extern MagickExport char
**GetMagicList(const char *,size_t *,ExceptionInfo *);
extern MagickExport const char
*GetMagicName(const MagicInfo *);
extern MagickExport MagickBooleanType
ListMagicInfo(FILE *,ExceptionInfo *),
MagicComponentGenesis(void);
extern MagickExport const MagicInfo
*GetMagicInfo(const unsigned char *,const size_t,ExceptionInfo *),
**GetMagicInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport void
MagicComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/compare.h 0000644 00000004040 14751151177 0007605 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image compare methods.
*/
#ifndef MAGICKCORE_COMPARE_H
#define MAGICKCORE_COMPARE_H
#include "magick/image.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedMetric,
AbsoluteErrorMetric,
MeanAbsoluteErrorMetric,
MeanErrorPerPixelMetric,
MeanSquaredErrorMetric,
PeakAbsoluteErrorMetric,
PeakSignalToNoiseRatioMetric,
RootMeanSquaredErrorMetric,
NormalizedCrossCorrelationErrorMetric,
FuzzErrorMetric,
UndefinedErrorMetric = 0,
PerceptualHashErrorMetric = 0xff
} MetricType;
extern MagickExport double
*GetImageChannelDistortions(Image *,const Image *,const MetricType,
ExceptionInfo *);
extern MagickExport Image
*CompareImageChannels(Image *,const Image *,const ChannelType,
const MetricType,double *,ExceptionInfo *),
*CompareImages(Image *,const Image *,const MetricType,double *,
ExceptionInfo *),
*SimilarityImage(Image *,const Image *,RectangleInfo *,double *,
ExceptionInfo *),
*SimilarityMetricImage(Image *,const Image *,const MetricType,
RectangleInfo *,double *,ExceptionInfo *);
extern MagickExport MagickBooleanType
GetImageChannelDistortion(Image *,const Image *,const ChannelType,
const MetricType,double *,ExceptionInfo *),
GetImageDistortion(Image *,const Image *,const MetricType,double *,
ExceptionInfo *),
IsImagesEqual(Image *,const Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/gem.h 0000644 00000005721 14751151177 0006736 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore private graphic gems methods.
*/
#ifndef MAGICKCORE_GEM_H
#define MAGICKCORE_GEM_H
#include "magick/random_.h"
#include "magick/visual-effects.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport double
ExpandAffine(const AffineMatrix *) magick_attribute((__pure__)),
GenerateDifferentialNoise(RandomInfo *,const Quantum,const NoiseType,
const MagickRealType);
extern MagickExport size_t
GetOptimalKernelWidth(const double,const double),
GetOptimalKernelWidth1D(const double,const double),
GetOptimalKernelWidth2D(const double,const double);
extern MagickExport void
ConvertHCLToRGB(const double,const double,const double,Quantum *,Quantum *,
Quantum *),
ConvertHCLpToRGB(const double,const double,const double,Quantum *,Quantum *,
Quantum *),
ConvertHSBToRGB(const double,const double,const double,Quantum *,Quantum *,
Quantum *),
ConvertHSIToRGB(const double,const double,const double,Quantum *,Quantum *,
Quantum *),
ConvertHSLToRGB(const double,const double,const double,Quantum *,Quantum *,
Quantum *),
ConvertHSVToRGB(const double,const double,const double,Quantum *,Quantum *,
Quantum *),
ConvertHWBToRGB(const double,const double,const double,Quantum *,Quantum *,
Quantum *),
ConvertLCHabToRGB(const double,const double,const double,Quantum *,Quantum *,
Quantum *),
ConvertLCHuvToRGB(const double,const double,const double,Quantum *,Quantum *,
Quantum *),
ConvertRGBToHCL(const Quantum,const Quantum,const Quantum,double *,double *,
double *),
ConvertRGBToHCLp(const Quantum,const Quantum,const Quantum,double *,double *,
double *),
ConvertRGBToHSB(const Quantum,const Quantum,const Quantum,double *,double *,
double *),
ConvertRGBToHSI(const Quantum,const Quantum,const Quantum,double *,double *,
double *),
ConvertRGBToHSL(const Quantum,const Quantum,const Quantum,double *,double *,
double *),
ConvertRGBToHSV(const Quantum,const Quantum,const Quantum,double *,double *,
double *),
ConvertRGBToHWB(const Quantum,const Quantum,const Quantum,double *,double *,
double *),
ConvertRGBToLCHab(const Quantum,const Quantum,const Quantum,double *,double *,
double *),
ConvertRGBToLCHuv(const Quantum,const Quantum,const Quantum,double *,double *,
double *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/monitor.h 0000644 00000003120 14751151177 0007644 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore progress monitor methods.
*/
#ifndef MAGICKCORE_MONITOR_H
#define MAGICKCORE_MONITOR_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef MagickBooleanType
(*MagickProgressMonitor)(const char *,const MagickOffsetType,
const MagickSizeType,void *);
MagickExport MagickBooleanType
SetImageProgress(const Image *,const char *,const MagickOffsetType,
const MagickSizeType);
MagickExport MagickProgressMonitor
SetImageProgressMonitor(Image *,const MagickProgressMonitor,void *),
SetImageInfoProgressMonitor(ImageInfo *,const MagickProgressMonitor,void *);
static inline MagickBooleanType QuantumTick(const MagickOffsetType offset,
const MagickSizeType span)
{
if (span <= 100)
return(MagickTrue);
if (offset == (MagickOffsetType) (span-1))
return(MagickTrue);
if ((offset % (MagickOffsetType) (span/100)) == 0)
return(MagickTrue);
return(MagickFalse);
}
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/annotate.h 0000644 00000002431 14751151177 0007772 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image annotation methods.
*/
#ifndef MAGICKCORE_ANNOTATE_H
#define MAGICKCORE_ANNOTATE_H
#include "magick/draw.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
AnnotateComponentGenesis(void),
AnnotateImage(Image *,const DrawInfo *),
GetMultilineTypeMetrics(Image *,const DrawInfo *,TypeMetric *),
GetTypeMetrics(Image *,const DrawInfo *,TypeMetric *);
extern MagickExport ssize_t
FormatMagickCaption(Image *,DrawInfo *,const MagickBooleanType,TypeMetric *,
char **);
extern MagickExport void
AnnotateComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/channel.h 0000644 00000003267 14751151177 0007601 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image channel methods.
*/
#ifndef MAGICKCORE_CHANNEL_H
#define MAGICKCORE_CHANNEL_H
#include "magick/image.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedAlphaChannel,
ActivateAlphaChannel,
BackgroundAlphaChannel,
CopyAlphaChannel,
DeactivateAlphaChannel,
ExtractAlphaChannel,
OpaqueAlphaChannel,
ResetAlphaChannel, /* deprecated */
SetAlphaChannel,
ShapeAlphaChannel,
TransparentAlphaChannel,
FlattenAlphaChannel,
RemoveAlphaChannel,
AssociateAlphaChannel,
DisassociateAlphaChannel,
OffIfOpaqueAlphaChannel
} AlphaChannelType;
extern MagickExport Image
*CombineImages(const Image *,const ChannelType,ExceptionInfo *),
*SeparateImage(const Image *,const ChannelType,ExceptionInfo *),
*SeparateImages(const Image *,const ChannelType,ExceptionInfo *);
extern MagickExport MagickBooleanType
GetImageAlphaChannel(const Image *),
SeparateImageChannel(Image *,const ChannelType),
SetImageAlphaChannel(Image *,const AlphaChannelType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/quantize.h 0000644 00000003704 14751151177 0010025 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image quantization methods.
*/
#ifndef MAGICKCORE_QUANTIZE_H
#define MAGICKCORE_QUANTIZE_H
#include "magick/colorspace.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedDitherMethod,
NoDitherMethod,
RiemersmaDitherMethod,
FloydSteinbergDitherMethod
} DitherMethod;
typedef struct _QuantizeInfo
{
size_t
number_colors;
size_t
tree_depth;
MagickBooleanType
dither;
ColorspaceType
colorspace;
MagickBooleanType
measure_error;
size_t
signature;
DitherMethod
dither_method;
} QuantizeInfo;
extern MagickExport MagickBooleanType
CompressImageColormap(Image *),
GetImageQuantizeError(Image *),
PosterizeImage(Image *,const size_t,const MagickBooleanType),
PosterizeImageChannel(Image *,const ChannelType,const size_t,
const MagickBooleanType),
QuantizeImage(const QuantizeInfo *,Image *),
QuantizeImages(const QuantizeInfo *,Image *),
RemapImage(const QuantizeInfo *,Image *,const Image *),
RemapImages(const QuantizeInfo *,Image *,const Image *);
extern MagickExport QuantizeInfo
*AcquireQuantizeInfo(const ImageInfo *),
*CloneQuantizeInfo(const QuantizeInfo *),
*DestroyQuantizeInfo(QuantizeInfo *);
extern MagickExport void
GetQuantizeInfo(QuantizeInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/blob.h 0000644 00000004636 14751151177 0007110 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore Binary Large OBjects methods.
*/
#ifndef MAGICKCORE_BLOB_H
#define MAGICKCORE_BLOB_H
#include "magick/image.h"
#include "magick/stream.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#define MagickMaxBufferExtent 81920
#define MagickMinBufferExtent 16384
typedef enum
{
ReadMode,
WriteMode,
IOMode,
PersistMode
} MapMode;
extern MagickExport FILE
*GetBlobFileHandle(const Image *) magick_attribute((__pure__));
extern MagickExport Image
*BlobToImage(const ImageInfo *,const void *,const size_t,ExceptionInfo *),
*PingBlob(const ImageInfo *,const void *,const size_t,ExceptionInfo *);
extern MagickExport MagickBooleanType
BlobToFile(char *,const void *,const size_t,ExceptionInfo *),
FileToImage(Image *,const char *),
GetBlobError(const Image *) magick_attribute((__pure__)),
ImageToFile(Image *,char *,ExceptionInfo *),
InjectImageBlob(const ImageInfo *,Image *,Image *,const char *,
ExceptionInfo *),
IsBlobExempt(const Image *) magick_attribute((__pure__)),
IsBlobSeekable(const Image *) magick_attribute((__pure__)),
IsBlobTemporary(const Image *) magick_attribute((__pure__));
extern MagickExport MagickSizeType
GetBlobSize(const Image *);
extern MagickExport StreamHandler
GetBlobStreamHandler(const Image *) magick_attribute((__pure__));
extern MagickExport unsigned char
*FileToBlob(const char *,const size_t,size_t *,ExceptionInfo *),
*GetBlobStreamData(const Image *) magick_attribute((__pure__)),
*ImageToBlob(const ImageInfo *,Image *,size_t *,ExceptionInfo *),
*ImagesToBlob(const ImageInfo *,Image *,size_t *,ExceptionInfo *);
extern MagickExport void
DestroyBlob(Image *),
DuplicateBlob(Image *,const Image *),
SetBlobExempt(Image *,const MagickBooleanType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/method-attribute.h 0000644 00000010173 14751151177 0011444 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore method attributes.
*/
#ifndef MAGICKCORE_METHOD_ATTRIBUTE_H
#define MAGICKCORE_METHOD_ATTRIBUTE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if defined(__BORLANDC__) && defined(_DLL)
# define _MAGICKDLL_
# define _MAGICKLIB_
# define MAGICKCORE_MODULES_SUPPORT
# undef MAGICKCORE_BUILD_MODULES
#endif
#if defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(__CYGWIN__)
# define MagickPrivate
# if defined(_MT) && defined(_DLL) && !defined(_MAGICKDLL_) && !defined(_LIB)
# define _MAGICKDLL_
# endif
# if defined(_MAGICKDLL_)
# if defined(_VISUALC_)
# pragma warning( disable: 4273 ) /* Disable the dll linkage warnings */
# endif
# if !defined(_MAGICKLIB_)
# if defined(__clang__) || defined(__GNUC__)
# define MagickExport __attribute__ ((dllimport))
# else
# define MagickExport __declspec(dllimport)
# endif
# else
# if defined(__clang__) || defined(__GNUC__)
# define MagickExport __attribute__ ((dllexport))
# else
# define MagickExport __declspec(dllexport)
# endif
# endif
# else
# define MagickExport
# endif
# if defined(_DLL) && !defined(_LIB)
# if defined(__clang__) || defined(__GNUC__)
# define ModuleExport __attribute__ ((dllexport))
# else
# define ModuleExport __declspec(dllexport)
# endif
# else
# define ModuleExport
# endif
# if defined(_VISUALC_)
# pragma warning(disable : 4018)
# pragma warning(disable : 4068)
# pragma warning(disable : 4244)
# pragma warning(disable : 4142)
# pragma warning(disable : 4800)
# pragma warning(disable : 4786)
# pragma warning(disable : 4996)
# endif
#else
# if defined(__clang__) || (__GNUC__ >= 4)
# define MagickExport __attribute__ ((visibility ("default")))
# define MagickPrivate __attribute__ ((visibility ("hidden")))
# else
# define MagickExport
# define MagickPrivate
# endif
# define ModuleExport MagickExport
#endif
#define MagickCoreSignature 0xabacadabUL
#define MagickSignature MagickCoreSignature
#if !defined(MaxTextExtent)
# define MaxTextExtent 4096 /* always >= max(4096,PATH_MAX) */
#endif
#define MagickTimeExtent 26
#if defined(MAGICKCORE_HAVE___ATTRIBUTE__)
# define magick_aligned(x,y) x __attribute__((aligned(y)))
# define magick_attribute __attribute__
# define magick_unused(x) magick_unused_ ## x __attribute__((unused))
# define magick_unreferenced(x) /* nothing */
#elif defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(__CYGWIN__)
# define magick_aligned(x,y) __declspec(align(y)) x
# define magick_attribute(x) /* nothing */
# define magick_unused(x) x
# define magick_unreferenced(x) (x)
#else
# define magick_aligned(x,y) /* nothing */
# define magick_attribute(x) /* nothing */
# define magick_unused(x) x
# define magick_unreferenced(x) /* nothing */
#endif
#if !defined(__clang__) && (defined(__GNUC__) && (__GNUC__) > 4)
# define magick_alloc_size(x) __attribute__((__alloc_size__(x)))
# define magick_alloc_sizes(x,y) __attribute__((__alloc_size__(x,y)))
# define magick_fallthrough __attribute__((fallthrough))
#else
# define magick_alloc_size(x) /* nothing */
# define magick_alloc_sizes(x,y) /* nothing */
# define magick_fallthrough /* nothing */
#endif
#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__) > 4)
# define magick_cold_spot __attribute__((__cold__))
# define magick_hot_spot __attribute__((__hot__))
#else
# define magick_cold_spot
# define magick_hot_spot
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/pixel.h 0000644 00000011301 14751151177 0007276 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image constitute methods.
*/
#ifndef MAGICKCORE_PIXEL_H
#define MAGICKCORE_PIXEL_H
#include "magick/colorspace.h"
#include "magick/constitute.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/*
Pixel enum declarations.
*/
typedef enum
{
UndefinedInterpolatePixel,
AverageInterpolatePixel, /* Average 4 nearest neighbours */
BicubicInterpolatePixel, /* Catmull-Rom interpolation */
BilinearInterpolatePixel, /* Triangular filter interpolation */
FilterInterpolatePixel, /* Use resize filter - (very slow) */
IntegerInterpolatePixel, /* Integer (floor) interpolation */
MeshInterpolatePixel, /* Triangular mesh interpolation */
NearestNeighborInterpolatePixel, /* Nearest neighbour only */
SplineInterpolatePixel, /* Cubic Spline (blurred) interpolation */
Average9InterpolatePixel, /* Average 9 nearest neighbours */
Average16InterpolatePixel, /* Average 16 nearest neighbours */
BlendInterpolatePixel, /* blend of nearest 1, 2 or 4 pixels */
BackgroundInterpolatePixel, /* just return background color */
CatromInterpolatePixel /* Catmull-Rom interpolation */
} InterpolatePixelMethod;
typedef enum
{
PixelRed = 0,
PixelCyan = 0,
PixelGray = 0,
PixelY = 0,
PixelGreen = 1,
PixelMagenta = 1,
PixelCb = 1,
PixelBlue = 2,
PixelYellow = 2,
PixelCr = 2,
PixelAlpha = 3,
PixelBlack = 4,
PixelIndex = 4,
MaskPixelComponent = 5
} PixelComponent;
typedef enum
{
UndefinedPixelIntensityMethod = 0,
AveragePixelIntensityMethod,
BrightnessPixelIntensityMethod,
LightnessPixelIntensityMethod,
Rec601LumaPixelIntensityMethod,
Rec601LuminancePixelIntensityMethod,
Rec709LumaPixelIntensityMethod,
Rec709LuminancePixelIntensityMethod,
RMSPixelIntensityMethod,
MSPixelIntensityMethod
} PixelIntensityMethod;
/*
Pixel typedef declarations.
*/
typedef struct _DoublePixelPacket
{
double
red,
green,
blue,
opacity,
index;
} DoublePixelPacket;
typedef struct _LongPixelPacket
{
unsigned int
red,
green,
blue,
opacity,
index;
} LongPixelPacket;
typedef struct _MagickPixelPacket
{
ClassType
storage_class;
ColorspaceType
colorspace;
MagickBooleanType
matte;
double
fuzz;
size_t
depth;
MagickRealType
red,
green,
blue,
opacity,
index;
} MagickPixelPacket;
typedef Quantum IndexPacket;
typedef struct _PixelPacket
{
#if defined(MAGICKCORE_WORDS_BIGENDIAN)
#define MAGICK_PIXEL_RGBA 1
Quantum
red,
green,
blue,
opacity;
#else
#define MAGICK_PIXEL_BGRA 1
Quantum
blue,
green,
red,
opacity;
#endif
} PixelPacket;
typedef struct _QuantumPixelPacket
{
Quantum
red,
green,
blue,
opacity,
index;
} QuantumPixelPacket;
typedef struct _CacheView
CacheView_;
/*
Pixel method declarations.
*/
extern MagickExport MagickBooleanType
ExportImagePixels(const Image *,const ssize_t,const ssize_t,const size_t,
const size_t,const char *,const StorageType,void *,ExceptionInfo *),
ImportImagePixels(Image *,const ssize_t,const ssize_t,const size_t,
const size_t,const char *,const StorageType,const void *),
InterpolateMagickPixelPacket(const Image *magick_restrict,const CacheView_ *,
const InterpolatePixelMethod,const double,const double,MagickPixelPacket *,
ExceptionInfo *);
extern MagickExport MagickPixelPacket
*CloneMagickPixelPacket(const MagickPixelPacket *);
extern MagickExport MagickRealType
DecodePixelGamma(const MagickRealType) magick_hot_spot,
EncodePixelGamma(const MagickRealType) magick_hot_spot,
GetMagickPixelIntensity(const Image *image,
const MagickPixelPacket *magick_restrict) magick_hot_spot,
GetPixelIntensity(const Image *image,const PixelPacket *magick_restrict)
magick_hot_spot;
extern MagickExport void
ConformMagickPixelPacket(Image *,const MagickPixelPacket *,
MagickPixelPacket *,ExceptionInfo *),
GetMagickPixelPacket(const Image *,MagickPixelPacket *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/delegate.h 0000644 00000004235 14751151177 0007737 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore delegates methods.
*/
#ifndef MAGICKCORE_DELEGATE_H
#define MAGICKCORE_DELEGATE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#include <stdarg.h>
#include "magick/semaphore.h"
typedef struct _DelegateInfo
{
char
*path,
*decode,
*encode,
*commands;
ssize_t
mode;
MagickBooleanType
thread_support,
spawn,
stealth;
struct _DelegateInfo
*previous,
*next; /* deprecated, use GetDelegateInfoList() */
size_t
signature;
SemaphoreInfo
*semaphore;
} DelegateInfo;
extern MagickExport char
*GetDelegateCommand(const ImageInfo *,Image *,const char *,const char *,
ExceptionInfo *),
**GetDelegateList(const char *,size_t *,ExceptionInfo *);
extern MagickExport const char
*GetDelegateCommands(const DelegateInfo *);
extern MagickExport const DelegateInfo
*GetDelegateInfo(const char *,const char *,ExceptionInfo *exception),
**GetDelegateInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport int
ExternalDelegateCommand(const MagickBooleanType,const MagickBooleanType,
const char *,char *,ExceptionInfo *);
extern MagickExport ssize_t
GetDelegateMode(const DelegateInfo *);
extern MagickExport MagickBooleanType
DelegateComponentGenesis(void),
GetDelegateThreadSupport(const DelegateInfo *),
InvokeDelegate(ImageInfo *,Image *,const char *,const char *,ExceptionInfo *),
ListDelegateInfo(FILE *,ExceptionInfo *);
extern MagickExport void
DelegateComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/version.h 0000644 00000000267 14751151177 0007653 0 ustar 00 #include <bits/wordsize.h>
#if __WORDSIZE == 32
# include "version-32.h"
#elif __WORDSIZE == 64
# include "version-64.h"
#else
# error "unexpected value for __WORDSIZE macro"
#endif
magick/vision.h 0000644 00000001670 14751151177 0007474 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore computer vision methods.
*/
#ifndef MAGICKCORE_VISION_H
#define MAGICKCORE_VISION_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport Image
*ConnectedComponentsImage(const Image *,const size_t,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/shear.h 0000644 00000002155 14751151177 0007266 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image stream methods.
*/
#ifndef MAGICKCORE_SHEAR_H
#define MAGICKCORE_SHEAR_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport Image
*DeskewImage(const Image *,const double,ExceptionInfo *),
*IntegralRotateImage(const Image *,size_t,ExceptionInfo *),
*ShearImage(const Image *,const double,const double,ExceptionInfo *),
*ShearRotateImage(const Image *,const double,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/coder.h 0000644 00000003150 14751151177 0007254 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image coder methods.
*/
#ifndef MAGICKCORE_CODER_H
#define MAGICKCORE_CODER_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _CoderInfo
{
char
*path,
*magick,
*name;
MagickBooleanType
exempt,
stealth;
struct _CoderInfo
*previous,
*next; /* deprecated, use GetCoderInfoList() */
size_t
signature;
} CoderInfo;
extern MagickExport char
**GetCoderList(const char *,size_t *,ExceptionInfo *);
extern MagickExport const CoderInfo
*GetCoderInfo(const char *,ExceptionInfo *),
**GetCoderInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport MagickBooleanType
CoderComponentGenesis(void),
ListCoderInfo(FILE *,ExceptionInfo *);
MagickExport void
CoderComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/hashmap.h 0000644 00000005534 14751151177 0007611 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore hash methods.
*/
#ifndef MAGICKCORE_HASHMAP_H
#define MAGICKCORE_HASHMAP_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#define SmallHashmapSize 17
#define MediumHashmapSize 509
#define LargeHashmapSize 8191
#define HugeHashmapSize 131071
typedef struct _HashmapInfo
HashmapInfo;
typedef struct _LinkedListInfo
LinkedListInfo;
extern MagickExport HashmapInfo
*DestroyHashmap(HashmapInfo *),
*NewHashmap(const size_t,size_t (*)(const void *),MagickBooleanType (*)
(const void *,const void *),void *(*)(void *),void *(*)(void *));
extern MagickExport LinkedListInfo
*DestroyLinkedList(LinkedListInfo *,void *(*)(void *)),
*NewLinkedList(const size_t);
extern MagickExport MagickBooleanType
AppendValueToLinkedList(LinkedListInfo *,const void *),
CompareHashmapString(const void *,const void *),
CompareHashmapStringInfo(const void *,const void *),
InsertValueInLinkedList(LinkedListInfo *,const size_t,const void *),
InsertValueInSortedLinkedList(LinkedListInfo *,
int (*)(const void *,const void *),void **,const void *),
IsHashmapEmpty(const HashmapInfo *),
IsLinkedListEmpty(const LinkedListInfo *),
LinkedListToArray(LinkedListInfo *,void **),
PutEntryInHashmap(HashmapInfo *,const void *,const void *);
extern MagickExport size_t
GetNumberOfElementsInLinkedList(const LinkedListInfo *),
GetNumberOfEntriesInHashmap(const HashmapInfo *),
HashPointerType(const void *),
HashStringType(const void *),
HashStringInfoType(const void *);
extern MagickExport void
ClearLinkedList(LinkedListInfo *,void *(*)(void *)),
*GetLastValueInLinkedList(LinkedListInfo *),
*GetNextKeyInHashmap(HashmapInfo *),
*GetNextValueInHashmap(HashmapInfo *),
*GetNextValueInLinkedList(LinkedListInfo *),
*GetValueFromHashmap(HashmapInfo *,const void *),
*GetValueFromLinkedList(LinkedListInfo *,const size_t),
*RemoveElementByValueFromLinkedList(LinkedListInfo *,const void *),
*RemoveElementFromLinkedList(LinkedListInfo *,const size_t),
*RemoveEntryFromHashmap(HashmapInfo *,const void *),
*RemoveLastElementFromLinkedList(LinkedListInfo *),
ResetHashmapIterator(HashmapInfo *),
ResetLinkedListIterator(LinkedListInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/signature.h 0000644 00000001636 14751151177 0010170 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore digital signature methods.
*/
#ifndef MAGICKCORE_SIGNATURE_H
#define MAGICKCORE_SIGNATURE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
SignatureImage(Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/transform.h 0000644 00000003634 14751151177 0010202 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image transform methods.
*/
#ifndef MAGICKCORE_TRANSFORM_H
#define MAGICKCORE_TRANSFORM_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport Image
*AutoOrientImage(const Image *,const OrientationType,ExceptionInfo *),
*ChopImage(const Image *,const RectangleInfo *,ExceptionInfo *),
*ConsolidateCMYKImages(const Image *,ExceptionInfo *),
*CropImage(const Image *,const RectangleInfo *,ExceptionInfo *),
*CropImageToTiles(const Image *,const char *, ExceptionInfo *),
*ExcerptImage(const Image *,const RectangleInfo *,ExceptionInfo *),
*ExtentImage(const Image *,const RectangleInfo *,ExceptionInfo *),
*FlipImage(const Image *,ExceptionInfo *),
*FlopImage(const Image *,ExceptionInfo *),
*RollImage(const Image *,const ssize_t,const ssize_t,ExceptionInfo *),
*ShaveImage(const Image *,const RectangleInfo *,ExceptionInfo *),
*SpliceImage(const Image *,const RectangleInfo *,ExceptionInfo *),
*TransposeImage(const Image *,ExceptionInfo *),
*TransverseImage(const Image *,ExceptionInfo *),
*TrimImage(const Image *,ExceptionInfo *);
extern MagickExport MagickBooleanType
TransformImage(Image **,const char *,const char *),
TransformImages(Image **,const char *,const char *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/stream.h 0000644 00000002130 14751151177 0007450 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image stream methods.
*/
#ifndef MAGICKCORE_STREAM_H
#define MAGICKCORE_STREAM_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef size_t
(*StreamHandler)(const Image *,const void *,const size_t);
extern MagickExport Image
*ReadStream(const ImageInfo *,StreamHandler,ExceptionInfo *);
extern MagickExport MagickBooleanType
WriteStream(const ImageInfo *,Image *,StreamHandler);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/visual-effects.h 0000644 00000005437 14751151177 0011112 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image visual effects methods.
*/
#ifndef MAGICKCORE_VISUAL_EFFECTS_H
#define MAGICKCORE_VISUAL_EFFECTS_H
#include "magick/draw.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedNoise,
UniformNoise,
GaussianNoise,
MultiplicativeGaussianNoise,
ImpulseNoise,
LaplacianNoise,
PoissonNoise,
RandomNoise
} NoiseType;
extern MagickExport Image
*AddNoiseImage(const Image *,const NoiseType,ExceptionInfo *),
*AddNoiseImageChannel(const Image *,const ChannelType,const NoiseType,
ExceptionInfo *),
*BlueShiftImage(const Image *,const double,ExceptionInfo *),
*CharcoalImage(const Image *,const double,const double,ExceptionInfo *),
*ColorizeImage(const Image *,const char *,const PixelPacket,ExceptionInfo *),
*ColorMatrixImage(const Image *,const KernelInfo *kernel,ExceptionInfo *),
*ImplodeImage(const Image *,const double,ExceptionInfo *),
*MorphImages(const Image *,const size_t,ExceptionInfo *),
*PolaroidImage(const Image *,const DrawInfo *,const double,ExceptionInfo *),
*SepiaToneImage(const Image *,const double,ExceptionInfo *),
*ShadowImage(const Image *,const double,const double,const ssize_t,
const ssize_t,ExceptionInfo *),
*SketchImage(const Image *,const double,const double,const double,
ExceptionInfo *),
*SteganoImage(const Image *,const Image *,ExceptionInfo *),
*StereoImage(const Image *,const Image *,ExceptionInfo *),
*StereoAnaglyphImage(const Image *,const Image *,const ssize_t,const ssize_t,
ExceptionInfo *),
*SwirlImage(const Image *,double,ExceptionInfo *),
*TintImage(const Image *,const char *,const PixelPacket,ExceptionInfo *),
*VignetteImage(const Image *,const double,const double,const ssize_t,
const ssize_t,ExceptionInfo *),
*WaveImage(const Image *,const double,const double,ExceptionInfo *),
*WaveletDenoiseImage(const Image *,const double,const double,ExceptionInfo *);
extern MagickExport MagickBooleanType
PlasmaImage(Image *,const SegmentInfo *,size_t,size_t),
SolarizeImage(Image *,const double),
SolarizeImageChannel(Image *,const ChannelType,const double,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/static.h 0000644 00000024014 14751151177 0007451 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore static coder registration methods.
*/
#ifndef MAGICKCORE_STATIC_H
#define MAGICKCORE_STATIC_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
InvokeStaticImageFilter(const char *,Image **,const int,const char **,
ExceptionInfo *),
RegisterStaticModule(const char *,ExceptionInfo *exception),
UnregisterStaticModule(const char *);
extern ModuleExport size_t
RegisterAAIImage(void),
RegisterARTImage(void),
RegisterAVIImage(void),
RegisterAVSImage(void),
RegisterBIEImage(void),
RegisterBGRImage(void),
RegisterBMPImage(void),
RegisterBRAILLEImage(void),
RegisterCALSImage(void),
RegisterCAPTIONImage(void),
RegisterCINImage(void),
RegisterCIPImage(void),
RegisterCLIPImage(void),
RegisterCLIPBOARDImage(void),
RegisterCMYKImage(void),
RegisterCUTImage(void),
RegisterDCMImage(void),
RegisterDCXImage(void),
RegisterDDSImage(void),
RegisterDEBUGImage(void),
RegisterDIBImage(void),
RegisterDJVUImage(void),
RegisterDNGImage(void),
RegisterDOTImage(void),
RegisterDPSImage(void),
RegisterDPXImage(void),
RegisterEMFImage(void),
RegisterEPDFImage(void),
RegisterEPIImage(void),
RegisterEPSImage(void),
RegisterEPS2Image(void),
RegisterEPSFImage(void),
RegisterEPSIImage(void),
RegisterEPTImage(void),
RegisterEXRImage(void),
RegisterFAXImage(void),
RegisterFITSImage(void),
RegisterFLIFImage(void),
RegisterFPXImage(void),
RegisterG3Image(void),
RegisterGIFImage(void),
RegisterGIF87Image(void),
RegisterGRADIENTImage(void),
RegisterGRANITEImage(void),
RegisterGRAYImage(void),
RegisterHALDImage(void),
RegisterHDRImage(void),
RegisterHEICImage(void),
RegisterHImage(void),
RegisterHISTOGRAMImage(void),
RegisterHRZImage(void),
RegisterHTMLImage(void),
RegisterICBImage(void),
RegisterICONImage(void),
RegisterINFOImage(void),
RegisterINLINEImage(void),
RegisterIPLImage(void),
RegisterJBGImage(void),
RegisterJBIGImage(void),
RegisterJNXImage(void),
RegisterJPEGImage(void),
RegisterJP2Image(void),
RegisterJSONImage(void),
RegisterLABELImage(void),
RegisterMACImage(void),
RegisterMAGICKImage(void),
RegisterMAPImage(void),
RegisterMASKImage(void),
RegisterMATImage(void),
RegisterMATTEImage(void),
RegisterMETAImage(void),
RegisterMIFFImage(void),
RegisterMNGImage(void),
RegisterMONOImage(void),
RegisterMPCImage(void),
RegisterMPRImage(void),
RegisterMSLImage(void),
RegisterMTVImage(void),
RegisterMVGImage(void),
RegisterNETSCAPEImage(void),
RegisterNULLImage(void),
RegisterP7Image(void),
RegisterPBMImage(void),
RegisterOTBImage(void),
RegisterPALMImage(void),
RegisterPANGOImage(void),
RegisterPATTERNImage(void),
RegisterPCDImage(void),
RegisterPCDSImage(void),
RegisterPCLImage(void),
RegisterPCTImage(void),
RegisterPCXImage(void),
RegisterPDBImage(void),
RegisterPDFImage(void),
RegisterPESImage(void),
RegisterPGXImage(void),
RegisterPICImage(void),
RegisterPICTImage(void),
RegisterPIXImage(void),
RegisterPGMImage(void),
RegisterPLASMAImage(void),
RegisterPMImage(void),
RegisterPNGImage(void),
RegisterPNMImage(void),
RegisterPPMImage(void),
RegisterPREVIEWImage(void),
RegisterPSImage(void),
RegisterPS2Image(void),
RegisterPS3Image(void),
RegisterPSDImage(void),
RegisterPTIFImage(void),
RegisterPWPImage(void),
RegisterRASImage(void),
RegisterRAWImage(void),
RegisterRGBImage(void),
RegisterRGBAImage(void),
RegisterRGFImage(void),
RegisterRLAImage(void),
RegisterRLEImage(void),
RegisterSCRImage(void),
RegisterSCREENSHOTImage(void),
RegisterSCTImage(void),
RegisterSFWImage(void),
RegisterSGIImage(void),
RegisterSHTMLImage(void),
RegisterSIXELImage(void),
RegisterSTEGANOImage(void),
RegisterSUNImage(void),
RegisterSVGImage(void),
RegisterTEXTImage(void),
RegisterTGAImage(void),
RegisterTHUMBNAILImage(void),
RegisterTIFImage(void),
RegisterTIFFImage(void),
RegisterTILEImage(void),
RegisterTIMImage(void),
RegisterTTFImage(void),
RegisterTXTImage(void),
RegisterUILImage(void),
RegisterURLImage(void),
RegisterUYVYImage(void),
RegisterVDAImage(void),
RegisterVICARImage(void),
RegisterVIDImage(void),
RegisterVIDEOImage(void),
RegisterVIFFImage(void),
RegisterVIPSImage(void),
RegisterVSTImage(void),
RegisterWBMPImage(void),
RegisterWEBPImage(void),
RegisterWMFImage(void),
RegisterWPGImage(void),
RegisterXImage(void),
RegisterXBMImage(void),
RegisterXCImage(void),
RegisterXCFImage(void),
RegisterXPMImage(void),
RegisterXPSImage(void),
RegisterXVImage(void),
RegisterXWDImage(void),
RegisterYCBCRImage(void),
RegisterYUVImage(void);
extern ModuleExport void
UnregisterAAIImage(void),
UnregisterARTImage(void),
UnregisterAVIImage(void),
UnregisterAVSImage(void),
UnregisterBIEImage(void),
UnregisterBGRImage(void),
UnregisterBMPImage(void),
UnregisterBRAILLEImage(void),
UnregisterCALSImage(void),
UnregisterCAPTIONImage(void),
UnregisterCINImage(void),
UnregisterCIPImage(void),
UnregisterCLIPImage(void),
UnregisterCLIPBOARDImage(void),
UnregisterCMYKImage(void),
UnregisterCUTImage(void),
UnregisterDCMImage(void),
UnregisterDCXImage(void),
UnregisterDDSImage(void),
UnregisterDEBUGImage(void),
UnregisterDIBImage(void),
UnregisterDJVUImage(void),
UnregisterDNGImage(void),
UnregisterDOTImage(void),
UnregisterDPSImage(void),
UnregisterDPXImage(void),
UnregisterEMFImage(void),
UnregisterEPDFImage(void),
UnregisterEPIImage(void),
UnregisterEPSImage(void),
UnregisterEPS2Image(void),
UnregisterEPSFImage(void),
UnregisterEPSIImage(void),
UnregisterEPTImage(void),
UnregisterEXRImage(void),
UnregisterFAXImage(void),
UnregisterFITSImage(void),
UnregisterFLIFImage(void),
UnregisterFPXImage(void),
UnregisterG3Image(void),
UnregisterGIFImage(void),
UnregisterGIF87Image(void),
UnregisterGRADIENTImage(void),
UnregisterGRANITEImage(void),
UnregisterGRAYImage(void),
UnregisterHALDImage(void),
UnregisterHDRImage(void),
UnregisterHEICImage(void),
UnregisterHImage(void),
UnregisterHISTOGRAMImage(void),
UnregisterHRZImage(void),
UnregisterHTMLImage(void),
UnregisterICBImage(void),
UnregisterICONImage(void),
UnregisterINFOImage(void),
UnregisterINLINEImage(void),
UnregisterIPLImage(void),
UnregisterJBGImage(void),
UnregisterJBIGImage(void),
UnregisterJNXImage(void),
UnregisterJPEGImage(void),
UnregisterJP2Image(void),
UnregisterJSONImage(void),
UnregisterLABELImage(void),
UnregisterLOCALEImage(void),
UnregisterMACImage(void),
UnregisterMAGICKImage(void),
UnregisterMAPImage(void),
UnregisterMASKImage(void),
UnregisterMATImage(void),
UnregisterMATTEImage(void),
UnregisterMETAImage(void),
UnregisterMIFFImage(void),
UnregisterMNGImage(void),
UnregisterMONOImage(void),
UnregisterMPCImage(void),
UnregisterMPRImage(void),
UnregisterMSLImage(void),
UnregisterMTVImage(void),
UnregisterMVGImage(void),
UnregisterNETSCAPEImage(void),
UnregisterNULLImage(void),
UnregisterP7Image(void),
UnregisterPBMImage(void),
UnregisterOTBImage(void),
UnregisterPALMImage(void),
UnregisterPANGOImage(void),
UnregisterPATTERNImage(void),
UnregisterPCDImage(void),
UnregisterPCDSImage(void),
UnregisterPCLImage(void),
UnregisterPCTImage(void),
UnregisterPCXImage(void),
UnregisterPDBImage(void),
UnregisterPDFImage(void),
UnregisterPESImage(void),
UnregisterPGXImage(void),
UnregisterPICImage(void),
UnregisterPICTImage(void),
UnregisterPIXImage(void),
UnregisterPLASMAImage(void),
UnregisterPGMImage(void),
UnregisterPMImage(void),
UnregisterPNGImage(void),
UnregisterPNMImage(void),
UnregisterPPMImage(void),
UnregisterPREVIEWImage(void),
UnregisterPSImage(void),
UnregisterPS2Image(void),
UnregisterPS3Image(void),
UnregisterPSDImage(void),
UnregisterPTIFImage(void),
UnregisterPWPImage(void),
UnregisterRASImage(void),
UnregisterRAWImage(void),
UnregisterRGBImage(void),
UnregisterRGBAImage(void),
UnregisterRGFImage(void),
UnregisterRLAImage(void),
UnregisterRLEImage(void),
UnregisterSCRImage(void),
UnregisterSCREENSHOTImage(void),
UnregisterSCTImage(void),
UnregisterSFWImage(void),
UnregisterSGIImage(void),
UnregisterSHTMLImage(void),
UnregisterSIXELImage(void),
UnregisterSTEGANOImage(void),
UnregisterSUNImage(void),
UnregisterSVGImage(void),
UnregisterTEXTImage(void),
UnregisterTGAImage(void),
UnregisterTHUMBNAILImage(void),
UnregisterTIFImage(void),
UnregisterTIFFImage(void),
UnregisterTILEImage(void),
UnregisterTIMImage(void),
UnregisterTTFImage(void),
UnregisterTXTImage(void),
UnregisterUILImage(void),
UnregisterURLImage(void),
UnregisterUYVYImage(void),
UnregisterVDAImage(void),
UnregisterVICARImage(void),
UnregisterVIDImage(void),
UnregisterVIDEOImage(void),
UnregisterVIFFImage(void),
UnregisterVIPSImage(void),
UnregisterVSTImage(void),
UnregisterWBMPImage(void),
UnregisterWEBPImage(void),
UnregisterWMFImage(void),
UnregisterWPGImage(void),
UnregisterXImage(void),
UnregisterXBMImage(void),
UnregisterXCImage(void),
UnregisterXCFImage(void),
UnregisterXPMImage(void),
UnregisterXPSImage(void),
UnregisterXVImage(void),
UnregisterXWDImage(void),
UnregisterYCBCRImage(void),
UnregisterYUVImage(void);
extern MagickExport void
RegisterStaticModules(void),
UnregisterStaticModules(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/registry.h 0000644 00000002740 14751151177 0010034 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore registry methods.
*/
#ifndef MAGICKCORE_REGISTRY_H
#define MAGICKCORE_REGISTRY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedRegistryType,
ImageRegistryType,
ImageInfoRegistryType,
StringRegistryType
} RegistryType;
extern MagickExport char
*GetNextImageRegistry(void);
extern MagickExport MagickBooleanType
DefineImageRegistry(const RegistryType,const char *,ExceptionInfo *),
DeleteImageRegistry(const char *),
RegistryComponentGenesis(void),
SetImageRegistry(const RegistryType,const char *,const void *,
ExceptionInfo *);
extern MagickExport void
*GetImageRegistry(const RegistryType,const char *,ExceptionInfo *),
RegistryComponentTerminus(void),
*RemoveImageRegistry(const char *),
ResetImageRegistryIterator(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/cache.h 0000644 00000005505 14751151177 0007231 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore cache methods.
*/
#ifndef MAGICKCORE_CACHE_H
#define MAGICKCORE_CACHE_H
#include "magick/blob.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedCache,
MemoryCache,
MapCache,
DiskCache,
PingCache,
DistributedCache
} CacheType;
extern MagickExport CacheType
GetImagePixelCacheType(const Image *);
extern MagickExport const char
*GetPixelCacheFilename(const Image *);
extern MagickExport const IndexPacket
*GetVirtualIndexQueue(const Image *);
extern MagickExport const PixelPacket
*GetVirtualPixels(const Image *,const ssize_t,const ssize_t,const size_t,
const size_t,ExceptionInfo *),
*GetVirtualPixelQueue(const Image *);
extern MagickExport const void
*AcquirePixelCachePixels(const Image *,MagickSizeType *,ExceptionInfo *);
extern MagickExport IndexPacket
*GetAuthenticIndexQueue(const Image *);
extern MagickExport MagickBooleanType
CacheComponentGenesis(void),
GetOneVirtualMagickPixel(const Image *,const ssize_t,const ssize_t,
MagickPixelPacket *,ExceptionInfo *),
GetOneVirtualPixel(const Image *,const ssize_t,const ssize_t,PixelPacket *,
ExceptionInfo *),
GetOneVirtualMethodPixel(const Image *,const VirtualPixelMethod,const ssize_t,
const ssize_t,PixelPacket *,ExceptionInfo *),
GetOneAuthenticPixel(Image *,const ssize_t,const ssize_t,PixelPacket *,
ExceptionInfo *),
PersistPixelCache(Image *,const char *,const MagickBooleanType,
MagickOffsetType *,ExceptionInfo *),
SyncAuthenticPixels(Image *,ExceptionInfo *);
extern MagickExport MagickSizeType
GetImageExtent(const Image *);
extern MagickExport PixelPacket
*GetAuthenticPixels(Image *,const ssize_t,const ssize_t,const size_t,
const size_t,ExceptionInfo *),
*GetAuthenticPixelQueue(const Image *),
*QueueAuthenticPixels(Image *,const ssize_t,const ssize_t,const size_t,
const size_t,ExceptionInfo *);
extern MagickExport VirtualPixelMethod
GetPixelCacheVirtualMethod(const Image *),
SetPixelCacheVirtualMethod(const Image *,const VirtualPixelMethod);
extern MagickExport void
CacheComponentTerminus(void),
*GetPixelCachePixels(Image *,MagickSizeType *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/xml-tree.h 0000644 00000004126 14751151177 0007721 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Magick's toolkit xml-tree methods.
*/
#ifndef MAGICKCORE_XML_TREE_H
#define MAGICKCORE_XML_TREE_H
#include "magick/exception.h"
#include "magick/splay-tree.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _XMLTreeInfo
XMLTreeInfo;
extern MagickExport char
*CanonicalXMLContent(const char *,const MagickBooleanType),
*XMLTreeInfoToXML(XMLTreeInfo *);
extern MagickExport const char
*GetXMLTreeAttribute(XMLTreeInfo *,const char *),
*GetXMLTreeContent(XMLTreeInfo *),
**GetXMLTreeProcessingInstructions(XMLTreeInfo *,const char *),
*GetXMLTreeTag(XMLTreeInfo *);
extern MagickExport MagickBooleanType
GetXMLTreeAttributes(const XMLTreeInfo *,SplayTreeInfo *);
extern MagickExport XMLTreeInfo
*AddChildToXMLTree(XMLTreeInfo *,const char *,const size_t),
*AddPathToXMLTree(XMLTreeInfo *,const char *,const size_t),
*DestroyXMLTree(XMLTreeInfo *),
*GetNextXMLTreeTag(XMLTreeInfo *),
*GetXMLTreeChild(XMLTreeInfo *,const char *),
*GetXMLTreeOrdered(XMLTreeInfo *),
*GetXMLTreePath(XMLTreeInfo *,const char *),
*GetXMLTreeSibling(XMLTreeInfo *),
*InsertTagIntoXMLTree(XMLTreeInfo *,XMLTreeInfo *,const size_t),
*NewXMLTree(const char *,ExceptionInfo *),
*NewXMLTreeTag(const char *),
*ParseTagFromXMLTree(XMLTreeInfo *),
*PruneTagFromXMLTree(XMLTreeInfo *),
*SetXMLTreeAttribute(XMLTreeInfo *,const char *,const char *),
*SetXMLTreeContent(XMLTreeInfo *,const char *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/option.h 0000644 00000012446 14751151177 0007500 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore option methods.
*/
#ifndef MAGICKCORE_OPTION_H
#define MAGICKCORE_OPTION_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
MagickUndefinedOptions = -1,
MagickAlignOptions = 0,
MagickAlphaOptions,
MagickBooleanOptions,
MagickCacheOptions,
MagickChannelOptions,
MagickClassOptions,
MagickClipPathOptions,
MagickCoderOptions,
MagickColorOptions,
MagickColorspaceOptions,
MagickCommandOptions,
MagickComposeOptions,
MagickCompressOptions,
MagickConfigureOptions,
MagickDataTypeOptions,
MagickDebugOptions,
MagickDecorateOptions,
MagickDelegateOptions,
MagickDirectionOptions,
MagickDisposeOptions,
MagickDistortOptions,
MagickDitherOptions,
MagickEndianOptions,
MagickEvaluateOptions,
MagickFillRuleOptions,
MagickFilterOptions,
MagickFontOptions,
MagickFontsOptions,
MagickFormatOptions,
MagickFunctionOptions,
MagickGravityOptions,
MagickIntentOptions,
MagickInterlaceOptions,
MagickInterpolateOptions,
MagickKernelOptions,
MagickLayerOptions,
MagickLineCapOptions,
MagickLineJoinOptions,
MagickListOptions,
MagickLocaleOptions,
MagickLogEventOptions,
MagickLogOptions,
MagickMagicOptions,
MagickMethodOptions,
MagickMetricOptions,
MagickMimeOptions,
MagickModeOptions,
MagickModuleOptions,
MagickMorphologyOptions,
MagickNoiseOptions,
MagickOrientationOptions,
MagickPixelIntensityOptions,
MagickPolicyOptions,
MagickPolicyDomainOptions,
MagickPolicyRightsOptions,
MagickPreviewOptions,
MagickPrimitiveOptions,
MagickQuantumFormatOptions,
MagickResolutionOptions,
MagickResourceOptions,
MagickSparseColorOptions,
MagickStatisticOptions,
MagickStorageOptions,
MagickStretchOptions,
MagickStyleOptions,
MagickThresholdOptions,
MagickTypeOptions,
MagickValidateOptions,
MagickVirtualPixelOptions,
MagickComplexOptions,
MagickIntensityOptions,
MagickGradientOptions,
MagickWeightOptions,
MagickComplianceOptions,
MagickAutoThresholdOptions,
MagickPagesizeOptions
} CommandOption;
typedef enum
{
UndefinedValidate,
NoValidate = 0x00000,
ColorspaceValidate = 0x00001,
CompareValidate = 0x00002,
CompositeValidate = 0x00004,
ConvertValidate = 0x00008,
FormatsDiskValidate = 0x00010,
FormatsMapValidate = 0x00020,
FormatsMemoryValidate = 0x00040,
IdentifyValidate = 0x00080,
ImportExportValidate = 0x00100,
MontageValidate = 0x00200,
StreamValidate = 0x00400,
AllValidate = 0x7fffffff
} ValidateType;
typedef struct _OptionInfo
{
const char
*mnemonic;
ssize_t
type,
flags;
MagickBooleanType
stealth;
} OptionInfo;
/*
Flags to describe classes of image processing options.
*/
typedef enum
{
UndefinedOptionFlag = 0x0000,
FireOptionFlag = 0x0001, /* Option sequence firing point */
ImageInfoOptionFlag = 0x0002, /* Sets ImageInfo, no image needed */
DrawInfoOptionFlag = 0x0004, /* Sets DrawInfo, no image needed */
QuantizeInfoOptionFlag = 0x0008, /* Sets QuantizeInfo, no image needed */
GlobalOptionFlag = 0x0010, /* Sets Global Option, no image needed */
SimpleOperatorOptionFlag = 0x0100, /* Simple Image processing operator */
ListOperatorOptionFlag = 0x0200, /* Multi-Image List processing operator */
SpecialOperatorOptionFlag = 0x0400, /* Specially handled Operator Option */
GenesisOptionFlag = 0x0400, /* Genesis Command Wrapper Option */
NonConvertOptionFlag = 0x4000, /* Option not used by Convert */
DeprecateOptionFlag = 0x8000 /* Deprecate option, give warning */
} CommandOptionFlags;
extern MagickExport char
**GetCommandOptions(const CommandOption),
*GetNextImageOption(const ImageInfo *),
*RemoveImageOption(ImageInfo *,const char *);
extern MagickExport const char
*CommandOptionToMnemonic(const CommandOption,const ssize_t),
*GetImageOption(const ImageInfo *,const char *);
extern MagickExport MagickBooleanType
CloneImageOptions(ImageInfo *,const ImageInfo *),
DefineImageOption(ImageInfo *,const char *),
DeleteImageOption(ImageInfo *,const char *),
IsCommandOption(const char *),
IsOptionMember(const char *,const char *),
ListCommandOptions(FILE *,const CommandOption,ExceptionInfo *),
SetImageOption(ImageInfo *,const char *,const char *);
extern MagickExport ssize_t
GetCommandOptionFlags(const CommandOption,const MagickBooleanType,
const char *),
ParseChannelOption(const char *),
ParseCommandOption(const CommandOption,const MagickBooleanType,const char *);
extern MagickExport void
DestroyImageOptions(ImageInfo *),
ResetImageOptions(const ImageInfo *),
ResetImageOptionIterator(const ImageInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/histogram.h 0000644 00000002743 14751151177 0010164 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore histogram methods.
*/
#ifndef MAGICKCORE_HISTOGRAM_H
#define MAGICKCORE_HISTOGRAM_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _ColorPacket
{
PixelPacket
pixel;
IndexPacket
index;
MagickSizeType
count;
} ColorPacket;
extern MagickExport ColorPacket
*GetImageHistogram(const Image *,size_t *,ExceptionInfo *);
extern MagickExport Image
*UniqueImageColors(const Image *,ExceptionInfo *);
extern MagickExport MagickBooleanType
IdentifyPaletteImage(const Image *,ExceptionInfo *),
IsHistogramImage(const Image *,ExceptionInfo *),
IsPaletteImage(const Image *,ExceptionInfo *),
MinMaxStretchImage(Image *,const ChannelType,const double,const double);
extern MagickExport size_t
GetNumberColors(const Image *,FILE *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/configure.h 0000644 00000003753 14751151177 0010152 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore configure methods.
*/
#ifndef MAGICKCORE_CONFIGURE_H
#define MAGICKCORE_CONFIGURE_H
#include "magick/hashmap.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _ConfigureInfo
{
char
*path,
*name,
*value;
MagickBooleanType
exempt,
stealth;
struct _ConfigureInfo
*previous,
*next; /* deprecated, use GetConfigureInfoList() */
size_t
signature;
} ConfigureInfo;
extern MagickExport char
**GetConfigureList(const char *,size_t *,ExceptionInfo *),
*GetConfigureOption(const char *);
extern MagickExport const char
*GetConfigureValue(const ConfigureInfo *);
extern MagickExport const ConfigureInfo
*GetConfigureInfo(const char *,ExceptionInfo *),
**GetConfigureInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport LinkedListInfo
*DestroyConfigureOptions(LinkedListInfo *),
*GetConfigurePaths(const char *,ExceptionInfo *),
*GetConfigureOptions(const char *,ExceptionInfo *);
extern MagickExport MagickBooleanType
ConfigureComponentGenesis(void),
ListConfigureInfo(FILE *,ExceptionInfo *);
extern MagickExport void
ConfigureComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/quantum.h 0000644 00000012277 14751151177 0007664 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore quantum inline methods.
*/
#ifndef MAGICKCORE_QUANTUM_H
#define MAGICKCORE_QUANTUM_H
#include <float.h>
#include "magick/image.h"
#include "magick/semaphore.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#define RoundToQuantum(quantum) ClampToQuantum(quantum)
typedef enum
{
UndefinedEndian,
LSBEndian,
MSBEndian
} EndianType;
typedef enum
{
UndefinedQuantumAlpha,
AssociatedQuantumAlpha,
DisassociatedQuantumAlpha
} QuantumAlphaType;
typedef enum
{
UndefinedQuantumFormat,
FloatingPointQuantumFormat,
SignedQuantumFormat,
UnsignedQuantumFormat
} QuantumFormatType;
typedef enum
{
UndefinedQuantum,
AlphaQuantum,
BlackQuantum,
BlueQuantum,
CMYKAQuantum,
CMYKQuantum,
CyanQuantum,
GrayAlphaQuantum,
GrayQuantum,
GreenQuantum,
IndexAlphaQuantum,
IndexQuantum,
MagentaQuantum,
OpacityQuantum,
RedQuantum,
RGBAQuantum,
BGRAQuantum,
RGBOQuantum,
RGBQuantum,
YellowQuantum,
GrayPadQuantum, /* deprecated */
RGBPadQuantum,
CbYCrYQuantum,
CbYCrQuantum,
CbYCrAQuantum,
CMYKOQuantum,
BGRQuantum,
BGROQuantum
} QuantumType;
typedef struct _QuantumInfo
QuantumInfo;
static inline Quantum ClampToQuantum(const MagickRealType quantum)
{
#if defined(MAGICKCORE_HDRI_SUPPORT)
return((Quantum) quantum);
#else
if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
return((Quantum) 0);
if (quantum >= (MagickRealType) QuantumRange)
return(QuantumRange);
return((Quantum) (quantum+0.5));
#endif
}
#if (MAGICKCORE_QUANTUM_DEPTH == 8)
static inline unsigned char ScaleQuantumToChar(const Quantum quantum)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
return((unsigned char) quantum);
#else
if ((IsNaN(quantum) != 0) || (quantum <= 0.0f))
return(0);
if (quantum >= 255.0)
return(255);
return((unsigned char) (quantum+0.5f));
#endif
}
#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
static inline unsigned char ScaleQuantumToChar(const Quantum quantum)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
return((unsigned char) (((quantum+128UL)-((quantum+128UL) >> 8)) >> 8));
#else
if ((IsNaN(quantum) != 0) || (quantum <= 0.0f))
return(0);
if ((quantum/257.0f) >= 255.0f)
return(255);
return((unsigned char) (quantum/257.0f+0.5f));
#endif
}
#elif (MAGICKCORE_QUANTUM_DEPTH == 32)
static inline unsigned char ScaleQuantumToChar(const Quantum quantum)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
return((unsigned char) ((quantum+MagickULLConstant(8421504))/
MagickULLConstant(16843009)));
#else
if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
return(0);
if ((quantum/16843009.0) >= 255.0)
return(255);
return((unsigned char) (quantum/16843009.0+0.5));
#endif
}
#elif (MAGICKCORE_QUANTUM_DEPTH == 64)
static inline unsigned char ScaleQuantumToChar(const Quantum quantum)
{
#if !defined(MAGICKCORE_HDRI_SUPPORT)
return((unsigned char) (quantum/72340172838076673.0+0.5));
#else
if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
return(0);
if ((quantum/72340172838076673.0) >= 255.0)
return(255);
return((unsigned char) (quantum/72340172838076673.0+0.5));
#endif
}
#endif
extern MagickExport EndianType
GetQuantumEndian(const QuantumInfo *);
extern MagickExport MagickBooleanType
SetQuantumDepth(const Image *,QuantumInfo *,const size_t),
SetQuantumEndian(const Image *,QuantumInfo *,const EndianType),
SetQuantumFormat(const Image *,QuantumInfo *,const QuantumFormatType),
SetQuantumPad(const Image *,QuantumInfo *,const size_t);
extern MagickExport QuantumFormatType
GetQuantumFormat(const QuantumInfo *);
extern MagickExport QuantumInfo
*AcquireQuantumInfo(const ImageInfo *,Image *),
*DestroyQuantumInfo(QuantumInfo *);
extern MagickExport QuantumType
GetQuantumType(Image *,ExceptionInfo *);
extern MagickExport size_t
ExportQuantumPixels(const Image *,const CacheView *,const QuantumInfo *,
const QuantumType,unsigned char *magick_restrict,ExceptionInfo *),
GetQuantumExtent(const Image *,const QuantumInfo *,const QuantumType),
ImportQuantumPixels(Image *,CacheView *,const QuantumInfo *,const QuantumType,
const unsigned char *magick_restrict,ExceptionInfo *);
extern MagickExport unsigned char
*GetQuantumPixels(const QuantumInfo *);
extern MagickExport void
GetQuantumInfo(const ImageInfo *,QuantumInfo *),
SetQuantumAlphaType(QuantumInfo *,const QuantumAlphaType),
SetQuantumImageType(Image *,const QuantumType),
SetQuantumMinIsWhite(QuantumInfo *,const MagickBooleanType),
SetQuantumPack(QuantumInfo *,const MagickBooleanType),
SetQuantumQuantum(QuantumInfo *,const size_t),
SetQuantumScale(QuantumInfo *,const double);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/token.h 0000644 00000003126 14751151177 0007303 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore token methods.
*/
#ifndef MAGICKCORE_TOKEN_H
#define MAGICKCORE_TOKEN_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/*
Typedef declarations.
*/
typedef struct _TokenInfo
TokenInfo;
extern MagickExport int
Tokenizer(TokenInfo *,const unsigned int,char *,const size_t,const char *,
const char *,const char *,const char *,const char,char *,int *,char *);
extern MagickExport MagickBooleanType
GlobExpression(const char *magick_restrict,const char *magick_restrict,
const MagickBooleanType) magick_attribute((__pure__)),
IsGlob(const char *) magick_attribute((__pure__)),
IsMagickTrue(const char *) magick_attribute((__pure__));
extern MagickExport size_t
GetNextToken(const char *magick_restrict,const char **magick_restrict,
const size_t,char *magick_restrict) magick_hot_spot;
extern MagickExport TokenInfo
*AcquireTokenInfo(void),
*DestroyTokenInfo(TokenInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/studio.h 0000644 00000024570 14751151177 0007500 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore private application programming interface declarations.
*/
#ifndef MAGICKCORE_STUDIO_H
#define MAGICKCORE_STUDIO_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if defined(WIN32) || defined(WIN64)
# define MAGICKCORE_WINDOWS_SUPPORT
#else
# define MAGICKCORE_POSIX_SUPPORT
#endif
#define MAGICKCORE_IMPLEMENTATION 1
#if !defined(MAGICKCORE_CONFIG_H)
# define MAGICKCORE_CONFIG_H
# if !defined(vms) && !defined(macintosh)
# include "magick/magick-config.h"
# else
# include "magick-config.h"
# endif
#if defined(MAGICKCORE__FILE_OFFSET_BITS) && !defined(_FILE_OFFSET_BITS)
# define _FILE_OFFSET_BITS MAGICKCORE__FILE_OFFSET_BITS
#endif
#if defined(_magickcore_const) && !defined(const)
# define const _magickcore_const
#endif
#if defined(_magickcore_inline) && !defined(inline)
# define inline _magickcore_inline
#endif
# if defined(__cplusplus) || defined(c_plusplus)
# undef inline
# endif
#endif
#if defined(MAGICKCORE_NAMESPACE_PREFIX)
# include "magick/methods.h"
#endif
#if !defined(const)
# define STDC
#endif
/* Define to 1 if assertions should be disabled. */
#if defined(MAGICKCORE_NDEBUG)
#define NDEBUG 1
#endif
#include <stdarg.h>
#include <stdio.h>
#if defined(MAGICKCORE_HAVE_SYS_STAT_H)
# include <sys/stat.h>
#endif
#if defined(MAGICKCORE_STDC_HEADERS)
# include <stdlib.h>
# include <stddef.h>
#else
# if defined(MAGICKCORE_HAVE_STDLIB_H)
# include <stdlib.h>
# endif
#endif
#if !defined(magick_restrict)
# if !defined(_magickcore_restrict)
# define magick_restrict restrict
# else
# define magick_restrict _magickcore_restrict
# endif
#endif
#if defined(MAGICKCORE_HAVE_STRING_H)
# if !defined(STDC_HEADERS) && defined(MAGICKCORE_HAVE_MEMORY_H)
# include <memory.h>
# endif
# include <string.h>
#endif
#if defined(MAGICKCORE_HAVE_STRINGS_H)
# include <strings.h>
#endif
#if defined(MAGICKCORE_HAVE_INTTYPES_H)
# include <inttypes.h>
#endif
#if defined(MAGICKCORE_HAVE_STDINT_H)
# include <stdint.h>
#endif
#if defined(MAGICKCORE_HAVE_UNISTD_H)
# include <unistd.h>
#endif
#if defined(MAGICKCORE_WINDOWS_SUPPORT) && defined(_DEBUG)
#define _CRTDBG_MAP_ALLOC
#endif
#if defined(MAGICKCORE_WINDOWS_SUPPORT)
# include <io.h>
#if !defined(__CYGWIN__)
# include <direct.h>
#endif
# if !defined(MAGICKCORE_HAVE_STRERROR)
# define HAVE_STRERROR
# endif
#endif
#include <ctype.h>
#include <locale.h>
#include <errno.h>
#include <fcntl.h>
#include <math.h>
#include <time.h>
#include <limits.h>
#include <signal.h>
#include <assert.h>
#if defined(MAGICKCORE_HAVE_XLOCALE_H)
# include <xlocale.h>
#endif
#if defined(MAGICKCORE_THREAD_SUPPORT)
# include <pthread.h>
#endif
#if defined(MAGICKCORE_WINDOWS_SUPPORT)
#if !defined(__CYGWIN__)
#include <winsock2.h>
#include <ws2tcpip.h>
#endif
#include <windows.h>
#ifdef _MSC_VER
#pragma comment (lib, "ws2_32.lib")
#endif
#endif
#if defined(MAGICKCORE_HAVE_SYS_SYSLIMITS_H)
# include <sys/syslimits.h>
#endif
#if defined(MAGICKCORE_HAVE_ARM_LIMITS_H)
# include <arm/limits.h>
#endif
#if defined(MAGICKCORE_HAVE_CL_CL_H) && !defined(MAGICK_PIXEL_RGBA)
# define MAGICKCORE_OPENCL_SUPPORT 1
#endif
#if defined(MAGICKCORE_HAVE_OPENCL_CL_H) && !defined(MAGICK_PIXEL_RGBA)
# define MAGICKCORE_OPENCL_SUPPORT 1
#endif
#if defined(_OPENMP) && ((_OPENMP >= 200203) || defined(__OPENCC__))
# include <omp.h>
# define MAGICKCORE_OPENMP_SUPPORT 1
#endif
#if defined(MAGICKCORE_HAVE_PREAD) && defined(MAGICKCORE_HAVE_DECL_PREAD) && !MAGICKCORE_HAVE_DECL_PREAD
ssize_t pread(int,void *,size_t,off_t);
#endif
#if defined(MAGICKCORE_HAVE_PWRITE) && defined(MAGICKCORE_HAVE_DECL_PWRITE) && !MAGICKCORE_HAVE_DECL_PWRITE
ssize_t pwrite(int,const void *,size_t,off_t);
#endif
#if defined(MAGICKCORE_HAVE_STRLCPY) && defined(MAGICKCORE_HAVE_DECL_STRLCPY) && !MAGICKCORE_HAVE_DECL_STRLCPY
extern size_t strlcpy(char *,const char *,size_t);
#endif
#if defined(MAGICKCORE_HAVE_VSNPRINTF) && defined(MAGICKCORE_HAVE_DECL_VSNPRINTF) && !MAGICKCORE_HAVE_DECL_VSNPRINTF
extern int vsnprintf(char *,size_t,const char *,va_list);
#endif
#include "magick/method-attribute.h"
#if defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(MAGICKCORE_POSIX_SUPPORT)
# include <sys/types.h>
# include <sys/stat.h>
# if defined(MAGICKCORE_POSIX_SUPPORT)
# if defined(MAGICKCORE_HAVE_SYS_NDIR_H) || defined(MAGICKCORE_HAVE_SYS_DIR_H) || defined(MAGICKCORE_HAVE_NDIR_H)
# define dirent direct
# define NAMLEN(dirent) (dirent)->d_namlen
# if defined(MAGICKCORE_HAVE_SYS_NDIR_H)
# include <sys/ndir.h>
# endif
# if defined(MAGICKCORE_HAVE_SYS_DIR_H)
# include <sys/dir.h>
# endif
# if defined(MAGICKCORE_HAVE_NDIR_H)
# include <ndir.h>
# endif
# else
# include <dirent.h>
# define NAMLEN(dirent) strlen((dirent)->d_name)
# endif
# include <sys/wait.h>
# include <pwd.h>
# endif
# if !defined(S_ISDIR)
# define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
# endif
# if !defined(S_ISREG)
# define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG)
# endif
# include "magick/magick-type.h"
# if !defined(MAGICKCORE_WINDOWS_SUPPORT)
# include <sys/time.h>
# if defined(MAGICKCORE_HAVE_SYS_TIMES_H)
# include <sys/times.h>
# endif
# if defined(MAGICKCORE_HAVE_SYS_RESOURCE_H)
# include <sys/resource.h>
# endif
# if defined(MAGICKCORE_HAVE_SYS_MMAN_H)
# include <sys/mman.h>
# endif
# if defined(MAGICKCORE_HAVE_SYS_SENDFILE_H)
# include <sys/sendfile.h>
# endif
# if defined(MAGICKCORE_HAVE_SYS_SOCKET_H)
# include <sys/socket.h>
# endif
# if defined(MAGICKCORE_HAVE_SYS_UIO_H)
# include <sys/uio.h>
# endif
#endif
#else
# include <types.h>
# include <stat.h>
# if defined(macintosh)
# if !defined(DISABLE_SIOUX)
# include <SIOUX.h>
# include <console.h>
# endif
# include <unix.h>
# endif
# include "magick/magick-type.h"
#endif
#if defined(S_IRUSR) && defined(S_IWUSR)
# define S_MODE (S_IRUSR | S_IWUSR)
#elif defined (MAGICKCORE_WINDOWS_SUPPORT)
# define S_MODE (_S_IREAD | _S_IWRITE)
#else
# define S_MODE 0600
#endif
#if defined(MAGICKCORE_WINDOWS_SUPPORT)
# include "magick/nt-base.h"
#endif
#if defined(macintosh)
# include "magick/mac.h"
#endif
#if defined(vms)
# include "magick/vms.h"
#endif
#undef HAVE_CONFIG_H
#undef gamma
#undef index
#undef pipe
#undef y1
/*
Review these platform specific definitions.
*/
#if ( defined(MAGICKCORE_POSIX_SUPPORT) && !defined(__OS2__) ) && !defined( __VMS )
# define DirectorySeparator "/"
# define DirectoryListSeparator ':'
# define EditorOptions " -title \"Edit Image Comment\" -e vi"
# define Exit exit
# define IsBasenameSeparator(c) ((c) == '/' ? MagickTrue : MagickFalse)
# define X11_PREFERENCES_PATH "~/."
# define ProcessPendingEvents(text)
# define ReadCommandlLine(argc,argv)
# define SetNotifyHandlers
#else
# if defined(vms)
# define X11_APPLICATION_PATH "decw$system_defaults:"
# define DirectorySeparator ""
# define DirectoryListSeparator ';'
# define EditorOptions ""
# define Exit exit
# define IsBasenameSeparator(c) \
(((c) == ']') || ((c) == ':') || ((c) == '/') ? MagickTrue : MagickFalse)
# define MAGICKCORE_LIBRARY_PATH "sys$login:"
# define MAGICKCORE_SHARE_PATH "sys$login:"
# define X11_PREFERENCES_PATH "decw$user_defaults:"
# define ProcessPendingEvents(text)
# define ReadCommandlLine(argc,argv)
# define SetNotifyHandlers
# endif
# if defined(__OS2__)
# define DirectorySeparator "\\"
# define DirectoryListSeparator ';'
# define EditorOptions " -title \"Edit Image Comment\" -e vi"
# define Exit exit
# define IsBasenameSeparator(c) \
(((c) == '/') || ((c) == '\\') ? MagickTrue : MagickFalse)
# define PreferencesDefaults "~\."
# define ProcessPendingEvents(text)
# define ReadCommandlLine(argc,argv)
# define SetNotifyHandlers
#endif
# if defined(macintosh)
# define X11_APPLICATION_PATH "/usr/lib/X11/app-defaults/"
# define DirectorySeparator ":"
# define DirectoryListSeparator ';'
# define EditorOptions ""
# define IsBasenameSeparator(c) ((c) == ':' ? MagickTrue : MagickFalse)
# define MAGICKCORE_LIBRARY_PATH ""
# define MAGICKCORE_SHARE_PATH ""
# define X11_PREFERENCES_PATH "~/."
# if defined(DISABLE_SIOUX)
# define ReadCommandlLine(argc,argv)
# define SetNotifyHandlers \
SetFatalErrorHandler(MacFatalErrorHandler); \
SetErrorHandler(MACErrorHandler); \
SetWarningHandler(MACWarningHandler)
# else
# define ReadCommandlLine(argc,argv) argc=ccommand(argv); puts(MagickVersion);
# define SetNotifyHandlers \
SetErrorHandler(MACErrorHandler); \
SetWarningHandler(MACWarningHandler)
# endif
# endif
# if defined(MAGICKCORE_WINDOWS_SUPPORT)
# define DirectorySeparator "\\"
# define DirectoryListSeparator ';'
# define EditorOptions ""
# define IsBasenameSeparator(c) \
(((c) == '/') || ((c) == '\\') ? MagickTrue : MagickFalse)
# define ProcessPendingEvents(text)
# if !defined(X11_PREFERENCES_PATH)
# define X11_PREFERENCES_PATH "~\\."
# endif
# define ReadCommandlLine(argc,argv)
# define SetNotifyHandlers \
SetErrorHandler(NTErrorHandler); \
SetWarningHandler(NTWarningHandler)
# if !defined(MAGICKCORE_HAVE_TIFFCONF_H)
# define HAVE_TIFFCONF_H
# endif
# endif
#endif
/*
Define system symbols if not already defined.
*/
#if !defined(STDIN_FILENO)
#define STDIN_FILENO 0x00
#endif
#if !defined(O_BINARY)
#define O_BINARY 0x00
#endif
#if !defined(PATH_MAX)
#define PATH_MAX 4096
#endif
#if defined(MAGICKCORE_LTDL_DELEGATE) || (defined(MAGICKCORE_WINDOWS_SUPPORT) && defined(_DLL) && !defined(_LIB))
# define MAGICKCORE_MODULES_SUPPORT
#endif
#if defined(_MAGICKMOD_)
# undef MAGICKCORE_BUILD_MODULES
# define MAGICKCORE_BUILD_MODULES
#endif
/*
Magick defines.
*/
#define MagickMaxRecursionDepth 600
#define Swap(x,y) ((x)^=(y), (y)^=(x), (x)^=(y))
#if defined(_MSC_VER)
# define DisableMSCWarning(nr) __pragma(warning(push)) \
__pragma(warning(disable:nr))
# define RestoreMSCWarning __pragma(warning(pop))
#else
# define DisableMSCWarning(nr)
# define RestoreMSCWarning
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/MagickCore.h 0000644 00000011122 14751151177 0010162 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore Application Programming Interface declarations.
*/
#ifndef MAGICKCORE_CORE_H
#define MAGICKCORE_CORE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if !defined(MAGICKCORE_CONFIG_H)
# define MAGICKCORE_CONFIG_H
# if !defined(vms) && !defined(macintosh)
# include "magick/magick-config.h"
# else
# include "magick-config.h"
# endif
#if defined(_magickcore_const) && !defined(const)
# define const _magickcore_const
#endif
#if defined(_magickcore_inline) && !defined(inline)
# define inline _magickcore_inline
#endif
#if !defined(magick_restrict)
# if !defined(_magickcore_restrict)
# define magick_restrict restrict
# else
# define magick_restrict _magickcore_restrict
# endif
#endif
# if defined(__cplusplus) || defined(c_plusplus)
# undef inline
# endif
#endif
#define MAGICKCORE_CHECK_VERSION(major,minor,micro) \
((MAGICKCORE_MAJOR_VERSION > (major)) || \
((MAGICKCORE_MAJOR_VERSION == (major)) && \
(MAGICKCORE_MINOR_VERSION > (minor))) || \
((MAGICKCORE_MAJOR_VERSION == (major)) && \
(MAGICKCORE_MINOR_VERSION == (minor)) && \
(MAGICKCORE_MICRO_VERSION >= (micro))))
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
#include <sys/types.h>
#include <time.h>
#if defined(WIN32) || defined(WIN64)
# define MAGICKCORE_WINDOWS_SUPPORT
#else
# define MAGICKCORE_POSIX_SUPPORT
#endif
#include "magick/method-attribute.h"
#if defined(MAGICKCORE_NAMESPACE_PREFIX)
# include "magick/methods.h"
#endif
#include "magick/magick-type.h"
#include "magick/animate.h"
#include "magick/annotate.h"
#include "magick/artifact.h"
#include "magick/attribute.h"
#include "magick/blob.h"
#include "magick/cache.h"
#include "magick/cache-view.h"
#include "magick/channel.h"
#include "magick/cipher.h"
#include "magick/client.h"
#include "magick/coder.h"
#include "magick/color.h"
#include "magick/colorspace.h"
#include "magick/colormap.h"
#include "magick/compare.h"
#include "magick/composite.h"
#include "magick/compress.h"
#include "magick/configure.h"
#include "magick/constitute.h"
#include "magick/decorate.h"
#include "magick/delegate.h"
#include "magick/deprecate.h"
#include "magick/display.h"
#include "magick/distort.h"
#include "magick/distribute-cache.h"
#include "magick/draw.h"
#include "magick/effect.h"
#include "magick/enhance.h"
#include "magick/exception.h"
#include "magick/feature.h"
#include "magick/fourier.h"
#include "magick/fx.h"
#include "magick/gem.h"
#include "magick/geometry.h"
#include "magick/hashmap.h"
#include "magick/histogram.h"
#include "magick/identify.h"
#include "magick/image.h"
#include "magick/image-view.h"
#include "magick/layer.h"
#include "magick/list.h"
#include "magick/locale_.h"
#include "magick/log.h"
#include "magick/magic.h"
#include "magick/magick.h"
#include "magick/matrix.h"
#include "magick/memory_.h"
#include "magick/module.h"
#include "magick/mime.h"
#include "magick/monitor.h"
#include "magick/montage.h"
#include "magick/morphology.h"
#include "magick/opencl.h"
#include "magick/option.h"
#include "magick/paint.h"
#include "magick/pixel.h"
#include "magick/pixel-accessor.h"
#include "magick/policy.h"
#include "magick/prepress.h"
#include "magick/profile.h"
#include "magick/property.h"
#include "magick/quantize.h"
#include "magick/quantum.h"
#include "magick/registry.h"
#include "magick/random_.h"
#include "magick/resample.h"
#include "magick/resize.h"
#include "magick/resource_.h"
#include "magick/segment.h"
#include "magick/shear.h"
#include "magick/signature.h"
#include "magick/splay-tree.h"
#include "magick/static.h"
#include "magick/stream.h"
#include "magick/statistic.h"
#include "magick/string_.h"
#include "magick/timer.h"
#include "magick/token.h"
#include "magick/transform.h"
#include "magick/threshold.h"
#include "magick/type.h"
#include "magick/utility.h"
#include "magick/version.h"
#include "magick/vision.h"
#include "magick/visual-effects.h"
#include "magick/xml-tree.h"
#include "magick/xwindow.h"
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/image-view.h 0000644 00000005301 14751151177 0010212 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image view methods.
*/
#ifndef MAGICKCORE_IMAGE_VIEW_H
#define MAGICKCORE_IMAGE_VIEW_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _ImageView
ImageView;
typedef MagickBooleanType
(*DuplexTransferImageViewMethod)(const ImageView *,const ImageView *,
ImageView *,const ssize_t,const int,void *),
(*GetImageViewMethod)(const ImageView *,const ssize_t,const int,void *),
(*SetImageViewMethod)(ImageView *,const ssize_t,const int,void *),
(*TransferImageViewMethod)(const ImageView *,ImageView *,const ssize_t,
const int,void *),
(*UpdateImageViewMethod)(ImageView *,const ssize_t,const int,void *);
extern MagickExport char
*GetImageViewException(const ImageView *,ExceptionType *);
extern MagickExport const IndexPacket
*GetImageViewVirtualIndexes(const ImageView *);
extern MagickExport const PixelPacket
*GetImageViewVirtualPixels(const ImageView *);
extern MagickExport Image
*GetImageViewImage(const ImageView *);
extern MagickExport ImageView
*CloneImageView(const ImageView *),
*DestroyImageView(ImageView *),
*NewImageView(Image *),
*NewImageViewRegion(Image *,const ssize_t,const ssize_t,const size_t,
const size_t);
extern MagickExport IndexPacket
*GetImageViewAuthenticIndexes(const ImageView *);
extern MagickExport MagickBooleanType
DuplexTransferImageViewIterator(ImageView *,ImageView *,ImageView *,
DuplexTransferImageViewMethod,void *),
GetImageViewIterator(ImageView *,GetImageViewMethod,void *),
IsImageView(const ImageView *),
SetImageViewIterator(ImageView *,SetImageViewMethod,void *),
TransferImageViewIterator(ImageView *,ImageView *,TransferImageViewMethod,
void *),
UpdateImageViewIterator(ImageView *,UpdateImageViewMethod,void *);
extern MagickExport PixelPacket
*GetImageViewAuthenticPixels(const ImageView *);
extern MagickExport RectangleInfo
GetImageViewExtent(const ImageView *);
extern MagickExport void
SetImageViewDescription(ImageView *,const char *),
SetImageViewThreads(ImageView *,const size_t);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/fx.h 0000644 00000002004 14751151177 0006572 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image f/x methods.
*/
#ifndef MAGICKCORE_FX_H
#define MAGICKCORE_FX_H
#include "magick/draw.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport Image
*FxImage(const Image *,const char *,ExceptionInfo *),
*FxImageChannel(const Image *,const ChannelType,const char *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/log.h 0000644 00000005303 14751151177 0006743 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore log methods.
*/
#ifndef MAGICKCORE_LOG_H
#define MAGICKCORE_LOG_H
#include <stdarg.h>
#include "magick/exception.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if !defined(GetMagickModule)
# define GetMagickModule() __FILE__,__func__,(unsigned long) __LINE__
#endif
#define MagickLogFilename "log.xml"
typedef enum
{
UndefinedEvents,
NoEvents = 0x00000,
TraceEvent = 0x00001,
AnnotateEvent = 0x00002,
BlobEvent = 0x00004,
CacheEvent = 0x00008,
CoderEvent = 0x00010,
ConfigureEvent = 0x00020,
DeprecateEvent = 0x00040,
DrawEvent = 0x00080,
ExceptionEvent = 0x00100,
ImageEvent = 0x00200,
LocaleEvent = 0x00400,
ModuleEvent = 0x00800,
PolicyEvent = 0x01000,
ResourceEvent = 0x02000,
TransformEvent = 0x04000,
UserEvent = 0x09000,
WandEvent = 0x10000,
X11Event = 0x20000,
AccelerateEvent = 0x40000,
AllEvents = 0x7fffffff
} LogEventType;
typedef struct _LogInfo
LogInfo;
typedef void
(*MagickLogMethod)(const LogEventType,const char *);
extern const MagickExport LogInfo
**GetLogInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport char
**GetLogList(const char *,size_t *,ExceptionInfo *);
extern MagickExport char
*GetLogName(void) magick_attribute((__pure__)),
*SetLogName(const char *);
extern MagickExport LogEventType
GetLogEventMask(void) magick_attribute((__pure__));
extern MagickExport LogEventType
SetLogEventMask(const char *);
extern MagickExport MagickBooleanType
IsEventLogging(void) magick_attribute((__pure__)),
ListLogInfo(FILE *,ExceptionInfo *),
LogComponentGenesis(void),
LogMagickEvent(const LogEventType,const char *,const char *,const size_t,
const char *,...) magick_attribute((__format__ (__printf__,5,6))),
LogMagickEventList(const LogEventType,const char *,const char *,const size_t,
const char *,va_list) magick_attribute((__format__ (__printf__,5,0)));
extern MagickExport void
CloseMagickLog(void),
LogComponentTerminus(void),
SetLogFormat(const char *),
SetLogMethod(MagickLogMethod);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/client.h 0000644 00000002027 14751151177 0007440 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore client methods.
*/
#ifndef MAGICKCORE_CLIENT_H
#define MAGICKCORE_CLIENT_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport const char
*GetClientPath(void) magick_attribute((__const__)),
*GetClientName(void) magick_attribute((__const__)),
*SetClientName(const char *),
*SetClientPath(const char *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/distribute-cache.h 0000644 00000001734 14751151177 0011405 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore distributed cache methods.
*/
#ifndef MAGICKCORE_DISTRIBUTE_CACHE_H
#define MAGICKCORE_DISTRIBUTE_CACHE_H
#include "magick/exception.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport void
DistributePixelCacheServer(const int,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/threshold.h 0000644 00000004607 14751151177 0010164 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image threshold methods.
*/
#ifndef MAGICKCORE_THRESHOLD_H
#define MAGICKCORE_THRESHOLD_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedThresholdMethod,
KapurThresholdMethod,
OTSUThresholdMethod,
TriangleThresholdMethod
} AutoThresholdMethod;
typedef struct _ThresholdMap
ThresholdMap;
extern MagickExport Image
*AdaptiveThresholdImage(const Image *,const size_t,const size_t,const ssize_t,
ExceptionInfo *);
extern MagickExport ThresholdMap
*DestroyThresholdMap(ThresholdMap *),
*GetThresholdMap(const char *,ExceptionInfo *);
extern MagickExport MagickBooleanType
AutoThresholdImage(Image *,const AutoThresholdMethod,ExceptionInfo *),
BilevelImage(Image *,const double),
BilevelImageChannel(Image *,const ChannelType,const double),
BlackThresholdImage(Image *,const char *),
BlackThresholdImageChannel(Image *,const ChannelType,const char *,
ExceptionInfo *),
ClampImage(Image *),
ClampImageChannel(Image *,const ChannelType),
ListThresholdMaps(FILE *,ExceptionInfo *),
OrderedDitherImage(Image *), /* deprecated */
OrderedDitherImageChannel(Image *,const ChannelType,ExceptionInfo *),
OrderedPosterizeImage(Image *,const char *,ExceptionInfo *),
OrderedPosterizeImageChannel(Image *,const ChannelType,const char *,
ExceptionInfo *),
PerceptibleImage(Image *,const double),
PerceptibleImageChannel(Image *,const ChannelType,const double),
RandomThresholdImage(Image *,const char *,ExceptionInfo *),
RandomThresholdImageChannel(Image *,const ChannelType,const char *,
ExceptionInfo *),
WhiteThresholdImage(Image *,const char *),
WhiteThresholdImageChannel(Image *,const ChannelType,const char *,
ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/resize.h 0000644 00000003352 14751151177 0007465 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image resize methods.
*/
#ifndef MAGICKCORE_RESIZE_H
#define MAGICKCORE_RESIZE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _ResizeFilter
ResizeFilter;
extern MagickExport Image
*AdaptiveResizeImage(const Image *,const size_t,const size_t,ExceptionInfo *),
*InterpolativeResizeImage(const Image *,const size_t,const size_t,
const InterpolatePixelMethod,ExceptionInfo *),
*LiquidRescaleImage(const Image *,const size_t,const size_t,const double,
const double,ExceptionInfo *),
*MagnifyImage(const Image *,ExceptionInfo *),
*MinifyImage(const Image *,ExceptionInfo *),
*ResampleImage(const Image *,const double,const double,const FilterTypes,
const double,ExceptionInfo *),
*ResizeImage(const Image *,const size_t,const size_t,const FilterTypes,
const double,ExceptionInfo *),
*SampleImage(const Image *,const size_t,const size_t,ExceptionInfo *),
*ScaleImage(const Image *,const size_t,const size_t,ExceptionInfo *),
*ThumbnailImage(const Image *,const size_t,const size_t,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/profile.h 0000644 00000003377 14751151177 0007633 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image profile methods.
*/
#ifndef MAGICKCORE_PROFILE_H
#define MAGICKCORE_PROFILE_H
#include "magick/string_.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _ProfileInfo
{
char
*name;
size_t
length;
unsigned char
*info;
size_t
signature;
} ProfileInfo;
typedef enum
{
UndefinedIntent,
SaturationIntent,
PerceptualIntent,
AbsoluteIntent,
RelativeIntent
} RenderingIntent;
extern MagickExport char
*GetNextImageProfile(const Image *);
extern MagickExport const StringInfo
*GetImageProfile(const Image *,const char *);
extern MagickExport MagickBooleanType
CloneImageProfiles(Image *,const Image *),
DeleteImageProfile(Image *,const char *),
ProfileImage(Image *,const char *,const void *,const size_t,
const MagickBooleanType),
SetImageProfile(Image *,const char *,const StringInfo *),
SyncImageProfiles(Image *);
extern MagickExport StringInfo
*RemoveImageProfile(Image *,const char *);
extern MagickExport void
DestroyImageProfiles(Image *),
ResetImageProfileIterator(const Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/statistic.h 0000644 00000011563 14751151177 0010176 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore statistical methods.
*/
#ifndef MAGICKCORE_STATISTIC_H
#define MAGICKCORE_STATISTIC_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#include "magick/draw.h"
#define MaximumNumberOfImageMoments 8
#define MaximumNumberOfPerceptualHashes 7
typedef struct _ChannelStatistics
{
size_t
depth;
double
minima,
maxima,
sum,
sum_squared,
sum_cubed,
sum_fourth_power,
mean,
variance,
standard_deviation,
kurtosis,
skewness,
entropy;
} ChannelStatistics;
#undef I
typedef struct _ChannelMoments
{
double
I[32];
PointInfo
centroid,
ellipse_axis;
double
ellipse_angle,
ellipse_eccentricity,
ellipse_intensity;
} ChannelMoments;
typedef struct _ChannelPerceptualHash
{
double
P[32],
Q[32];
} ChannelPerceptualHash;
typedef enum
{
UndefinedEvaluateOperator,
AddEvaluateOperator,
AndEvaluateOperator,
DivideEvaluateOperator,
LeftShiftEvaluateOperator,
MaxEvaluateOperator,
MinEvaluateOperator,
MultiplyEvaluateOperator,
OrEvaluateOperator,
RightShiftEvaluateOperator,
SetEvaluateOperator,
SubtractEvaluateOperator,
XorEvaluateOperator,
PowEvaluateOperator,
LogEvaluateOperator,
ThresholdEvaluateOperator,
ThresholdBlackEvaluateOperator,
ThresholdWhiteEvaluateOperator,
GaussianNoiseEvaluateOperator,
ImpulseNoiseEvaluateOperator,
LaplacianNoiseEvaluateOperator,
MultiplicativeNoiseEvaluateOperator,
PoissonNoiseEvaluateOperator,
UniformNoiseEvaluateOperator,
CosineEvaluateOperator,
SineEvaluateOperator,
AddModulusEvaluateOperator,
MeanEvaluateOperator,
AbsEvaluateOperator,
ExponentialEvaluateOperator,
MedianEvaluateOperator,
SumEvaluateOperator,
RootMeanSquareEvaluateOperator,
InverseLogEvaluateOperator
} MagickEvaluateOperator;
typedef enum
{
UndefinedFunction,
PolynomialFunction,
SinusoidFunction,
ArcsinFunction,
ArctanFunction
} MagickFunction;
typedef enum
{
UndefinedStatistic,
GradientStatistic,
MaximumStatistic,
MeanStatistic,
MedianStatistic,
MinimumStatistic,
ModeStatistic,
NonpeakStatistic,
StandardDeviationStatistic,
RootMeanSquareStatistic
} StatisticType;
extern MagickExport ChannelStatistics
*GetImageChannelStatistics(const Image *,ExceptionInfo *);
extern MagickExport ChannelMoments
*GetImageChannelMoments(const Image *,ExceptionInfo *);
extern MagickExport ChannelPerceptualHash
*GetImageChannelPerceptualHash(const Image *,ExceptionInfo *);
extern MagickExport Image
*EvaluateImages(const Image *,const MagickEvaluateOperator,ExceptionInfo *),
*PolynomialImage(const Image *,const size_t,const double *,ExceptionInfo *),
*PolynomialImageChannel(const Image *,const ChannelType,const size_t,
const double *,ExceptionInfo *),
*StatisticImage(const Image *,const StatisticType,const size_t,const size_t,
ExceptionInfo *),
*StatisticImageChannel(const Image *,const ChannelType,const StatisticType,
const size_t,const size_t,ExceptionInfo *);
extern MagickExport MagickBooleanType
EvaluateImage(Image *,const MagickEvaluateOperator,const double,
ExceptionInfo *),
EvaluateImageChannel(Image *,const ChannelType,const MagickEvaluateOperator,
const double,ExceptionInfo *),
FunctionImage(Image *,const MagickFunction,const size_t,const double *,
ExceptionInfo *),
FunctionImageChannel(Image *,const ChannelType,const MagickFunction,
const size_t,const double *,ExceptionInfo *),
GetImageChannelEntropy(const Image *,const ChannelType,double *,
ExceptionInfo *),
GetImageChannelExtrema(const Image *,const ChannelType,size_t *,size_t *,
ExceptionInfo *),
GetImageChannelMean(const Image *,const ChannelType,double *,double *,
ExceptionInfo *),
GetImageChannelKurtosis(const Image *,const ChannelType,double *,double *,
ExceptionInfo *),
GetImageChannelRange(const Image *,const ChannelType,double *,double *,
ExceptionInfo *),
GetImageEntropy(const Image *,double *,ExceptionInfo *),
GetImageExtrema(const Image *,size_t *,size_t *,ExceptionInfo *),
GetImageMean(const Image *,double *,double *,ExceptionInfo *),
GetImageKurtosis(const Image *,double *,double *,ExceptionInfo *),
GetImageRange(const Image *,double *,double *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/colorspace.h 0000644 00000004633 14751151177 0010321 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image colorspace methods.
*/
#ifndef MAGICKCORE_COLORSPACE_H
#define MAGICKCORE_COLORSPACE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedColorspace,
RGBColorspace, /* Linear RGB colorspace */
GRAYColorspace, /* greyscale (non-linear) image (faked 1 channel) */
TransparentColorspace,
OHTAColorspace,
LabColorspace,
XYZColorspace,
YCbCrColorspace,
YCCColorspace,
YIQColorspace,
YPbPrColorspace,
YUVColorspace,
CMYKColorspace, /* negated linear RGB with black separated */
sRGBColorspace, /* Default: non-linear sRGB colorspace */
HSBColorspace,
HSLColorspace,
HWBColorspace,
Rec601LumaColorspace,
Rec601YCbCrColorspace,
Rec709LumaColorspace,
Rec709YCbCrColorspace,
LogColorspace,
CMYColorspace, /* negated linear RGB colorspace */
LuvColorspace,
HCLColorspace,
LCHColorspace, /* alias for LCHuv */
LMSColorspace,
LCHabColorspace, /* Cylindrical (Polar) Lab */
LCHuvColorspace, /* Cylindrical (Polar) Luv */
scRGBColorspace,
HSIColorspace,
HSVColorspace, /* alias for HSB */
HCLpColorspace,
YDbDrColorspace,
xyYColorspace,
LinearGRAYColorspace /* greyscale (linear) image (faked 1 channel) */
} ColorspaceType;
extern MagickExport ColorspaceType
GetImageColorspaceType(const Image *,ExceptionInfo *);
extern MagickExport MagickBooleanType
RGBTransformImage(Image *,const ColorspaceType),
SetImageColorspace(Image *,const ColorspaceType),
SetImageGray(Image *,ExceptionInfo *),
SetImageMonochrome(Image *,ExceptionInfo *),
TransformImageColorspace(Image *,const ColorspaceType),
TransformRGBImage(Image *,const ColorspaceType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/magick.h 0000644 00000007304 14751151177 0007420 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore magick methods.
*/
#ifndef MAGICKCORE_MAGICK_H
#define MAGICKCORE_MAGICK_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#include <stdarg.h>
#include "magick/semaphore.h"
#if defined(__cplusplus) || defined(c_plusplus)
# define magick_module _module /* reserved word in C++(20) */
#else
# define magick_module module
#endif
typedef enum
{
UndefinedFormatType,
ImplicitFormatType,
ExplicitFormatType
} MagickFormatType;
typedef enum
{
NoThreadSupport = 0x0000,
DecoderThreadSupport = 0x0001,
EncoderThreadSupport = 0x0002
} MagickThreadSupport;
typedef Image
*DecodeImageHandler(const ImageInfo *,ExceptionInfo *);
typedef MagickBooleanType
EncodeImageHandler(const ImageInfo *,Image *);
typedef MagickBooleanType
IsImageFormatHandler(const unsigned char *,const size_t);
typedef struct _MagickInfo
{
char
*name,
*description,
*version,
*note,
*magick_module;
ImageInfo
*image_info;
DecodeImageHandler
*decoder;
EncodeImageHandler
*encoder;
IsImageFormatHandler
*magick;
void
*client_data;
MagickBooleanType
adjoin,
raw,
endian_support,
blob_support,
seekable_stream;
MagickFormatType
format_type;
MagickStatusType
thread_support;
MagickBooleanType
stealth;
struct _MagickInfo
*previous,
*next; /* deprecated, use GetMagickInfoList() */
size_t
signature;
char
*mime_type;
SemaphoreInfo
*semaphore;
} MagickInfo;
extern MagickExport char
**GetMagickList(const char *,size_t *,ExceptionInfo *);
extern MagickExport const char
*GetMagickDescription(const MagickInfo *),
*GetMagickMimeType(const MagickInfo *);
extern MagickExport DecodeImageHandler
*GetImageDecoder(const MagickInfo *) magick_attribute((__pure__));
extern MagickExport EncodeImageHandler
*GetImageEncoder(const MagickInfo *) magick_attribute((__pure__));
extern MagickExport int
GetMagickPrecision(void),
SetMagickPrecision(const int);
extern MagickExport MagickBooleanType
GetImageMagick(const unsigned char *,const size_t,char *),
GetMagickAdjoin(const MagickInfo *) magick_attribute((__pure__)),
GetMagickBlobSupport(const MagickInfo *) magick_attribute((__pure__)),
GetMagickEndianSupport(const MagickInfo *) magick_attribute((__pure__)),
GetMagickRawSupport(const MagickInfo *) magick_attribute((__pure__)),
GetMagickSeekableStream(const MagickInfo *) magick_attribute((__pure__)),
IsMagickCoreInstantiated(void) magick_attribute((__pure__)),
MagickComponentGenesis(void),
UnregisterMagickInfo(const char *);
extern const MagickExport MagickInfo
*GetMagickInfo(const char *,ExceptionInfo *),
**GetMagickInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport MagickInfo
*RegisterMagickInfo(MagickInfo *),
*SetMagickInfo(const char *);
extern MagickExport MagickStatusType
GetMagickThreadSupport(const MagickInfo *);
extern MagickExport void
MagickComponentTerminus(void),
MagickCoreGenesis(const char *,const MagickBooleanType),
MagickCoreTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/cipher.h 0000644 00000002150 14751151177 0007431 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore cipher methods.
*/
#ifndef MAGICKCORE_CIPHER_H
#define MAGICKCORE_CIPHER_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
DecipherImage(Image *,const char *,ExceptionInfo *),
EncipherImage(Image *,const char *,ExceptionInfo *),
PasskeyDecipherImage(Image *,const StringInfo *,ExceptionInfo *),
PasskeyEncipherImage(Image *,const StringInfo *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/geometry.h 0000644 00000010004 14751151177 0010007 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image geometry methods.
*/
#ifndef MAGICKCORE_GEOMETRY_H
#define MAGICKCORE_GEOMETRY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
#undef NoValue
NoValue = 0x0000,
#undef XValue
XValue = 0x0001,
XiValue = 0x0001,
#undef YValue
YValue = 0x0002,
PsiValue = 0x0002,
#undef WidthValue
WidthValue = 0x0004,
RhoValue = 0x0004,
#undef HeightValue
HeightValue = 0x0008,
SigmaValue = 0x0008,
ChiValue = 0x0010,
XiNegative = 0x0020,
#undef XNegative
XNegative = 0x0020,
PsiNegative = 0x0040,
#undef YNegative
YNegative = 0x0040,
ChiNegative = 0x0080,
PercentValue = 0x1000, /* '%' percentage of something */
AspectValue = 0x2000, /* '!' resize no-aspect - special use flag */
NormalizeValue = 0x2000, /* '!' ScaleKernelValue() in morphology.c */
LessValue = 0x4000, /* '<' resize smaller - special use flag */
GreaterValue = 0x8000, /* '>' resize larger - spacial use flag */
MinimumValue = 0x10000, /* '^' special handling needed */
CorrelateNormalizeValue = 0x10000, /* '^' see ScaleKernelValue() */
AreaValue = 0x20000, /* '@' resize to area - special use flag */
DecimalValue = 0x40000, /* '.' floating point numbers found */
SeparatorValue = 0x80000, /* 'x' separator found */
AspectRatioValue = 0x100000, /* '~' special handling needed */
AlphaValue = 0x200000, /* '/' alpha */
#undef AllValues
AllValues = 0x7fffffff
} GeometryFlags;
#if defined(ForgetGravity)
#undef ForgetGravity
#undef NorthWestGravity
#undef NorthGravity
#undef NorthEastGravity
#undef WestGravity
#undef CenterGravity
#undef EastGravity
#undef SouthWestGravity
#undef SouthGravity
#undef SouthEastGravity
#undef StaticGravity
#endif
typedef enum
{
UndefinedGravity,
ForgetGravity = 0,
NorthWestGravity = 1,
NorthGravity = 2,
NorthEastGravity = 3,
WestGravity = 4,
CenterGravity = 5,
EastGravity = 6,
SouthWestGravity = 7,
SouthGravity = 8,
SouthEastGravity = 9,
StaticGravity = 10
} GravityType;
typedef struct _AffineMatrix
{
double
sx,
rx,
ry,
sy,
tx,
ty;
} AffineMatrix;
typedef struct _GeometryInfo
{
double
rho,
sigma,
xi,
psi,
chi;
} GeometryInfo;
typedef struct _OffsetInfo
{
ssize_t
x,
y;
} OffsetInfo;
typedef struct _RectangleInfo
{
size_t
width,
height;
ssize_t
x,
y;
} RectangleInfo;
extern MagickExport char
*GetPageGeometry(const char *);
extern MagickExport MagickBooleanType
IsGeometry(const char *),
IsSceneGeometry(const char *,const MagickBooleanType);
extern MagickExport MagickStatusType
GetGeometry(const char *,ssize_t *,ssize_t *,size_t *,size_t *),
ParseAbsoluteGeometry(const char *,RectangleInfo *),
ParseAffineGeometry(const char *,AffineMatrix *,ExceptionInfo *),
ParseGeometry(const char *,GeometryInfo *),
ParseGravityGeometry(const Image *,const char *,RectangleInfo *,
ExceptionInfo *),
ParseMetaGeometry(const char *,ssize_t *,ssize_t *,size_t *,size_t *),
ParsePageGeometry(const Image *,const char *,RectangleInfo *,ExceptionInfo *),
ParseRegionGeometry(const Image *,const char *,RectangleInfo *,
ExceptionInfo *);
extern MagickExport void
GravityAdjustGeometry(const size_t,const size_t,const GravityType,
RectangleInfo *),
SetGeometry(const Image *,RectangleInfo *),
SetGeometryInfo(GeometryInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/methods.h 0000644 00000330005 14751151177 0007625 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore API methods prefix.
nm -p magick/.libs/libMagickCore-6.Q16.a | grep ' T ' | \
egrep -v '(MagickError)|(MagickFatalError)|(MagickWarning)|(ThrowException)' | \
awk '{ printf("#define %s PrependMagickMethod(%s)\n", $3, $3); }' | sort
*/
#ifndef MAGICKCORE_METHOD_H
#define MAGICKCORE_METHOD_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if defined(MAGICKCORE_NAMESPACE_PREFIX)
#if defined(__STDC__)
#define PrescanMagickPrefix(prefix,method) prefix ## method
#else
#define PrescanMagickPrefix(prefix,method) prefix(method)
#endif
#define EvaluateMagickPrefix(prefix,method) PrescanMagickPrefix(prefix,method)
#define PrependMagickMethod(method) \
EvaluateMagickPrefix(MAGICKCORE_NAMESPACE_PREFIX,method)
#define AcquireAlignedMemory PrependMagickMethod(AcquireAlignedMemory)
#define AcquireAuthenticCacheView PrependMagickMethod(AcquireAuthenticCacheView)
#define AcquireCacheViewIndexes PrependMagickMethod(AcquireCacheViewIndexes)
#define AcquireCacheViewPixels PrependMagickMethod(AcquireCacheViewPixels)
#define AcquireCacheView PrependMagickMethod(AcquireCacheView)
#define AcquireCriticalMemory PrependMagickMethod(AcquireCriticalMemory)
#define AcquireDistributeCacheInfo PrependMagickMethod(AcquireDistributeCacheInfo)
#define AcquireDrawInfo PrependMagickMethod(AcquireDrawInfo)
#define AcquireExceptionInfo PrependMagickMethod(AcquireExceptionInfo)
#define AcquireFxInfo PrependMagickMethod(AcquireFxInfo)
#define AcquireImageColormap PrependMagickMethod(AcquireImageColormap)
#define AcquireImageInfo PrependMagickMethod(AcquireImageInfo)
#define AcquireImagePixels PrependMagickMethod(AcquireImagePixels)
#define AcquireImage PrependMagickMethod(AcquireImage)
#define AcquireIndexes PrependMagickMethod(AcquireIndexes)
#define AcquireKernelBuiltIn PrependMagickMethod(AcquireKernelBuiltIn)
#define AcquireKernelInfo PrependMagickMethod(AcquireKernelInfo)
#define AcquireMagickMatrix PrependMagickMethod(AcquireMagickMatrix)
#define AcquireMagickMemory PrependMagickMethod(AcquireMagickMemory)
#define AcquireMagickResource PrependMagickMethod(AcquireMagickResource)
#define AcquireMatrixInfo PrependMagickMethod(AcquireMatrixInfo)
#define AcquireMemory PrependMagickMethod(AcquireMemory)
#define AcquireNextImage PrependMagickMethod(AcquireNextImage)
#define AcquireOneCacheViewPixel PrependMagickMethod(AcquireOneCacheViewPixel)
#define AcquireOneCacheViewVirtualPixel PrependMagickMethod(AcquireOneCacheViewVirtualPixel)
#define AcquireOneMagickPixel PrependMagickMethod(AcquireOneMagickPixel)
#define AcquireOnePixel PrependMagickMethod(AcquireOnePixel)
#define AcquireOneVirtualPixel PrependMagickMethod(AcquireOneVirtualPixel)
#define AcquirePixelCacheNexus PrependMagickMethod(AcquirePixelCacheNexus)
#define AcquirePixelCachePixels PrependMagickMethod(AcquirePixelCachePixels)
#define AcquirePixelCache PrependMagickMethod(AcquirePixelCache)
#define AcquirePixels PrependMagickMethod(AcquirePixels)
#define AcquireQuantizeInfo PrependMagickMethod(AcquireQuantizeInfo)
#define AcquireQuantumInfo PrependMagickMethod(AcquireQuantumInfo)
#define AcquireQuantumMemory PrependMagickMethod(AcquireQuantumMemory)
#define AcquireRandomInfo PrependMagickMethod(AcquireRandomInfo)
#define AcquireResampleFilter PrependMagickMethod(AcquireResampleFilter)
#define AcquireResizeFilter PrependMagickMethod(AcquireResizeFilter)
#define AcquireSemaphoreInfo PrependMagickMethod(AcquireSemaphoreInfo)
#define AcquireSignatureInfo PrependMagickMethod(AcquireSignatureInfo)
#define AcquireStreamInfo PrependMagickMethod(AcquireStreamInfo)
#define AcquireStringInfo PrependMagickMethod(AcquireStringInfo)
#define AcquireString PrependMagickMethod(AcquireString)
#define AcquireTimerInfo PrependMagickMethod(AcquireTimerInfo)
#define AcquireTokenInfo PrependMagickMethod(AcquireTokenInfo)
#define AcquireUniqueFilename PrependMagickMethod(AcquireUniqueFilename)
#define AcquireUniqueFileResource PrependMagickMethod(AcquireUniqueFileResource)
#define AcquireUniqueSymbolicLink PrependMagickMethod(AcquireUniqueSymbolicLink)
#define AcquireVirtualCacheView PrependMagickMethod(AcquireVirtualCacheView)
#define AcquireVirtualMemory PrependMagickMethod(AcquireVirtualMemory)
#define ActivateSemaphoreInfo PrependMagickMethod(ActivateSemaphoreInfo)
#define AdaptiveBlurImageChannel PrependMagickMethod(AdaptiveBlurImageChannel)
#define AdaptiveBlurImage PrependMagickMethod(AdaptiveBlurImage)
#define AdaptiveResizeImage PrependMagickMethod(AdaptiveResizeImage)
#define AdaptiveSharpenImageChannel PrependMagickMethod(AdaptiveSharpenImageChannel)
#define AdaptiveSharpenImage PrependMagickMethod(AdaptiveSharpenImage)
#define AdaptiveThresholdImage PrependMagickMethod(AdaptiveThresholdImage)
#define AddChildToXMLTree PrependMagickMethod(AddChildToXMLTree)
#define AddNoiseImageChannel PrependMagickMethod(AddNoiseImageChannel)
#define AddNoiseImage PrependMagickMethod(AddNoiseImage)
#define AddPathToXMLTree PrependMagickMethod(AddPathToXMLTree)
#define AddValueToSplayTree PrependMagickMethod(AddValueToSplayTree)
#define AffineTransformImage PrependMagickMethod(AffineTransformImage)
#define AffinityImage PrependMagickMethod(AffinityImage)
#define AffinityImages PrependMagickMethod(AffinityImages)
#define AllocateImageColormap PrependMagickMethod(AllocateImageColormap)
#define AllocateImage PrependMagickMethod(AllocateImage)
#define AllocateNextImage PrependMagickMethod(AllocateNextImage)
#define AllocateSemaphoreInfo PrependMagickMethod(AllocateSemaphoreInfo)
#define AllocateString PrependMagickMethod(AllocateString)
#define analyzeImage PrependMagickMethod(analyzeImage)
#define AnimateImages PrependMagickMethod(AnimateImages)
#define AnnotateComponentGenesis PrependMagickMethod(AnnotateComponentGenesis)
#define AnnotateComponentTerminus PrependMagickMethod(AnnotateComponentTerminus)
#define AnnotateImage PrependMagickMethod(AnnotateImage)
#define AppendImageFormat PrependMagickMethod(AppendImageFormat)
#define AppendImages PrependMagickMethod(AppendImages)
#define AppendImageToList PrependMagickMethod(AppendImageToList)
#define AppendValueToLinkedList PrependMagickMethod(AppendValueToLinkedList)
#define Ascii85Encode PrependMagickMethod(Ascii85Encode)
#define Ascii85Flush PrependMagickMethod(Ascii85Flush)
#define Ascii85Initialize PrependMagickMethod(Ascii85Initialize)
#define AsynchronousResourceComponentTerminus PrependMagickMethod(AsynchronousResourceComponentTerminus)
#define AttachBlob PrependMagickMethod(AttachBlob)
#define AutoGammaImageChannel PrependMagickMethod(AutoGammaImageChannel)
#define AutoGammaImage PrependMagickMethod(AutoGammaImage)
#define AutoLevelImageChannel PrependMagickMethod(AutoLevelImageChannel)
#define AutoLevelImage PrependMagickMethod(AutoLevelImage)
#define AutoOrientImage PrependMagickMethod(AutoOrientImage)
#define AutoThresholdImage PrependMagickMethod(AutoThresholdImage)
#define AverageImages PrependMagickMethod(AverageImages)
#define Base64Decode PrependMagickMethod(Base64Decode)
#define Base64Encode PrependMagickMethod(Base64Encode)
#define BilevelImageChannel PrependMagickMethod(BilevelImageChannel)
#define BilevelImage PrependMagickMethod(BilevelImage)
#define BlackThresholdImageChannel PrependMagickMethod(BlackThresholdImageChannel)
#define BlackThresholdImage PrependMagickMethod(BlackThresholdImage)
#define BlobToFile PrependMagickMethod(BlobToFile)
#define BlobToImage PrependMagickMethod(BlobToImage)
#define BlobToStringInfo PrependMagickMethod(BlobToStringInfo)
#define BlueShiftImage PrependMagickMethod(BlueShiftImage)
#define BlurImageChannel PrependMagickMethod(BlurImageChannel)
#define BlurImage PrependMagickMethod(BlurImage)
#define BorderImage PrependMagickMethod(BorderImage)
#define BrightnessContrastImageChannel PrependMagickMethod(BrightnessContrastImageChannel)
#define BrightnessContrastImage PrependMagickMethod(BrightnessContrastImage)
#define CacheComponentGenesis PrependMagickMethod(CacheComponentGenesis)
#define CacheComponentTerminus PrependMagickMethod(CacheComponentTerminus)
#define CannyEdgeImage PrependMagickMethod(CannyEdgeImage)
#define CanonicalXMLContent PrependMagickMethod(CanonicalXMLContent)
#define CatchException PrependMagickMethod(CatchException)
#define CatchImageException PrependMagickMethod(CatchImageException)
#define ChannelImage PrependMagickMethod(ChannelImage)
#define ChannelThresholdImage PrependMagickMethod(ChannelThresholdImage)
#define CharcoalImage PrependMagickMethod(CharcoalImage)
#define ChopImage PrependMagickMethod(ChopImage)
#define ChopPathComponents PrependMagickMethod(ChopPathComponents)
#define ClampImageChannel PrependMagickMethod(ClampImageChannel)
#define ClampImage PrependMagickMethod(ClampImage)
#define ClearExceptionInfo PrependMagickMethod(ClearExceptionInfo)
#define ClearLinkedList PrependMagickMethod(ClearLinkedList)
#define ClearMagickException PrependMagickMethod(ClearMagickException)
#define ClipImagePath PrependMagickMethod(ClipImagePath)
#define ClipImage PrependMagickMethod(ClipImage)
#define ClipPathImage PrependMagickMethod(ClipPathImage)
#define CloneBlobInfo PrependMagickMethod(CloneBlobInfo)
#define CloneCacheView PrependMagickMethod(CloneCacheView)
#define CloneDrawInfo PrependMagickMethod(CloneDrawInfo)
#define CloneExceptionInfo PrependMagickMethod(CloneExceptionInfo)
#define CloneImageArtifacts PrependMagickMethod(CloneImageArtifacts)
#define CloneImageAttributes PrependMagickMethod(CloneImageAttributes)
#define CloneImageInfo PrependMagickMethod(CloneImageInfo)
#define CloneImageList PrependMagickMethod(CloneImageList)
#define CloneImageOptions PrependMagickMethod(CloneImageOptions)
#define CloneImage PrependMagickMethod(CloneImage)
#define CloneImageProfiles PrependMagickMethod(CloneImageProfiles)
#define CloneImageProperties PrependMagickMethod(CloneImageProperties)
#define CloneImages PrependMagickMethod(CloneImages)
#define CloneImageView PrependMagickMethod(CloneImageView)
#define CloneKernelInfo PrependMagickMethod(CloneKernelInfo)
#define CloneMagickPixelPacket PrependMagickMethod(CloneMagickPixelPacket)
#define CloneMemory PrependMagickMethod(CloneMemory)
#define CloneMontageInfo PrependMagickMethod(CloneMontageInfo)
#define ClonePixelCacheMethods PrependMagickMethod(ClonePixelCacheMethods)
#define ClonePixelCache PrependMagickMethod(ClonePixelCache)
#define CloneQuantizeInfo PrependMagickMethod(CloneQuantizeInfo)
#define CloneSplayTree PrependMagickMethod(CloneSplayTree)
#define CloneStringInfo PrependMagickMethod(CloneStringInfo)
#define CloneString PrependMagickMethod(CloneString)
#define CloseBlob PrependMagickMethod(CloseBlob)
#define CloseCacheView PrependMagickMethod(CloseCacheView)
#define CloseMagickLog PrependMagickMethod(CloseMagickLog)
#define ClutImageChannel PrependMagickMethod(ClutImageChannel)
#define ClutImage PrependMagickMethod(ClutImage)
#define CoalesceImages PrependMagickMethod(CoalesceImages)
#define CoderComponentGenesis PrependMagickMethod(CoderComponentGenesis)
#define CoderComponentTerminus PrependMagickMethod(CoderComponentTerminus)
#define ColorComponentGenesis PrependMagickMethod(ColorComponentGenesis)
#define ColorComponentTerminus PrependMagickMethod(ColorComponentTerminus)
#define ColorDecisionListImage PrependMagickMethod(ColorDecisionListImage)
#define ColorFloodfillImage PrependMagickMethod(ColorFloodfillImage)
#define ColorizeImage PrependMagickMethod(ColorizeImage)
#define ColorMatrixImage PrependMagickMethod(ColorMatrixImage)
#define CombineImages PrependMagickMethod(CombineImages)
#define CommandOptionToMnemonic PrependMagickMethod(CommandOptionToMnemonic)
#define CompareHashmapStringInfo PrependMagickMethod(CompareHashmapStringInfo)
#define CompareHashmapString PrependMagickMethod(CompareHashmapString)
#define CompareImageChannels PrependMagickMethod(CompareImageChannels)
#define CompareImageLayers PrependMagickMethod(CompareImageLayers)
#define CompareImages PrependMagickMethod(CompareImages)
#define CompareSplayTreeStringInfo PrependMagickMethod(CompareSplayTreeStringInfo)
#define CompareSplayTreeString PrependMagickMethod(CompareSplayTreeString)
#define CompareStringInfo PrependMagickMethod(CompareStringInfo)
#define ComplexImages PrependMagickMethod(ComplexImages)
#define CompositeImageChannel PrependMagickMethod(CompositeImageChannel)
#define CompositeImage PrependMagickMethod(CompositeImage)
#define CompositeLayers PrependMagickMethod(CompositeLayers)
#define CompressImageColormap PrependMagickMethod(CompressImageColormap)
#define ConcatenateColorComponent PrependMagickMethod(ConcatenateColorComponent)
#define ConcatenateMagickString PrependMagickMethod(ConcatenateMagickString)
#define ConcatenateStringInfo PrependMagickMethod(ConcatenateStringInfo)
#define ConcatenateString PrependMagickMethod(ConcatenateString)
#define ConfigureComponentGenesis PrependMagickMethod(ConfigureComponentGenesis)
#define ConfigureComponentTerminus PrependMagickMethod(ConfigureComponentTerminus)
#define ConfigureFileToStringInfo PrependMagickMethod(ConfigureFileToStringInfo)
#define ConformMagickPixelPacket PrependMagickMethod(ConformMagickPixelPacket)
#define ConnectedComponentsImage PrependMagickMethod(ConnectedComponentsImage)
#define ConsolidateCMYKImages PrependMagickMethod(ConsolidateCMYKImages)
#define ConstantString PrependMagickMethod(ConstantString)
#define ConstituteComponentGenesis PrependMagickMethod(ConstituteComponentGenesis)
#define ConstituteComponentTerminus PrependMagickMethod(ConstituteComponentTerminus)
#define ConstituteImage PrependMagickMethod(ConstituteImage)
#define ContinueTimer PrependMagickMethod(ContinueTimer)
#define ContrastImage PrependMagickMethod(ContrastImage)
#define ContrastStretchImageChannel PrependMagickMethod(ContrastStretchImageChannel)
#define ContrastStretchImage PrependMagickMethod(ContrastStretchImage)
#define ConvertHCLpToRGB PrependMagickMethod(ConvertHCLpToRGB)
#define ConvertHCLToRGB PrependMagickMethod(ConvertHCLToRGB)
#define ConvertHSBToRGB PrependMagickMethod(ConvertHSBToRGB)
#define ConvertHSIToRGB PrependMagickMethod(ConvertHSIToRGB)
#define ConvertHSLToRGB PrependMagickMethod(ConvertHSLToRGB)
#define ConvertHSVToRGB PrependMagickMethod(ConvertHSVToRGB)
#define ConvertHWBToRGB PrependMagickMethod(ConvertHWBToRGB)
#define ConvertLCHabToRGB PrependMagickMethod(ConvertLCHabToRGB)
#define ConvertLCHuvToRGB PrependMagickMethod(ConvertLCHuvToRGB)
#define ConvertRGBToHCLp PrependMagickMethod(ConvertRGBToHCLp)
#define ConvertRGBToHCL PrependMagickMethod(ConvertRGBToHCL)
#define ConvertRGBToHSB PrependMagickMethod(ConvertRGBToHSB)
#define ConvertRGBToHSI PrependMagickMethod(ConvertRGBToHSI)
#define ConvertRGBToHSL PrependMagickMethod(ConvertRGBToHSL)
#define ConvertRGBToHSV PrependMagickMethod(ConvertRGBToHSV)
#define ConvertRGBToHWB PrependMagickMethod(ConvertRGBToHWB)
#define ConvertRGBToLCHab PrependMagickMethod(ConvertRGBToLCHab)
#define ConvertRGBToLCHuv PrependMagickMethod(ConvertRGBToLCHuv)
#define ConvolveImageChannel PrependMagickMethod(ConvolveImageChannel)
#define ConvolveImage PrependMagickMethod(ConvolveImage)
#define CopyImagePixels PrependMagickMethod(CopyImagePixels)
#define CopyMagickMemory PrependMagickMethod(CopyMagickMemory)
#define CopyMagickString PrependMagickMethod(CopyMagickString)
#define CreateMagickThreadKey PrependMagickMethod(CreateMagickThreadKey)
#define CropImage PrependMagickMethod(CropImage)
#define CropImageToTiles PrependMagickMethod(CropImageToTiles)
#define CycleColormapImage PrependMagickMethod(CycleColormapImage)
#define DecipherImage PrependMagickMethod(DecipherImage)
#define DecodePixelGamma PrependMagickMethod(DecodePixelGamma)
#define DeconstructImages PrependMagickMethod(DeconstructImages)
#define DefineImageArtifact PrependMagickMethod(DefineImageArtifact)
#define DefineImageOption PrependMagickMethod(DefineImageOption)
#define DefineImageProperty PrependMagickMethod(DefineImageProperty)
#define DefineImageRegistry PrependMagickMethod(DefineImageRegistry)
#define DelegateComponentGenesis PrependMagickMethod(DelegateComponentGenesis)
#define DelegateComponentTerminus PrependMagickMethod(DelegateComponentTerminus)
#define DeleteImageArtifact PrependMagickMethod(DeleteImageArtifact)
#define DeleteImageAttribute PrependMagickMethod(DeleteImageAttribute)
#define DeleteImageFromList PrependMagickMethod(DeleteImageFromList)
#define DeleteImageList PrependMagickMethod(DeleteImageList)
#define DeleteImageOption PrependMagickMethod(DeleteImageOption)
#define DeleteImageProfile PrependMagickMethod(DeleteImageProfile)
#define DeleteImageProperty PrependMagickMethod(DeleteImageProperty)
#define DeleteImageRegistry PrependMagickMethod(DeleteImageRegistry)
#define DeleteImages PrependMagickMethod(DeleteImages)
#define DeleteMagickRegistry PrependMagickMethod(DeleteMagickRegistry)
#define DeleteMagickThreadKey PrependMagickMethod(DeleteMagickThreadKey)
#define DeleteNodeByValueFromSplayTree PrependMagickMethod(DeleteNodeByValueFromSplayTree)
#define DeleteNodeFromSplayTree PrependMagickMethod(DeleteNodeFromSplayTree)
#define DescribeImage PrependMagickMethod(DescribeImage)
#define DeskewImage PrependMagickMethod(DeskewImage)
#define DespeckleImage PrependMagickMethod(DespeckleImage)
#define DestroyBlob PrependMagickMethod(DestroyBlob)
#define DestroyCacheView PrependMagickMethod(DestroyCacheView)
#define DestroyConfigureOptions PrependMagickMethod(DestroyConfigureOptions)
#define DestroyConstitute PrependMagickMethod(DestroyConstitute)
#define DestroyDistributeCacheInfo PrependMagickMethod(DestroyDistributeCacheInfo)
#define DestroyDrawInfo PrependMagickMethod(DestroyDrawInfo)
#define DestroyExceptionInfo PrependMagickMethod(DestroyExceptionInfo)
#define DestroyFxInfo PrependMagickMethod(DestroyFxInfo)
#define DestroyHashmap PrependMagickMethod(DestroyHashmap)
#define DestroyImageArtifacts PrependMagickMethod(DestroyImageArtifacts)
#define DestroyImageAttributes PrependMagickMethod(DestroyImageAttributes)
#define DestroyImageInfo PrependMagickMethod(DestroyImageInfo)
#define DestroyImageList PrependMagickMethod(DestroyImageList)
#define DestroyImageOptions PrependMagickMethod(DestroyImageOptions)
#define DestroyImagePixels PrependMagickMethod(DestroyImagePixels)
#define DestroyImage PrependMagickMethod(DestroyImage)
#define DestroyImageProfiles PrependMagickMethod(DestroyImageProfiles)
#define DestroyImageProperties PrependMagickMethod(DestroyImageProperties)
#define DestroyImages PrependMagickMethod(DestroyImages)
#define DestroyImageView PrependMagickMethod(DestroyImageView)
#define DestroyKernelInfo PrependMagickMethod(DestroyKernelInfo)
#define DestroyLinkedList PrependMagickMethod(DestroyLinkedList)
#define DestroyLocaleOptions PrependMagickMethod(DestroyLocaleOptions)
#define DestroyMagickMemory PrependMagickMethod(DestroyMagickMemory)
#define DestroyMagick PrependMagickMethod(DestroyMagick)
#define DestroyMagickRegistry PrependMagickMethod(DestroyMagickRegistry)
#define DestroyMatrixInfo PrependMagickMethod(DestroyMatrixInfo)
#define DestroyMontageInfo PrependMagickMethod(DestroyMontageInfo)
#define DestroyPixelCacheNexus PrependMagickMethod(DestroyPixelCacheNexus)
#define DestroyPixelCache PrependMagickMethod(DestroyPixelCache)
#define DestroyQuantizeInfo PrependMagickMethod(DestroyQuantizeInfo)
#define DestroyQuantumInfo PrependMagickMethod(DestroyQuantumInfo)
#define DestroyRandomInfo PrependMagickMethod(DestroyRandomInfo)
#define DestroyResampleFilter PrependMagickMethod(DestroyResampleFilter)
#define DestroyResizeFilter PrependMagickMethod(DestroyResizeFilter)
#define DestroySemaphoreInfo PrependMagickMethod(DestroySemaphoreInfo)
#define DestroySignatureInfo PrependMagickMethod(DestroySignatureInfo)
#define DestroySplayTree PrependMagickMethod(DestroySplayTree)
#define DestroyStreamInfo PrependMagickMethod(DestroyStreamInfo)
#define DestroyStringInfo PrependMagickMethod(DestroyStringInfo)
#define DestroyStringList PrependMagickMethod(DestroyStringList)
#define DestroyString PrependMagickMethod(DestroyString)
#define DestroyThresholdMap PrependMagickMethod(DestroyThresholdMap)
#define DestroyTimerInfo PrependMagickMethod(DestroyTimerInfo)
#define DestroyTokenInfo PrependMagickMethod(DestroyTokenInfo)
#define DestroyXMLTree PrependMagickMethod(DestroyXMLTree)
#define DestroyXResources PrependMagickMethod(DestroyXResources)
#define DestroyXWidget PrependMagickMethod(DestroyXWidget)
#define DetachBlob PrependMagickMethod(DetachBlob)
#define DisassociateBlob PrependMagickMethod(DisassociateBlob)
#define DisassociateImageStream PrependMagickMethod(DisassociateImageStream)
#define DiscardBlobBytes PrependMagickMethod(DiscardBlobBytes)
#define DispatchImage PrependMagickMethod(DispatchImage)
#define DisplayImages PrependMagickMethod(DisplayImages)
#define DisposeImages PrependMagickMethod(DisposeImages)
#define DistortImage PrependMagickMethod(DistortImage)
#define DistortResizeImage PrependMagickMethod(DistortResizeImage)
#define DistributePixelCacheServer PrependMagickMethod(DistributePixelCacheServer)
#define DrawAffineImage PrependMagickMethod(DrawAffineImage)
#define DrawClipPath PrependMagickMethod(DrawClipPath)
#define DrawGradientImage PrependMagickMethod(DrawGradientImage)
#define DrawImage PrependMagickMethod(DrawImage)
#define DrawPatternPath PrependMagickMethod(DrawPatternPath)
#define DrawPrimitive PrependMagickMethod(DrawPrimitive)
#define DuplexTransferImageViewIterator PrependMagickMethod(DuplexTransferImageViewIterator)
#define DuplicateBlob PrependMagickMethod(DuplicateBlob)
#define DuplicateImages PrependMagickMethod(DuplicateImages)
#define EdgeImage PrependMagickMethod(EdgeImage)
#define EmbossImage PrependMagickMethod(EmbossImage)
#define EncipherImage PrependMagickMethod(EncipherImage)
#define EncodePixelGamma PrependMagickMethod(EncodePixelGamma)
#define EnhanceImage PrependMagickMethod(EnhanceImage)
#define EOFBlob PrependMagickMethod(EOFBlob)
#define EqualizeImageChannel PrependMagickMethod(EqualizeImageChannel)
#define EqualizeImage PrependMagickMethod(EqualizeImage)
#define ErrorBlob PrependMagickMethod(ErrorBlob)
#define EscapeString PrependMagickMethod(EscapeString)
#define EvaluateImageChannel PrependMagickMethod(EvaluateImageChannel)
#define EvaluateImage PrependMagickMethod(EvaluateImage)
#define EvaluateImages PrependMagickMethod(EvaluateImages)
#define ExceptionComponentGenesis PrependMagickMethod(ExceptionComponentGenesis)
#define ExceptionComponentTerminus PrependMagickMethod(ExceptionComponentTerminus)
#define ExcerptImage PrependMagickMethod(ExcerptImage)
#define ExpandAffine PrependMagickMethod(ExpandAffine)
#define ExpandFilename PrependMagickMethod(ExpandFilename)
#define ExpandFilenames PrependMagickMethod(ExpandFilenames)
#define ExportImagePixels PrependMagickMethod(ExportImagePixels)
#define ExportQuantumPixels PrependMagickMethod(ExportQuantumPixels)
#define ExtentImage PrependMagickMethod(ExtentImage)
#define ExternalDelegateCommand PrependMagickMethod(ExternalDelegateCommand)
#define ExtractSubimageFromImage PrependMagickMethod(ExtractSubimageFromImage)
#define FileToBlob PrependMagickMethod(FileToBlob)
#define FileToImage PrependMagickMethod(FileToImage)
#define FileToStringInfo PrependMagickMethod(FileToStringInfo)
#define FileToString PrependMagickMethod(FileToString)
#define FileToXML PrependMagickMethod(FileToXML)
#define FilterImageChannel PrependMagickMethod(FilterImageChannel)
#define FilterImage PrependMagickMethod(FilterImage)
#define FinalizeSignature PrependMagickMethod(FinalizeSignature)
#define FlattenImages PrependMagickMethod(FlattenImages)
#define FlipImage PrependMagickMethod(FlipImage)
#define FloodfillPaintImage PrependMagickMethod(FloodfillPaintImage)
#define FlopImage PrependMagickMethod(FlopImage)
#define FormatImageAttributeList PrependMagickMethod(FormatImageAttributeList)
#define FormatImageAttribute PrependMagickMethod(FormatImageAttribute)
#define FormatImagePropertyList PrependMagickMethod(FormatImagePropertyList)
#define FormatImageProperty PrependMagickMethod(FormatImageProperty)
#define FormatLocaleFileList PrependMagickMethod(FormatLocaleFileList)
#define FormatLocaleFile PrependMagickMethod(FormatLocaleFile)
#define FormatLocaleStringList PrependMagickMethod(FormatLocaleStringList)
#define FormatLocaleString PrependMagickMethod(FormatLocaleString)
#define FormatMagickCaption PrependMagickMethod(FormatMagickCaption)
#define FormatMagickSize PrependMagickMethod(FormatMagickSize)
#define FormatMagickStringList PrependMagickMethod(FormatMagickStringList)
#define FormatMagickString PrependMagickMethod(FormatMagickString)
#define FormatMagickTime PrependMagickMethod(FormatMagickTime)
#define FormatStringList PrependMagickMethod(FormatStringList)
#define FormatString PrependMagickMethod(FormatString)
#define ForwardFourierTransformImage PrependMagickMethod(ForwardFourierTransformImage)
#define FrameImage PrependMagickMethod(FrameImage)
#define FunctionImageChannel PrependMagickMethod(FunctionImageChannel)
#define FunctionImage PrependMagickMethod(FunctionImage)
#define FuzzyColorCompare PrependMagickMethod(FuzzyColorCompare)
#define FuzzyColorMatch PrependMagickMethod(FuzzyColorMatch)
#define FuzzyOpacityCompare PrependMagickMethod(FuzzyOpacityCompare)
#define FxEvaluateChannelExpression PrependMagickMethod(FxEvaluateChannelExpression)
#define FxEvaluateExpression PrependMagickMethod(FxEvaluateExpression)
#define FxImageChannel PrependMagickMethod(FxImageChannel)
#define FxImage PrependMagickMethod(FxImage)
#define FxPreprocessExpression PrependMagickMethod(FxPreprocessExpression)
#define GammaImageChannel PrependMagickMethod(GammaImageChannel)
#define GammaImage PrependMagickMethod(GammaImage)
#define GaussianBlurImageChannel PrependMagickMethod(GaussianBlurImageChannel)
#define GaussianBlurImage PrependMagickMethod(GaussianBlurImage)
#define GaussJordanElimination PrependMagickMethod(GaussJordanElimination)
#define GenerateDifferentialNoise PrependMagickMethod(GenerateDifferentialNoise)
#define GetAffineMatrix PrependMagickMethod(GetAffineMatrix)
#define GetAuthenticIndexQueue PrependMagickMethod(GetAuthenticIndexQueue)
#define GetAuthenticPixelCacheNexus PrependMagickMethod(GetAuthenticPixelCacheNexus)
#define GetAuthenticPixelQueue PrependMagickMethod(GetAuthenticPixelQueue)
#define GetAuthenticPixels PrependMagickMethod(GetAuthenticPixels)
#define GetBlobError PrependMagickMethod(GetBlobError)
#define GetBlobFileHandle PrependMagickMethod(GetBlobFileHandle)
#define GetBlobInfo PrependMagickMethod(GetBlobInfo)
#define GetBlobProperties PrependMagickMethod(GetBlobProperties)
#define GetBlobSize PrependMagickMethod(GetBlobSize)
#define GetBlobStreamData PrependMagickMethod(GetBlobStreamData)
#define GetBlobStreamHandler PrependMagickMethod(GetBlobStreamHandler)
#define GetCacheViewAuthenticIndexQueue PrependMagickMethod(GetCacheViewAuthenticIndexQueue)
#define GetCacheViewAuthenticPixelQueue PrependMagickMethod(GetCacheViewAuthenticPixelQueue)
#define GetCacheViewAuthenticPixels PrependMagickMethod(GetCacheViewAuthenticPixels)
#define GetCacheViewChannels PrependMagickMethod(GetCacheViewChannels)
#define GetCacheViewColorspace PrependMagickMethod(GetCacheViewColorspace)
#define GetCacheViewException PrependMagickMethod(GetCacheViewException)
#define GetCacheViewExtent PrependMagickMethod(GetCacheViewExtent)
#define GetCacheViewIndexes PrependMagickMethod(GetCacheViewIndexes)
#define GetCacheViewPixels PrependMagickMethod(GetCacheViewPixels)
#define GetCacheView PrependMagickMethod(GetCacheView)
#define GetCacheViewStorageClass PrependMagickMethod(GetCacheViewStorageClass)
#define GetCacheViewVirtualIndexQueue PrependMagickMethod(GetCacheViewVirtualIndexQueue)
#define GetCacheViewVirtualPixelQueue PrependMagickMethod(GetCacheViewVirtualPixelQueue)
#define GetCacheViewVirtualPixels PrependMagickMethod(GetCacheViewVirtualPixels)
#define GetClientName PrependMagickMethod(GetClientName)
#define GetClientPath PrependMagickMethod(GetClientPath)
#define GetCoderInfoList PrependMagickMethod(GetCoderInfoList)
#define GetCoderInfo PrependMagickMethod(GetCoderInfo)
#define GetCoderList PrependMagickMethod(GetCoderList)
#define GetColorCompliance PrependMagickMethod(GetColorCompliance)
#define GetColorInfoList PrependMagickMethod(GetColorInfoList)
#define GetColorInfo PrependMagickMethod(GetColorInfo)
#define GetColorList PrependMagickMethod(GetColorList)
#define GetColorTuple PrependMagickMethod(GetColorTuple)
#define GetCommandOptionFlags PrependMagickMethod(GetCommandOptionFlags)
#define GetCommandOptions PrependMagickMethod(GetCommandOptions)
#define GetConfigureBlob PrependMagickMethod(GetConfigureBlob)
#define GetConfigureInfoList PrependMagickMethod(GetConfigureInfoList)
#define GetConfigureInfo PrependMagickMethod(GetConfigureInfo)
#define GetConfigureList PrependMagickMethod(GetConfigureList)
#define GetConfigureOption PrependMagickMethod(GetConfigureOption)
#define GetConfigureOptions PrependMagickMethod(GetConfigureOptions)
#define GetConfigurePaths PrependMagickMethod(GetConfigurePaths)
#define GetConfigureValue PrependMagickMethod(GetConfigureValue)
#define GetDefaultOpenCLEnv PrependMagickMethod(GetDefaultOpenCLEnv)
#define GetDelegateCommand PrependMagickMethod(GetDelegateCommand)
#define GetDelegateCommands PrependMagickMethod(GetDelegateCommands)
#define GetDelegateInfoList PrependMagickMethod(GetDelegateInfoList)
#define GetDelegateInfo PrependMagickMethod(GetDelegateInfo)
#define GetDelegateList PrependMagickMethod(GetDelegateList)
#define GetDelegateMode PrependMagickMethod(GetDelegateMode)
#define GetDelegateThreadSupport PrependMagickMethod(GetDelegateThreadSupport)
#define GetDistributeCacheFile PrependMagickMethod(GetDistributeCacheFile)
#define GetDistributeCacheHostname PrependMagickMethod(GetDistributeCacheHostname)
#define GetDistributeCachePort PrependMagickMethod(GetDistributeCachePort)
#define GetDrawInfo PrependMagickMethod(GetDrawInfo)
#define GetElapsedTime PrependMagickMethod(GetElapsedTime)
#define GetEnvironmentValue PrependMagickMethod(GetEnvironmentValue)
#define GetExceptionInfo PrependMagickMethod(GetExceptionInfo)
#define GetExceptionMessage PrependMagickMethod(GetExceptionMessage)
#define GetExecutionPath PrependMagickMethod(GetExecutionPath)
#define GetFirstImageInList PrependMagickMethod(GetFirstImageInList)
#define GetGeometry PrependMagickMethod(GetGeometry)
#define GetHeadElementInLinkedList PrependMagickMethod(GetHeadElementInLinkedList)
#define GetImageAlphaChannel PrependMagickMethod(GetImageAlphaChannel)
#define GetImageArtifact PrependMagickMethod(GetImageArtifact)
#define GetImageAttribute PrependMagickMethod(GetImageAttribute)
#define GetImageBoundingBox PrependMagickMethod(GetImageBoundingBox)
#define GetImageChannelDepth PrependMagickMethod(GetImageChannelDepth)
#define GetImageChannelDistortion PrependMagickMethod(GetImageChannelDistortion)
#define GetImageChannelDistortions PrependMagickMethod(GetImageChannelDistortions)
#define GetImageChannelEntropy PrependMagickMethod(GetImageChannelEntropy)
#define GetImageChannelExtrema PrependMagickMethod(GetImageChannelExtrema)
#define GetImageChannelFeatures PrependMagickMethod(GetImageChannelFeatures)
#define GetImageChannelKurtosis PrependMagickMethod(GetImageChannelKurtosis)
#define GetImageChannelMean PrependMagickMethod(GetImageChannelMean)
#define GetImageChannelMoments PrependMagickMethod(GetImageChannelMoments)
#define GetImageChannelPerceptualHash PrependMagickMethod(GetImageChannelPerceptualHash)
#define GetImageChannelRange PrependMagickMethod(GetImageChannelRange)
#define GetImageChannels PrependMagickMethod(GetImageChannels)
#define GetImageChannelStatistics PrependMagickMethod(GetImageChannelStatistics)
#define GetImageClipMask PrependMagickMethod(GetImageClipMask)
#define GetImageClippingPathAttribute PrependMagickMethod(GetImageClippingPathAttribute)
#define GetImageColorspaceType PrependMagickMethod(GetImageColorspaceType)
#define GetImageDecoder PrependMagickMethod(GetImageDecoder)
#define GetImageDepth PrependMagickMethod(GetImageDepth)
#define GetImageDistortion PrependMagickMethod(GetImageDistortion)
#define GetImageDynamicThreshold PrependMagickMethod(GetImageDynamicThreshold)
#define GetImageEncoder PrependMagickMethod(GetImageEncoder)
#define GetImageEntropy PrependMagickMethod(GetImageEntropy)
#define GetImageException PrependMagickMethod(GetImageException)
#define GetImageExtent PrependMagickMethod(GetImageExtent)
#define GetImageExtrema PrependMagickMethod(GetImageExtrema)
#define GetImageFromList PrependMagickMethod(GetImageFromList)
#define GetImageFromMagickRegistry PrependMagickMethod(GetImageFromMagickRegistry)
#define GetImageGeometry PrependMagickMethod(GetImageGeometry)
#define GetImageHistogram PrependMagickMethod(GetImageHistogram)
#define GetImageIndexInList PrependMagickMethod(GetImageIndexInList)
#define GetImageInfoFile PrependMagickMethod(GetImageInfoFile)
#define GetImageInfo PrependMagickMethod(GetImageInfo)
#define GetImageKurtosis PrependMagickMethod(GetImageKurtosis)
#define GetImageListIndex PrependMagickMethod(GetImageListIndex)
#define GetImageListLength PrependMagickMethod(GetImageListLength)
#define GetImageList PrependMagickMethod(GetImageList)
#define GetImageListSize PrependMagickMethod(GetImageListSize)
#define GetImageMagick PrependMagickMethod(GetImageMagick)
#define GetImageMask PrependMagickMethod(GetImageMask)
#define GetImageMean PrependMagickMethod(GetImageMean)
#define GetImageOption PrependMagickMethod(GetImageOption)
#define GetImagePixelCacheType PrependMagickMethod(GetImagePixelCacheType)
#define GetImagePixels PrependMagickMethod(GetImagePixels)
#define GetImageProfile PrependMagickMethod(GetImageProfile)
#define GetImageProperty PrependMagickMethod(GetImageProperty)
#define GetImageQuantizeError PrependMagickMethod(GetImageQuantizeError)
#define GetImageQuantumDepth PrependMagickMethod(GetImageQuantumDepth)
#define GetImageRange PrependMagickMethod(GetImageRange)
#define GetImageReferenceCount PrependMagickMethod(GetImageReferenceCount)
#define GetImageRegistry PrependMagickMethod(GetImageRegistry)
#define GetImageTotalInkDensity PrependMagickMethod(GetImageTotalInkDensity)
#define GetImageType PrependMagickMethod(GetImageType)
#define GetImageViewAuthenticIndexes PrependMagickMethod(GetImageViewAuthenticIndexes)
#define GetImageViewAuthenticPixels PrependMagickMethod(GetImageViewAuthenticPixels)
#define GetImageViewException PrependMagickMethod(GetImageViewException)
#define GetImageViewExtent PrependMagickMethod(GetImageViewExtent)
#define GetImageViewImage PrependMagickMethod(GetImageViewImage)
#define GetImageViewIterator PrependMagickMethod(GetImageViewIterator)
#define GetImageViewVirtualIndexes PrependMagickMethod(GetImageViewVirtualIndexes)
#define GetImageViewVirtualPixels PrependMagickMethod(GetImageViewVirtualPixels)
#define GetImageVirtualPixelMethod PrependMagickMethod(GetImageVirtualPixelMethod)
#define GetIndexes PrependMagickMethod(GetIndexes)
#define GetLastImageInList PrependMagickMethod(GetLastImageInList)
#define GetLastValueInLinkedList PrependMagickMethod(GetLastValueInLinkedList)
#define GetLocaleExceptionMessage PrependMagickMethod(GetLocaleExceptionMessage)
#define GetLocaleInfoList PrependMagickMethod(GetLocaleInfoList)
#define GetLocaleInfo_ PrependMagickMethod(GetLocaleInfo_)
#define GetLocaleList PrependMagickMethod(GetLocaleList)
#define GetLocaleMessage PrependMagickMethod(GetLocaleMessage)
#define GetLocaleOptions PrependMagickMethod(GetLocaleOptions)
#define GetLocaleValue PrependMagickMethod(GetLocaleValue)
#define GetLogEventMask PrependMagickMethod(GetLogEventMask)
#define GetLogInfoList PrependMagickMethod(GetLogInfoList)
#define GetLogList PrependMagickMethod(GetLogList)
#define GetLogName PrependMagickMethod(GetLogName)
#define GetMagicInfoList PrependMagickMethod(GetMagicInfoList)
#define GetMagicInfo PrependMagickMethod(GetMagicInfo)
#define GetMagickAdjoin PrependMagickMethod(GetMagickAdjoin)
#define GetMagickBlobSupport PrependMagickMethod(GetMagickBlobSupport)
#define GetMagickCopyright PrependMagickMethod(GetMagickCopyright)
#define GetMagickCoreSignature PrependMagickMethod(GetMagickCoreSignature)
#define GetMagickDelegates PrependMagickMethod(GetMagickDelegates)
#define GetMagickDescription PrependMagickMethod(GetMagickDescription)
#define GetMagickEndianSupport PrependMagickMethod(GetMagickEndianSupport)
#define GetMagickFeatures PrependMagickMethod(GetMagickFeatures)
#define GetMagickGeometry PrependMagickMethod(GetMagickGeometry)
#define GetMagickHomeURL PrependMagickMethod(GetMagickHomeURL)
#define GetMagickInfoList PrependMagickMethod(GetMagickInfoList)
#define GetMagickInfo PrependMagickMethod(GetMagickInfo)
#define GetMagickLicense PrependMagickMethod(GetMagickLicense)
#define GetMagickList PrependMagickMethod(GetMagickList)
#define GetMagickMemoryMethods PrependMagickMethod(GetMagickMemoryMethods)
#define GetMagickMimeType PrependMagickMethod(GetMagickMimeType)
#define GetMagickOpenCLEnvParam PrependMagickMethod(GetMagickOpenCLEnvParam)
#define GetMagickPackageName PrependMagickMethod(GetMagickPackageName)
#define GetMagickPageSize PrependMagickMethod(GetMagickPageSize)
#define GetMagickPixelIntensity PrependMagickMethod(GetMagickPixelIntensity)
#define GetMagickPixelPacket PrependMagickMethod(GetMagickPixelPacket)
#define GetMagickPrecision PrependMagickMethod(GetMagickPrecision)
#define GetMagickProperty PrependMagickMethod(GetMagickProperty)
#define GetMagickQuantumDepth PrependMagickMethod(GetMagickQuantumDepth)
#define GetMagickQuantumRange PrependMagickMethod(GetMagickQuantumRange)
#define GetMagickRawSupport PrependMagickMethod(GetMagickRawSupport)
#define GetMagickRegistry PrependMagickMethod(GetMagickRegistry)
#define GetMagickReleaseDate PrependMagickMethod(GetMagickReleaseDate)
#define GetMagickResourceLimit PrependMagickMethod(GetMagickResourceLimit)
#define GetMagickResource PrependMagickMethod(GetMagickResource)
#define GetMagickSeekableStream PrependMagickMethod(GetMagickSeekableStream)
#define GetMagickThreadSupport PrependMagickMethod(GetMagickThreadSupport)
#define GetMagickThreadValue PrependMagickMethod(GetMagickThreadValue)
#define GetMagickTime PrependMagickMethod(GetMagickTime)
#define GetMagickToken PrependMagickMethod(GetMagickToken)
#define GetMagickVersion PrependMagickMethod(GetMagickVersion)
#define GetMagicList PrependMagickMethod(GetMagicList)
#define GetMagicName PrependMagickMethod(GetMagicName)
#define GetMatrixColumns PrependMagickMethod(GetMatrixColumns)
#define GetMatrixElement PrependMagickMethod(GetMatrixElement)
#define GetMatrixRows PrependMagickMethod(GetMatrixRows)
#define GetMaxMemoryRequest PrependMagickMethod(GetMaxMemoryRequest)
#define GetMimeDescription PrependMagickMethod(GetMimeDescription)
#define GetMimeInfoList PrependMagickMethod(GetMimeInfoList)
#define GetMimeInfo PrependMagickMethod(GetMimeInfo)
#define GetMimeList PrependMagickMethod(GetMimeList)
#define GetMimeType PrependMagickMethod(GetMimeType)
#define GetMonitorHandler PrependMagickMethod(GetMonitorHandler)
#define GetMontageInfo PrependMagickMethod(GetMontageInfo)
#define GetMultilineTypeMetrics PrependMagickMethod(GetMultilineTypeMetrics)
#define GetNextImageArtifact PrependMagickMethod(GetNextImageArtifact)
#define GetNextImageAttribute PrependMagickMethod(GetNextImageAttribute)
#define GetNextImageInList PrependMagickMethod(GetNextImageInList)
#define GetNextImageOption PrependMagickMethod(GetNextImageOption)
#define GetNextImage PrependMagickMethod(GetNextImage)
#define GetNextImageProfile PrependMagickMethod(GetNextImageProfile)
#define GetNextImageProperty PrependMagickMethod(GetNextImageProperty)
#define GetNextImageRegistry PrependMagickMethod(GetNextImageRegistry)
#define GetNextKeyInHashmap PrependMagickMethod(GetNextKeyInHashmap)
#define GetNextKeyInSplayTree PrependMagickMethod(GetNextKeyInSplayTree)
#define GetNextToken PrependMagickMethod(GetNextToken)
#define GetNextValueInHashmap PrependMagickMethod(GetNextValueInHashmap)
#define GetNextValueInLinkedList PrependMagickMethod(GetNextValueInLinkedList)
#define GetNextValueInSplayTree PrependMagickMethod(GetNextValueInSplayTree)
#define GetNextXMLTreeTag PrependMagickMethod(GetNextXMLTreeTag)
#define GetNumberColors PrependMagickMethod(GetNumberColors)
#define GetNumberOfElementsInLinkedList PrependMagickMethod(GetNumberOfElementsInLinkedList)
#define GetNumberOfEntriesInHashmap PrependMagickMethod(GetNumberOfEntriesInHashmap)
#define GetNumberOfNodesInSplayTree PrependMagickMethod(GetNumberOfNodesInSplayTree)
#define GetNumberScenes PrependMagickMethod(GetNumberScenes)
#define GetOneAuthenticPixel PrependMagickMethod(GetOneAuthenticPixel)
#define GetOneCacheViewAuthenticPixel PrependMagickMethod(GetOneCacheViewAuthenticPixel)
#define GetOneCacheViewVirtualMethodPixel PrependMagickMethod(GetOneCacheViewVirtualMethodPixel)
#define GetOneCacheViewVirtualPixel PrependMagickMethod(GetOneCacheViewVirtualPixel)
#define GetOnePixel PrependMagickMethod(GetOnePixel)
#define GetOneVirtualMagickPixel PrependMagickMethod(GetOneVirtualMagickPixel)
#define GetOneVirtualMethodPixel PrependMagickMethod(GetOneVirtualMethodPixel)
#define GetOneVirtualPixel PrependMagickMethod(GetOneVirtualPixel)
#define GetOptimalKernelWidth1D PrependMagickMethod(GetOptimalKernelWidth1D)
#define GetOptimalKernelWidth2D PrependMagickMethod(GetOptimalKernelWidth2D)
#define GetOptimalKernelWidth PrependMagickMethod(GetOptimalKernelWidth)
#define GetPageGeometry PrependMagickMethod(GetPageGeometry)
#define GetPathAttributes PrependMagickMethod(GetPathAttributes)
#define GetPathComponent PrependMagickMethod(GetPathComponent)
#define GetPathComponents PrependMagickMethod(GetPathComponents)
#define GetPathTemplate PrependMagickMethod(GetPathTemplate)
#define GetPixelCacheChannels PrependMagickMethod(GetPixelCacheChannels)
#define GetPixelCacheColorspace PrependMagickMethod(GetPixelCacheColorspace)
#define GetPixelCacheFilename PrependMagickMethod(GetPixelCacheFilename)
#define GetPixelCacheMethods PrependMagickMethod(GetPixelCacheMethods)
#define GetPixelCacheNexusExtent PrependMagickMethod(GetPixelCacheNexusExtent)
#define GetPixelCachePixels PrependMagickMethod(GetPixelCachePixels)
#define GetPixelCacheStorageClass PrependMagickMethod(GetPixelCacheStorageClass)
#define GetPixelCacheTileSize PrependMagickMethod(GetPixelCacheTileSize)
#define GetPixelCacheType PrependMagickMethod(GetPixelCacheType)
#define GetPixelCacheVirtualMethod PrependMagickMethod(GetPixelCacheVirtualMethod)
#define GetPixelIntensity PrependMagickMethod(GetPixelIntensity)
#define GetPixels PrependMagickMethod(GetPixels)
#define GetPolicyInfoList PrependMagickMethod(GetPolicyInfoList)
#define GetPolicyList PrependMagickMethod(GetPolicyList)
#define GetPolicyValue PrependMagickMethod(GetPolicyValue)
#define GetPreviousImageInList PrependMagickMethod(GetPreviousImageInList)
#define GetPreviousImage PrependMagickMethod(GetPreviousImage)
#define GetPseudoRandomValue PrependMagickMethod(GetPseudoRandomValue)
#define GetQuantizeInfo PrependMagickMethod(GetQuantizeInfo)
#define GetQuantumEndian PrependMagickMethod(GetQuantumEndian)
#define GetQuantumExtent PrependMagickMethod(GetQuantumExtent)
#define GetQuantumFormat PrependMagickMethod(GetQuantumFormat)
#define GetQuantumInfo PrependMagickMethod(GetQuantumInfo)
#define GetQuantumPixels PrependMagickMethod(GetQuantumPixels)
#define GetQuantumType PrependMagickMethod(GetQuantumType)
#define GetRandomInfoNormalize PrependMagickMethod(GetRandomInfoNormalize)
#define GetRandomInfoSeed PrependMagickMethod(GetRandomInfoSeed)
#define GetRandomKey PrependMagickMethod(GetRandomKey)
#define GetRandomSecretKey PrependMagickMethod(GetRandomSecretKey)
#define GetRandomValue PrependMagickMethod(GetRandomValue)
#define GetResizeFilterBlur PrependMagickMethod(GetResizeFilterBlur)
#define GetResizeFilterCoefficient PrependMagickMethod(GetResizeFilterCoefficient)
#define GetResizeFilterScale PrependMagickMethod(GetResizeFilterScale)
#define GetResizeFilterSupport PrependMagickMethod(GetResizeFilterSupport)
#define GetResizeFilterWeightingType PrependMagickMethod(GetResizeFilterWeightingType)
#define GetResizeFilterWeight PrependMagickMethod(GetResizeFilterWeight)
#define GetResizeFilterWindowSupport PrependMagickMethod(GetResizeFilterWindowSupport)
#define GetResizeFilterWindowWeightingType PrependMagickMethod(GetResizeFilterWindowWeightingType)
#define GetRootValueFromSplayTree PrependMagickMethod(GetRootValueFromSplayTree)
#define GetSignatureBlocksize PrependMagickMethod(GetSignatureBlocksize)
#define GetSignatureDigest PrependMagickMethod(GetSignatureDigest)
#define GetSignatureDigestsize PrependMagickMethod(GetSignatureDigestsize)
#define GetStreamInfoClientData PrependMagickMethod(GetStreamInfoClientData)
#define GetStringInfoDatum PrependMagickMethod(GetStringInfoDatum)
#define GetStringInfoLength PrependMagickMethod(GetStringInfoLength)
#define GetStringInfoName PrependMagickMethod(GetStringInfoName)
#define GetStringInfoPath PrependMagickMethod(GetStringInfoPath)
#define GetThresholdMapFile PrependMagickMethod(GetThresholdMapFile)
#define GetThresholdMap PrependMagickMethod(GetThresholdMap)
#define GetTimerInfo PrependMagickMethod(GetTimerInfo)
#define GetTypeInfoByFamily PrependMagickMethod(GetTypeInfoByFamily)
#define GetTypeInfoList PrependMagickMethod(GetTypeInfoList)
#define GetTypeInfo PrependMagickMethod(GetTypeInfo)
#define GetTypeList PrependMagickMethod(GetTypeList)
#define GetTypeMetrics PrependMagickMethod(GetTypeMetrics)
#define GetUserTime PrependMagickMethod(GetUserTime)
#define GetValueFromHashmap PrependMagickMethod(GetValueFromHashmap)
#define GetValueFromLinkedList PrependMagickMethod(GetValueFromLinkedList)
#define GetValueFromSplayTree PrependMagickMethod(GetValueFromSplayTree)
#define GetVirtualIndexesFromNexus PrependMagickMethod(GetVirtualIndexesFromNexus)
#define GetVirtualIndexQueue PrependMagickMethod(GetVirtualIndexQueue)
#define GetVirtualMemoryBlob PrependMagickMethod(GetVirtualMemoryBlob)
#define GetVirtualPixelCacheNexus PrependMagickMethod(GetVirtualPixelCacheNexus)
#define GetVirtualPixelQueue PrependMagickMethod(GetVirtualPixelQueue)
#define GetVirtualPixelsNexus PrependMagickMethod(GetVirtualPixelsNexus)
#define GetVirtualPixels PrependMagickMethod(GetVirtualPixels)
#define GetXMLTreeAttribute PrependMagickMethod(GetXMLTreeAttribute)
#define GetXMLTreeAttributes PrependMagickMethod(GetXMLTreeAttributes)
#define GetXMLTreeChild PrependMagickMethod(GetXMLTreeChild)
#define GetXMLTreeContent PrependMagickMethod(GetXMLTreeContent)
#define GetXMLTreeOrdered PrependMagickMethod(GetXMLTreeOrdered)
#define GetXMLTreePath PrependMagickMethod(GetXMLTreePath)
#define GetXMLTreeProcessingInstructions PrependMagickMethod(GetXMLTreeProcessingInstructions)
#define GetXMLTreeSibling PrependMagickMethod(GetXMLTreeSibling)
#define GetXMLTreeTag PrependMagickMethod(GetXMLTreeTag)
#define GlobExpression PrependMagickMethod(GlobExpression)
#define GradientImage PrependMagickMethod(GradientImage)
#define GravityAdjustGeometry PrependMagickMethod(GravityAdjustGeometry)
#define GrayscaleImage PrependMagickMethod(GrayscaleImage)
#define HaldClutImageChannel PrependMagickMethod(HaldClutImageChannel)
#define HaldClutImage PrependMagickMethod(HaldClutImage)
#define HashPointerType PrependMagickMethod(HashPointerType)
#define HashStringInfoType PrependMagickMethod(HashStringInfoType)
#define HashStringType PrependMagickMethod(HashStringType)
#define HoughLineImage PrependMagickMethod(HoughLineImage)
#define HSLTransform PrependMagickMethod(HSLTransform)
#define HuffmanDecodeImage PrependMagickMethod(HuffmanDecodeImage)
#define HuffmanEncodeImage PrependMagickMethod(HuffmanEncodeImage)
#define IdentifyImageGray PrependMagickMethod(IdentifyImageGray)
#define IdentifyImageMonochrome PrependMagickMethod(IdentifyImageMonochrome)
#define IdentifyImage PrependMagickMethod(IdentifyImage)
#define IdentifyImageType PrependMagickMethod(IdentifyImageType)
#define IdentifyPaletteImage PrependMagickMethod(IdentifyPaletteImage)
#define IdentityAffine PrependMagickMethod(IdentityAffine)
#define ImageListToArray PrependMagickMethod(ImageListToArray)
#define ImagesToBlob PrependMagickMethod(ImagesToBlob)
#define ImageToBlob PrependMagickMethod(ImageToBlob)
#define ImageToFile PrependMagickMethod(ImageToFile)
#define ImplodeImage PrependMagickMethod(ImplodeImage)
#define ImportImagePixels PrependMagickMethod(ImportImagePixels)
#define ImportQuantumPixels PrependMagickMethod(ImportQuantumPixels)
#define InheritException PrependMagickMethod(InheritException)
#define InitializeExceptionInfo PrependMagickMethod(InitializeExceptionInfo)
#define InitializeMagick PrependMagickMethod(InitializeMagick)
#define InitializeSignature PrependMagickMethod(InitializeSignature)
#define InitImageMagickOpenCL PrependMagickMethod(InitImageMagickOpenCL)
#define InitOpenCLEnv PrependMagickMethod(InitOpenCLEnv)
#define InjectImageBlob PrependMagickMethod(InjectImageBlob)
#define InsertImageInList PrependMagickMethod(InsertImageInList)
#define InsertTagIntoXMLTree PrependMagickMethod(InsertTagIntoXMLTree)
#define InsertValueInLinkedList PrependMagickMethod(InsertValueInLinkedList)
#define InsertValueInSortedLinkedList PrependMagickMethod(InsertValueInSortedLinkedList)
#define IntegralRotateImage PrependMagickMethod(IntegralRotateImage)
#define InterpolateMagickPixelPacket PrependMagickMethod(InterpolateMagickPixelPacket)
#define InterpolatePixelColor PrependMagickMethod(InterpolatePixelColor)
#define InterpolativeResizeImage PrependMagickMethod(InterpolativeResizeImage)
#define InterpretImageAttributes PrependMagickMethod(InterpretImageAttributes)
#define InterpretImageFilename PrependMagickMethod(InterpretImageFilename)
#define InterpretImageProperties PrependMagickMethod(InterpretImageProperties)
#define InterpretLocaleValue PrependMagickMethod(InterpretLocaleValue)
#define InterpretSiPrefixValue PrependMagickMethod(InterpretSiPrefixValue)
#define InverseFourierTransformImage PrependMagickMethod(InverseFourierTransformImage)
#define InversesRGBCompandor PrependMagickMethod(InversesRGBCompandor)
#define InvokeDelegate PrependMagickMethod(InvokeDelegate)
#define InvokeDynamicImageFilter PrependMagickMethod(InvokeDynamicImageFilter)
#define IsBlobExempt PrependMagickMethod(IsBlobExempt)
#define IsBlobSeekable PrependMagickMethod(IsBlobSeekable)
#define IsBlobTemporary PrependMagickMethod(IsBlobTemporary)
#define IsColorSimilar PrependMagickMethod(IsColorSimilar)
#define IsCommandOption PrependMagickMethod(IsCommandOption)
#define IsEventLogging PrependMagickMethod(IsEventLogging)
#define IsGeometry PrependMagickMethod(IsGeometry)
#define IsGlob PrependMagickMethod(IsGlob)
#define IsGrayImage PrependMagickMethod(IsGrayImage)
#define IsHashmapEmpty PrependMagickMethod(IsHashmapEmpty)
#define IsHighDynamicRangeImage PrependMagickMethod(IsHighDynamicRangeImage)
#define IsHistogramImage PrependMagickMethod(IsHistogramImage)
#define IsImageObject PrependMagickMethod(IsImageObject)
#define IsImagesEqual PrependMagickMethod(IsImagesEqual)
#define IsImageSimilar PrependMagickMethod(IsImageSimilar)
#define IsImageView PrependMagickMethod(IsImageView)
#define IsIntensitySimilar PrependMagickMethod(IsIntensitySimilar)
#define IsLinkedListEmpty PrependMagickMethod(IsLinkedListEmpty)
#define IsMagickColorSimilar PrependMagickMethod(IsMagickColorSimilar)
#define IsMagickConflict PrependMagickMethod(IsMagickConflict)
#define IsMagickCoreInstantiated PrependMagickMethod(IsMagickCoreInstantiated)
#define IsMagickInstantiated PrependMagickMethod(IsMagickInstantiated)
#define IsMagickTrue PrependMagickMethod(IsMagickTrue)
#define IsMonochromeImage PrependMagickMethod(IsMonochromeImage)
#define IsOpacitySimilar PrependMagickMethod(IsOpacitySimilar)
#define IsOpaqueImage PrependMagickMethod(IsOpaqueImage)
#define IsOptionMember PrependMagickMethod(IsOptionMember)
#define IsPaletteImage PrependMagickMethod(IsPaletteImage)
#define IsPathAccessible PrependMagickMethod(IsPathAccessible)
#define IsRightsAuthorized PrependMagickMethod(IsRightsAuthorized)
#define IsSceneGeometry PrependMagickMethod(IsSceneGeometry)
#define IsStringNotFalse PrependMagickMethod(IsStringNotFalse)
#define IsStringTrue PrependMagickMethod(IsStringTrue)
#define IsSubimage PrependMagickMethod(IsSubimage)
#define IsTaintImage PrependMagickMethod(IsTaintImage)
#define KuwaharaImageChannel PrependMagickMethod(KuwaharaImageChannel)
#define KuwaharaImage PrependMagickMethod(KuwaharaImage)
#define LeastSquaresAddTerms PrependMagickMethod(LeastSquaresAddTerms)
#define LevelColorsImageChannel PrependMagickMethod(LevelColorsImageChannel)
#define LevelColorsImage PrependMagickMethod(LevelColorsImage)
#define LevelImageChannel PrependMagickMethod(LevelImageChannel)
#define LevelImageColors PrependMagickMethod(LevelImageColors)
#define LevelImage PrependMagickMethod(LevelImage)
#define LevelizeImageChannel PrependMagickMethod(LevelizeImageChannel)
#define LevelizeImage PrependMagickMethod(LevelizeImage)
#define LiberateMemory PrependMagickMethod(LiberateMemory)
#define LiberateSemaphoreInfo PrependMagickMethod(LiberateSemaphoreInfo)
#define LinearStretchImage PrependMagickMethod(LinearStretchImage)
#define LinkedListToArray PrependMagickMethod(LinkedListToArray)
#define LiquidRescaleImage PrependMagickMethod(LiquidRescaleImage)
#define ListCoderInfo PrependMagickMethod(ListCoderInfo)
#define ListColorInfo PrependMagickMethod(ListColorInfo)
#define ListCommandOptions PrependMagickMethod(ListCommandOptions)
#define ListConfigureInfo PrependMagickMethod(ListConfigureInfo)
#define ListDelegateInfo PrependMagickMethod(ListDelegateInfo)
#define ListFiles PrependMagickMethod(ListFiles)
#define ListLocaleInfo PrependMagickMethod(ListLocaleInfo)
#define ListLogInfo PrependMagickMethod(ListLogInfo)
#define ListMagicInfo PrependMagickMethod(ListMagicInfo)
#define ListMagickInfo PrependMagickMethod(ListMagickInfo)
#define ListMagickResourceInfo PrependMagickMethod(ListMagickResourceInfo)
#define ListMagickVersion PrependMagickMethod(ListMagickVersion)
#define ListMimeInfo PrependMagickMethod(ListMimeInfo)
#define ListModuleInfo PrependMagickMethod(ListModuleInfo)
#define ListPolicyInfo PrependMagickMethod(ListPolicyInfo)
#define ListThresholdMapFile PrependMagickMethod(ListThresholdMapFile)
#define ListThresholdMaps PrependMagickMethod(ListThresholdMaps)
#define ListTypeInfo PrependMagickMethod(ListTypeInfo)
#define LoadFontConfigFonts PrependMagickMethod(LoadFontConfigFonts)
#define LoadMimeLists PrependMagickMethod(LoadMimeLists)
#define LocalContrastImage PrependMagickMethod(LocalContrastImage)
#define LocaleCompare PrependMagickMethod(LocaleCompare)
#define LocaleComponentGenesis PrependMagickMethod(LocaleComponentGenesis)
#define LocaleComponentTerminus PrependMagickMethod(LocaleComponentTerminus)
#define LocaleLowercase PrependMagickMethod(LocaleLowercase)
#define LocaleLower PrependMagickMethod(LocaleLower)
#define LocaleNCompare PrependMagickMethod(LocaleNCompare)
#define LocaleUppercase PrependMagickMethod(LocaleUppercase)
#define LocaleUpper PrependMagickMethod(LocaleUpper)
#define LockSemaphoreInfo PrependMagickMethod(LockSemaphoreInfo)
#define LogComponentGenesis PrependMagickMethod(LogComponentGenesis)
#define LogComponentTerminus PrependMagickMethod(LogComponentTerminus)
#define LogMagickEventList PrependMagickMethod(LogMagickEventList)
#define LogMagickEvent PrependMagickMethod(LogMagickEvent)
#define LZWEncodeImage PrependMagickMethod(LZWEncodeImage)
#define MagicComponentGenesis PrependMagickMethod(MagicComponentGenesis)
#define MagicComponentTerminus PrependMagickMethod(MagicComponentTerminus)
#define MagickComponentGenesis PrependMagickMethod(MagickComponentGenesis)
#define MagickComponentTerminus PrependMagickMethod(MagickComponentTerminus)
#define MagickCoreGenesis PrependMagickMethod(MagickCoreGenesis)
#define MagickCoreTerminus PrependMagickMethod(MagickCoreTerminus)
#define MagickCreateThreadKey PrependMagickMethod(MagickCreateThreadKey)
#define MagickDelay PrependMagickMethod(MagickDelay)
#define MagickDeleteThreadKey PrependMagickMethod(MagickDeleteThreadKey)
#define MagickGetThreadValue PrependMagickMethod(MagickGetThreadValue)
#define MagickIncarnate PrependMagickMethod(MagickIncarnate)
#define MagickMonitor PrependMagickMethod(MagickMonitor)
#define MagickSetThreadValue PrependMagickMethod(MagickSetThreadValue)
#define MagickToMime PrependMagickMethod(MagickToMime)
#define MagnifyImage PrependMagickMethod(MagnifyImage)
#define MapBlob PrependMagickMethod(MapBlob)
#define MapImage PrependMagickMethod(MapImage)
#define MapImages PrependMagickMethod(MapImages)
#define MatrixToImage PrependMagickMethod(MatrixToImage)
#define MatteFloodfillImage PrependMagickMethod(MatteFloodfillImage)
#define MaximumImages PrependMagickMethod(MaximumImages)
#define MeanShiftImage PrependMagickMethod(MeanShiftImage)
#define MedianFilterImage PrependMagickMethod(MedianFilterImage)
#define MergeImageLayers PrependMagickMethod(MergeImageLayers)
#define MimeComponentGenesis PrependMagickMethod(MimeComponentGenesis)
#define MimeComponentTerminus PrependMagickMethod(MimeComponentTerminus)
#define MinifyImage PrependMagickMethod(MinifyImage)
#define MinimumImages PrependMagickMethod(MinimumImages)
#define MinMaxStretchImage PrependMagickMethod(MinMaxStretchImage)
#define ModeImage PrependMagickMethod(ModeImage)
#define ModifyImage PrependMagickMethod(ModifyImage)
#define ModulateImage PrependMagickMethod(ModulateImage)
#define MonitorComponentGenesis PrependMagickMethod(MonitorComponentGenesis)
#define MonitorComponentTerminus PrependMagickMethod(MonitorComponentTerminus)
#define MontageImageList PrependMagickMethod(MontageImageList)
#define MontageImages PrependMagickMethod(MontageImages)
#define MorphImages PrependMagickMethod(MorphImages)
#define MorphologyApply PrependMagickMethod(MorphologyApply)
#define MorphologyImageChannel PrependMagickMethod(MorphologyImageChannel)
#define MorphologyImage PrependMagickMethod(MorphologyImage)
#define MosaicImages PrependMagickMethod(MosaicImages)
#define MotionBlurImageChannel PrependMagickMethod(MotionBlurImageChannel)
#define MotionBlurImage PrependMagickMethod(MotionBlurImage)
#define MSBOrderLong PrependMagickMethod(MSBOrderLong)
#define MSBOrderShort PrependMagickMethod(MSBOrderShort)
#define MultilineCensus PrependMagickMethod(MultilineCensus)
#define NegateImageChannel PrependMagickMethod(NegateImageChannel)
#define NegateImage PrependMagickMethod(NegateImage)
#define NewHashmap PrependMagickMethod(NewHashmap)
#define NewImageList PrependMagickMethod(NewImageList)
#define NewImageView PrependMagickMethod(NewImageView)
#define NewImageViewRegion PrependMagickMethod(NewImageViewRegion)
#define NewLinkedList PrependMagickMethod(NewLinkedList)
#define NewMagickImage PrependMagickMethod(NewMagickImage)
#define NewSplayTree PrependMagickMethod(NewSplayTree)
#define NewXMLTree PrependMagickMethod(NewXMLTree)
#define NewXMLTreeTag PrependMagickMethod(NewXMLTreeTag)
#define NormalizeImageChannel PrependMagickMethod(NormalizeImageChannel)
#define NormalizeImage PrependMagickMethod(NormalizeImage)
#define NullMatrix PrependMagickMethod(NullMatrix)
#define OilPaintImage PrependMagickMethod(OilPaintImage)
#define OpaqueImage PrependMagickMethod(OpaqueImage)
#define OpaquePaintImageChannel PrependMagickMethod(OpaquePaintImageChannel)
#define OpaquePaintImage PrependMagickMethod(OpaquePaintImage)
#define OpenBlob PrependMagickMethod(OpenBlob)
#define OpenCacheView PrependMagickMethod(OpenCacheView)
#define OpenDistributePixelCache PrependMagickMethod(OpenDistributePixelCache)
#define OpenMagickStream PrependMagickMethod(OpenMagickStream)
#define OpenStream PrependMagickMethod(OpenStream)
#define OptimizeImageLayers PrependMagickMethod(OptimizeImageLayers)
#define OptimizeImageTransparency PrependMagickMethod(OptimizeImageTransparency)
#define OptimizePlusImageLayers PrependMagickMethod(OptimizePlusImageLayers)
#define OrderedDitherImageChannel PrependMagickMethod(OrderedDitherImageChannel)
#define OrderedDitherImage PrependMagickMethod(OrderedDitherImage)
#define OrderedPosterizeImageChannel PrependMagickMethod(OrderedPosterizeImageChannel)
#define OrderedPosterizeImage PrependMagickMethod(OrderedPosterizeImage)
#define PackbitsEncodeImage PrependMagickMethod(PackbitsEncodeImage)
#define PaintFloodfillImage PrependMagickMethod(PaintFloodfillImage)
#define PaintOpaqueImageChannel PrependMagickMethod(PaintOpaqueImageChannel)
#define PaintOpaqueImage PrependMagickMethod(PaintOpaqueImage)
#define PaintTransparentImage PrependMagickMethod(PaintTransparentImage)
#define ParseAbsoluteGeometry PrependMagickMethod(ParseAbsoluteGeometry)
#define ParseAffineGeometry PrependMagickMethod(ParseAffineGeometry)
#define ParseChannelOption PrependMagickMethod(ParseChannelOption)
#define ParseCommandOption PrependMagickMethod(ParseCommandOption)
#define ParseGeometry PrependMagickMethod(ParseGeometry)
#define ParseGravityGeometry PrependMagickMethod(ParseGravityGeometry)
#define ParseImageGeometry PrependMagickMethod(ParseImageGeometry)
#define ParseMetaGeometry PrependMagickMethod(ParseMetaGeometry)
#define ParsePageGeometry PrependMagickMethod(ParsePageGeometry)
#define ParseRegionGeometry PrependMagickMethod(ParseRegionGeometry)
#define ParseSizeGeometry PrependMagickMethod(ParseSizeGeometry)
#define PasskeyDecipherImage PrependMagickMethod(PasskeyDecipherImage)
#define PasskeyEncipherImage PrependMagickMethod(PasskeyEncipherImage)
#define PerceptibleImageChannel PrependMagickMethod(PerceptibleImageChannel)
#define PerceptibleImage PrependMagickMethod(PerceptibleImage)
#define PersistPixelCache PrependMagickMethod(PersistPixelCache)
#define PingBlob PrependMagickMethod(PingBlob)
#define PingImage PrependMagickMethod(PingImage)
#define PingImages PrependMagickMethod(PingImages)
#define PlasmaImage PrependMagickMethod(PlasmaImage)
#define PlasmaImageProxy PrependMagickMethod(PlasmaImageProxy)
#define PolaroidImage PrependMagickMethod(PolaroidImage)
#define PolicyComponentGenesis PrependMagickMethod(PolicyComponentGenesis)
#define PolicyComponentTerminus PrependMagickMethod(PolicyComponentTerminus)
#define PolynomialImageChannel PrependMagickMethod(PolynomialImageChannel)
#define PolynomialImage PrependMagickMethod(PolynomialImage)
#define PopImageList PrependMagickMethod(PopImageList)
#define PopImagePixels PrependMagickMethod(PopImagePixels)
#define PosterizeImageChannel PrependMagickMethod(PosterizeImageChannel)
#define PosterizeImage PrependMagickMethod(PosterizeImage)
#define PostscriptGeometry PrependMagickMethod(PostscriptGeometry)
#define PrependImageToList PrependMagickMethod(PrependImageToList)
#define PreviewImage PrependMagickMethod(PreviewImage)
#define PrintStringInfo PrependMagickMethod(PrintStringInfo)
#define process_message PrependMagickMethod(process_message)
#define ProfileImage PrependMagickMethod(ProfileImage)
#define PruneTagFromXMLTree PrependMagickMethod(PruneTagFromXMLTree)
#define PushImageList PrependMagickMethod(PushImageList)
#define PushImagePixels PrependMagickMethod(PushImagePixels)
#define PutEntryInHashmap PrependMagickMethod(PutEntryInHashmap)
#define QuantizationError PrependMagickMethod(QuantizationError)
#define QuantizeImage PrependMagickMethod(QuantizeImage)
#define QuantizeImages PrependMagickMethod(QuantizeImages)
#define QueryColorCompliance PrependMagickMethod(QueryColorCompliance)
#define QueryColorDatabase PrependMagickMethod(QueryColorDatabase)
#define QueryColorname PrependMagickMethod(QueryColorname)
#define QueryMagickColorCompliance PrependMagickMethod(QueryMagickColorCompliance)
#define QueryMagickColorname PrependMagickMethod(QueryMagickColorname)
#define QueryMagickColor PrependMagickMethod(QueryMagickColor)
#define QueueAuthenticPixelCacheNexus PrependMagickMethod(QueueAuthenticPixelCacheNexus)
#define QueueAuthenticPixel PrependMagickMethod(QueueAuthenticPixel)
#define QueueAuthenticPixels PrependMagickMethod(QueueAuthenticPixels)
#define QueueCacheViewAuthenticPixels PrependMagickMethod(QueueCacheViewAuthenticPixels)
#define RadialBlurImageChannel PrependMagickMethod(RadialBlurImageChannel)
#define RadialBlurImage PrependMagickMethod(RadialBlurImage)
#define RaiseImage PrependMagickMethod(RaiseImage)
#define RandomChannelThresholdImage PrependMagickMethod(RandomChannelThresholdImage)
#define RandomComponentGenesis PrependMagickMethod(RandomComponentGenesis)
#define RandomComponentTerminus PrependMagickMethod(RandomComponentTerminus)
#define RandomThresholdImageChannel PrependMagickMethod(RandomThresholdImageChannel)
#define RandomThresholdImage PrependMagickMethod(RandomThresholdImage)
#define ReacquireMemory PrependMagickMethod(ReacquireMemory)
#define ReadBlobByte PrependMagickMethod(ReadBlobByte)
#define ReadBlobDouble PrependMagickMethod(ReadBlobDouble)
#define ReadBlobFloat PrependMagickMethod(ReadBlobFloat)
#define ReadBlobLongLong PrependMagickMethod(ReadBlobLongLong)
#define ReadBlobLong PrependMagickMethod(ReadBlobLong)
#define ReadBlobLSBLong PrependMagickMethod(ReadBlobLSBLong)
#define ReadBlobLSBShort PrependMagickMethod(ReadBlobLSBShort)
#define ReadBlobLSBSignedLong PrependMagickMethod(ReadBlobLSBSignedLong)
#define ReadBlobLSBSignedShort PrependMagickMethod(ReadBlobLSBSignedShort)
#define ReadBlobMSBLongLong PrependMagickMethod(ReadBlobMSBLongLong)
#define ReadBlobMSBLong PrependMagickMethod(ReadBlobMSBLong)
#define ReadBlobMSBShort PrependMagickMethod(ReadBlobMSBShort)
#define ReadBlobMSBSignedLong PrependMagickMethod(ReadBlobMSBSignedLong)
#define ReadBlobMSBSignedShort PrependMagickMethod(ReadBlobMSBSignedShort)
#define ReadBlob PrependMagickMethod(ReadBlob)
#define ReadBlobShort PrependMagickMethod(ReadBlobShort)
#define ReadBlobSignedLong PrependMagickMethod(ReadBlobSignedLong)
#define ReadBlobSignedShort PrependMagickMethod(ReadBlobSignedShort)
#define ReadBlobStream PrependMagickMethod(ReadBlobStream)
#define ReadBlobString PrependMagickMethod(ReadBlobString)
#define ReadDistributePixelCacheIndexes PrependMagickMethod(ReadDistributePixelCacheIndexes)
#define ReadDistributePixelCachePixels PrependMagickMethod(ReadDistributePixelCachePixels)
#define ReadImage PrependMagickMethod(ReadImage)
#define ReadImages PrependMagickMethod(ReadImages)
#define ReadInlineImage PrependMagickMethod(ReadInlineImage)
#define ReadPSDLayers PrependMagickMethod(ReadPSDLayers)
#define ReadStream PrependMagickMethod(ReadStream)
#define RecolorImage PrependMagickMethod(RecolorImage)
#define ReduceNoiseImage PrependMagickMethod(ReduceNoiseImage)
#define ReferenceBlob PrependMagickMethod(ReferenceBlob)
#define ReferenceImage PrependMagickMethod(ReferenceImage)
#define ReferencePixelCache PrependMagickMethod(ReferencePixelCache)
#define RegisterAAIImage PrependMagickMethod(RegisterAAIImage)
#define RegisterARTImage PrependMagickMethod(RegisterARTImage)
#define RegisterAVSImage PrependMagickMethod(RegisterAVSImage)
#define RegisterBGRImage PrependMagickMethod(RegisterBGRImage)
#define RegisterBMPImage PrependMagickMethod(RegisterBMPImage)
#define RegisterBRAILLEImage PrependMagickMethod(RegisterBRAILLEImage)
#define RegisterCALSImage PrependMagickMethod(RegisterCALSImage)
#define RegisterCAPTIONImage PrependMagickMethod(RegisterCAPTIONImage)
#define RegisterCINImage PrependMagickMethod(RegisterCINImage)
#define RegisterCIPImage PrependMagickMethod(RegisterCIPImage)
#define RegisterCLIPImage PrependMagickMethod(RegisterCLIPImage)
#define RegisterCMYKImage PrependMagickMethod(RegisterCMYKImage)
#define RegisterCUTImage PrependMagickMethod(RegisterCUTImage)
#define RegisterDCMImage PrependMagickMethod(RegisterDCMImage)
#define RegisterDDSImage PrependMagickMethod(RegisterDDSImage)
#define RegisterDEBUGImage PrependMagickMethod(RegisterDEBUGImage)
#define RegisterDIBImage PrependMagickMethod(RegisterDIBImage)
#define RegisterDJVUImage PrependMagickMethod(RegisterDJVUImage)
#define RegisterDNGImage PrependMagickMethod(RegisterDNGImage)
#define RegisterDOTImage PrependMagickMethod(RegisterDOTImage)
#define RegisterDPXImage PrependMagickMethod(RegisterDPXImage)
#define RegisterEPTImage PrependMagickMethod(RegisterEPTImage)
#define RegisterEXRImage PrependMagickMethod(RegisterEXRImage)
#define RegisterFAXImage PrependMagickMethod(RegisterFAXImage)
#define RegisterFITSImage PrependMagickMethod(RegisterFITSImage)
#define RegisterGIFImage PrependMagickMethod(RegisterGIFImage)
#define RegisterGRADIENTImage PrependMagickMethod(RegisterGRADIENTImage)
#define RegisterGRAYImage PrependMagickMethod(RegisterGRAYImage)
#define RegisterHALDImage PrependMagickMethod(RegisterHALDImage)
#define RegisterHDRImage PrependMagickMethod(RegisterHDRImage)
#define RegisterHEICImage PrependMagickMethod(RegisterHEICImage)
#define RegisterHISTOGRAMImage PrependMagickMethod(RegisterHISTOGRAMImage)
#define RegisterHRZImage PrependMagickMethod(RegisterHRZImage)
#define RegisterHTMLImage PrependMagickMethod(RegisterHTMLImage)
#define RegisterICONImage PrependMagickMethod(RegisterICONImage)
#define RegisterINFOImage PrependMagickMethod(RegisterINFOImage)
#define RegisterINLINEImage PrependMagickMethod(RegisterINLINEImage)
#define RegisterIPLImage PrependMagickMethod(RegisterIPLImage)
#define RegisterJBIGImage PrependMagickMethod(RegisterJBIGImage)
#define RegisterJNXImage PrependMagickMethod(RegisterJNXImage)
#define RegisterJP2Image PrependMagickMethod(RegisterJP2Image)
#define RegisterJPEGImage PrependMagickMethod(RegisterJPEGImage)
#define RegisterJSONImage PrependMagickMethod(RegisterJSONImage)
#define RegisterLABELImage PrependMagickMethod(RegisterLABELImage)
#define RegisterMACImage PrependMagickMethod(RegisterMACImage)
#define RegisterMAGICKImage PrependMagickMethod(RegisterMAGICKImage)
#define RegisterMagickInfo PrependMagickMethod(RegisterMagickInfo)
#define RegisterMAPImage PrependMagickMethod(RegisterMAPImage)
#define RegisterMASKImage PrependMagickMethod(RegisterMASKImage)
#define RegisterMATImage PrependMagickMethod(RegisterMATImage)
#define RegisterMATTEImage PrependMagickMethod(RegisterMATTEImage)
#define RegisterMETAImage PrependMagickMethod(RegisterMETAImage)
#define RegisterMIFFImage PrependMagickMethod(RegisterMIFFImage)
#define RegisterMONOImage PrependMagickMethod(RegisterMONOImage)
#define RegisterMPCImage PrependMagickMethod(RegisterMPCImage)
#define RegisterMPRImage PrependMagickMethod(RegisterMPRImage)
#define RegisterMSLImage PrependMagickMethod(RegisterMSLImage)
#define RegisterMTVImage PrependMagickMethod(RegisterMTVImage)
#define RegisterMVGImage PrependMagickMethod(RegisterMVGImage)
#define RegisterNULLImage PrependMagickMethod(RegisterNULLImage)
#define RegisterOTBImage PrependMagickMethod(RegisterOTBImage)
#define RegisterPALMImage PrependMagickMethod(RegisterPALMImage)
#define RegisterPANGOImage PrependMagickMethod(RegisterPANGOImage)
#define RegisterPATTERNImage PrependMagickMethod(RegisterPATTERNImage)
#define RegisterPCDImage PrependMagickMethod(RegisterPCDImage)
#define RegisterPCLImage PrependMagickMethod(RegisterPCLImage)
#define RegisterPCXImage PrependMagickMethod(RegisterPCXImage)
#define RegisterPDBImage PrependMagickMethod(RegisterPDBImage)
#define RegisterPDFImage PrependMagickMethod(RegisterPDFImage)
#define RegisterPESImage PrependMagickMethod(RegisterPESImage)
#define RegisterPGXImage PrependMagickMethod(RegisterPGXImage)
#define RegisterPICTImage PrependMagickMethod(RegisterPICTImage)
#define RegisterPIXImage PrependMagickMethod(RegisterPIXImage)
#define RegisterPLASMAImage PrependMagickMethod(RegisterPLASMAImage)
#define RegisterPNGImage PrependMagickMethod(RegisterPNGImage)
#define RegisterPNMImage PrependMagickMethod(RegisterPNMImage)
#define RegisterPREVIEWImage PrependMagickMethod(RegisterPREVIEWImage)
#define RegisterPS2Image PrependMagickMethod(RegisterPS2Image)
#define RegisterPS3Image PrependMagickMethod(RegisterPS3Image)
#define RegisterPSDImage PrependMagickMethod(RegisterPSDImage)
#define RegisterPSImage PrependMagickMethod(RegisterPSImage)
#define RegisterPWPImage PrependMagickMethod(RegisterPWPImage)
#define RegisterRAWImage PrependMagickMethod(RegisterRAWImage)
#define RegisterRGBImage PrependMagickMethod(RegisterRGBImage)
#define RegisterRGFImage PrependMagickMethod(RegisterRGFImage)
#define RegisterRLAImage PrependMagickMethod(RegisterRLAImage)
#define RegisterRLEImage PrependMagickMethod(RegisterRLEImage)
#define RegisterSCREENSHOTImage PrependMagickMethod(RegisterSCREENSHOTImage)
#define RegisterSCRImage PrependMagickMethod(RegisterSCRImage)
#define RegisterSCTImage PrependMagickMethod(RegisterSCTImage)
#define RegisterSFWImage PrependMagickMethod(RegisterSFWImage)
#define RegisterSGIImage PrependMagickMethod(RegisterSGIImage)
#define RegisterSIXELImage PrependMagickMethod(RegisterSIXELImage)
#define RegisterStaticModule PrependMagickMethod(RegisterStaticModule)
#define RegisterStaticModules PrependMagickMethod(RegisterStaticModules)
#define RegisterSTEGANOImage PrependMagickMethod(RegisterSTEGANOImage)
#define RegisterSUNImage PrependMagickMethod(RegisterSUNImage)
#define RegisterSVGImage PrependMagickMethod(RegisterSVGImage)
#define RegisterTGAImage PrependMagickMethod(RegisterTGAImage)
#define RegisterTHUMBNAILImage PrependMagickMethod(RegisterTHUMBNAILImage)
#define RegisterTIFFImage PrependMagickMethod(RegisterTIFFImage)
#define RegisterTILEImage PrependMagickMethod(RegisterTILEImage)
#define RegisterTIMImage PrependMagickMethod(RegisterTIMImage)
#define RegisterTTFImage PrependMagickMethod(RegisterTTFImage)
#define RegisterTXTImage PrependMagickMethod(RegisterTXTImage)
#define RegisterUILImage PrependMagickMethod(RegisterUILImage)
#define RegisterUndefinedImage PrependMagickMethod(RegisterUndefinedImage)
#define RegisterURLImage PrependMagickMethod(RegisterURLImage)
#define RegisterUYVYImage PrependMagickMethod(RegisterUYVYImage)
#define RegisterVICARImage PrependMagickMethod(RegisterVICARImage)
#define RegisterVIDEOImage PrependMagickMethod(RegisterVIDEOImage)
#define RegisterVIDImage PrependMagickMethod(RegisterVIDImage)
#define RegisterVIFFImage PrependMagickMethod(RegisterVIFFImage)
#define RegisterVIPSImage PrependMagickMethod(RegisterVIPSImage)
#define RegisterWBMPImage PrependMagickMethod(RegisterWBMPImage)
#define RegisterWEBPImage PrependMagickMethod(RegisterWEBPImage)
#define RegisterWPGImage PrependMagickMethod(RegisterWPGImage)
#define RegisterXBMImage PrependMagickMethod(RegisterXBMImage)
#define RegisterXCFImage PrependMagickMethod(RegisterXCFImage)
#define RegisterXCImage PrependMagickMethod(RegisterXCImage)
#define RegisterXImage PrependMagickMethod(RegisterXImage)
#define RegisterXPMImage PrependMagickMethod(RegisterXPMImage)
#define RegisterXPSImage PrependMagickMethod(RegisterXPSImage)
#define RegisterXWDImage PrependMagickMethod(RegisterXWDImage)
#define RegisterYCBCRImage PrependMagickMethod(RegisterYCBCRImage)
#define RegisterYUVImage PrependMagickMethod(RegisterYUVImage)
#define RegistryComponentGenesis PrependMagickMethod(RegistryComponentGenesis)
#define RegistryComponentTerminus PrependMagickMethod(RegistryComponentTerminus)
#define RelinquishAlignedMemory PrependMagickMethod(RelinquishAlignedMemory)
#define RelinquishDistributePixelCache PrependMagickMethod(RelinquishDistributePixelCache)
#define RelinquishMagickMatrix PrependMagickMethod(RelinquishMagickMatrix)
#define RelinquishMagickMemory PrependMagickMethod(RelinquishMagickMemory)
#define RelinquishMagickResource PrependMagickMethod(RelinquishMagickResource)
#define RelinquishSemaphoreInfo PrependMagickMethod(RelinquishSemaphoreInfo)
#define RelinquishUniqueFileResource PrependMagickMethod(RelinquishUniqueFileResource)
#define RelinquishVirtualMemory PrependMagickMethod(RelinquishVirtualMemory)
#define RemapImage PrependMagickMethod(RemapImage)
#define RemapImages PrependMagickMethod(RemapImages)
#define RemoteDisplayCommand PrependMagickMethod(RemoteDisplayCommand)
#define RemoveDuplicateLayers PrependMagickMethod(RemoveDuplicateLayers)
#define RemoveElementByValueFromLinkedList PrependMagickMethod(RemoveElementByValueFromLinkedList)
#define RemoveElementFromLinkedList PrependMagickMethod(RemoveElementFromLinkedList)
#define RemoveEntryFromHashmap PrependMagickMethod(RemoveEntryFromHashmap)
#define RemoveFirstImageFromList PrependMagickMethod(RemoveFirstImageFromList)
#define RemoveImageArtifact PrependMagickMethod(RemoveImageArtifact)
#define RemoveImageFromList PrependMagickMethod(RemoveImageFromList)
#define RemoveImageOption PrependMagickMethod(RemoveImageOption)
#define RemoveImageProfile PrependMagickMethod(RemoveImageProfile)
#define RemoveImageProperty PrependMagickMethod(RemoveImageProperty)
#define RemoveImageRegistry PrependMagickMethod(RemoveImageRegistry)
#define RemoveLastElementFromLinkedList PrependMagickMethod(RemoveLastElementFromLinkedList)
#define RemoveLastImageFromList PrependMagickMethod(RemoveLastImageFromList)
#define RemoveNodeByValueFromSplayTree PrependMagickMethod(RemoveNodeByValueFromSplayTree)
#define RemoveNodeFromSplayTree PrependMagickMethod(RemoveNodeFromSplayTree)
#define RemoveZeroDelayLayers PrependMagickMethod(RemoveZeroDelayLayers)
#define ReplaceImageInList PrependMagickMethod(ReplaceImageInList)
#define ReplaceImageInListReturnLast PrependMagickMethod(ReplaceImageInListReturnLast)
#define ResampleImage PrependMagickMethod(ResampleImage)
#define ResamplePixelColor PrependMagickMethod(ResamplePixelColor)
#define ResetHashmapIterator PrependMagickMethod(ResetHashmapIterator)
#define ResetImageArtifactIterator PrependMagickMethod(ResetImageArtifactIterator)
#define ResetImageAttributeIterator PrependMagickMethod(ResetImageAttributeIterator)
#define ResetImageOptionIterator PrependMagickMethod(ResetImageOptionIterator)
#define ResetImageOptions PrependMagickMethod(ResetImageOptions)
#define ResetImagePage PrependMagickMethod(ResetImagePage)
#define ResetImagePixels PrependMagickMethod(ResetImagePixels)
#define ResetImageProfileIterator PrependMagickMethod(ResetImageProfileIterator)
#define ResetImagePropertyIterator PrependMagickMethod(ResetImagePropertyIterator)
#define ResetImageRegistryIterator PrependMagickMethod(ResetImageRegistryIterator)
#define ResetLinkedListIterator PrependMagickMethod(ResetLinkedListIterator)
#define ResetMagickMemory PrependMagickMethod(ResetMagickMemory)
#define ResetMaxMemoryRequest PrependMagickMethod(ResetMaxMemoryRequest)
#define ResetPixelCacheEpoch PrependMagickMethod(ResetPixelCacheEpoch)
#define ResetQuantumState PrependMagickMethod(ResetQuantumState)
#define ResetSplayTreeIterator PrependMagickMethod(ResetSplayTreeIterator)
#define ResetSplayTree PrependMagickMethod(ResetSplayTree)
#define ResetStringInfo PrependMagickMethod(ResetStringInfo)
#define ResetTimer PrependMagickMethod(ResetTimer)
#define ResetVirtualAnonymousMemory PrependMagickMethod(ResetVirtualAnonymousMemory)
#define ResizeImage PrependMagickMethod(ResizeImage)
#define ResizeMagickMemory PrependMagickMethod(ResizeMagickMemory)
#define ResizeQuantumMemory PrependMagickMethod(ResizeQuantumMemory)
#define ResourceComponentGenesis PrependMagickMethod(ResourceComponentGenesis)
#define ResourceComponentTerminus PrependMagickMethod(ResourceComponentTerminus)
#define ReverseImageList PrependMagickMethod(ReverseImageList)
#define RGBTransformImage PrependMagickMethod(RGBTransformImage)
#define RollImage PrependMagickMethod(RollImage)
#define RotateImage PrependMagickMethod(RotateImage)
#define RotationalBlurImageChannel PrependMagickMethod(RotationalBlurImageChannel)
#define RotationalBlurImage PrependMagickMethod(RotationalBlurImage)
#define SampleImage PrependMagickMethod(SampleImage)
#define SanitizeString PrependMagickMethod(SanitizeString)
#define ScaleGeometryKernelInfo PrependMagickMethod(ScaleGeometryKernelInfo)
#define ScaleImage PrependMagickMethod(ScaleImage)
#define ScaleKernelInfo PrependMagickMethod(ScaleKernelInfo)
#define ScaleResampleFilter PrependMagickMethod(ScaleResampleFilter)
#define SeedPseudoRandomGenerator PrependMagickMethod(SeedPseudoRandomGenerator)
#define SeekBlob PrependMagickMethod(SeekBlob)
#define SegmentImage PrependMagickMethod(SegmentImage)
#define SelectiveBlurImageChannel PrependMagickMethod(SelectiveBlurImageChannel)
#define SelectiveBlurImage PrependMagickMethod(SelectiveBlurImage)
#define SemaphoreComponentGenesis PrependMagickMethod(SemaphoreComponentGenesis)
#define SemaphoreComponentTerminus PrependMagickMethod(SemaphoreComponentTerminus)
#define SeparateImageChannel PrependMagickMethod(SeparateImageChannel)
#define SeparateImage PrependMagickMethod(SeparateImage)
#define SeparateImages PrependMagickMethod(SeparateImages)
#define SepiaToneImage PrependMagickMethod(SepiaToneImage)
#define SetBlobExempt PrependMagickMethod(SetBlobExempt)
#define SetBlobExtent PrependMagickMethod(SetBlobExtent)
#define SetCacheThreshold PrependMagickMethod(SetCacheThreshold)
#define SetCacheViewPixels PrependMagickMethod(SetCacheViewPixels)
#define SetCacheViewStorageClass PrependMagickMethod(SetCacheViewStorageClass)
#define SetCacheViewVirtualPixelMethod PrependMagickMethod(SetCacheViewVirtualPixelMethod)
#define SetClientName PrependMagickMethod(SetClientName)
#define SetClientPath PrependMagickMethod(SetClientPath)
#define SetErrorHandler PrependMagickMethod(SetErrorHandler)
#define SetExceptionInfo PrependMagickMethod(SetExceptionInfo)
#define SetFatalErrorHandler PrependMagickMethod(SetFatalErrorHandler)
#define SetGeometryInfo PrependMagickMethod(SetGeometryInfo)
#define SetGeometry PrependMagickMethod(SetGeometry)
#define SetHeadElementInLinkedList PrependMagickMethod(SetHeadElementInLinkedList)
#define SetImageAlphaChannel PrependMagickMethod(SetImageAlphaChannel)
#define SetImageArtifact PrependMagickMethod(SetImageArtifact)
#define SetImageAttribute PrependMagickMethod(SetImageAttribute)
#define SetImageBackgroundColor PrependMagickMethod(SetImageBackgroundColor)
#define SetImageChannelDepth PrependMagickMethod(SetImageChannelDepth)
#define SetImageChannels PrependMagickMethod(SetImageChannels)
#define SetImageClipMask PrependMagickMethod(SetImageClipMask)
#define SetImageColor PrependMagickMethod(SetImageColor)
#define SetImageColorspace PrependMagickMethod(SetImageColorspace)
#define SetImageDepth PrependMagickMethod(SetImageDepth)
#define SetImageExtent PrependMagickMethod(SetImageExtent)
#define SetImageGray PrependMagickMethod(SetImageGray)
#define SetImageInfoBlob PrependMagickMethod(SetImageInfoBlob)
#define SetImageInfoFile PrependMagickMethod(SetImageInfoFile)
#define SetImageInfo PrependMagickMethod(SetImageInfo)
#define SetImageInfoProgressMonitor PrependMagickMethod(SetImageInfoProgressMonitor)
#define SetImageList PrependMagickMethod(SetImageList)
#define SetImageMask PrependMagickMethod(SetImageMask)
#define SetImageMonochrome PrependMagickMethod(SetImageMonochrome)
#define SetImageOpacity PrependMagickMethod(SetImageOpacity)
#define SetImageOption PrependMagickMethod(SetImageOption)
#define SetImagePixels PrependMagickMethod(SetImagePixels)
#define SetImage PrependMagickMethod(SetImage)
#define SetImageProfile PrependMagickMethod(SetImageProfile)
#define SetImageProgressMonitor PrependMagickMethod(SetImageProgressMonitor)
#define SetImageProgress PrependMagickMethod(SetImageProgress)
#define SetImageProperty PrependMagickMethod(SetImageProperty)
#define SetImageRegistry PrependMagickMethod(SetImageRegistry)
#define SetImageStorageClass PrependMagickMethod(SetImageStorageClass)
#define SetImageType PrependMagickMethod(SetImageType)
#define SetImageViewDescription PrependMagickMethod(SetImageViewDescription)
#define SetImageViewIterator PrependMagickMethod(SetImageViewIterator)
#define SetImageViewThreads PrependMagickMethod(SetImageViewThreads)
#define SetImageVirtualPixelMethod PrependMagickMethod(SetImageVirtualPixelMethod)
#define SetLogEventMask PrependMagickMethod(SetLogEventMask)
#define SetLogFormat PrependMagickMethod(SetLogFormat)
#define SetLogMethod PrependMagickMethod(SetLogMethod)
#define SetLogName PrependMagickMethod(SetLogName)
#define SetMagickAlignedMemoryMethods PrependMagickMethod(SetMagickAlignedMemoryMethods)
#define SetMagickInfo PrependMagickMethod(SetMagickInfo)
#define SetMagickMemoryMethods PrependMagickMethod(SetMagickMemoryMethods)
#define SetMagickOpenCLEnvParam PrependMagickMethod(SetMagickOpenCLEnvParam)
#define SetMagickPrecision PrependMagickMethod(SetMagickPrecision)
#define SetMagickRegistry PrependMagickMethod(SetMagickRegistry)
#define SetMagickResourceLimit PrependMagickMethod(SetMagickResourceLimit)
#define SetMagickSecurityPolicy PrependMagickMethod(SetMagickSecurityPolicy)
#define SetMagickThreadValue PrependMagickMethod(SetMagickThreadValue)
#define SetMatrixElement PrependMagickMethod(SetMatrixElement)
#define SetMonitorHandler PrependMagickMethod(SetMonitorHandler)
#define SetPixelCacheMethods PrependMagickMethod(SetPixelCacheMethods)
#define SetPixelCacheVirtualMethod PrependMagickMethod(SetPixelCacheVirtualMethod)
#define SetQuantumAlphaType PrependMagickMethod(SetQuantumAlphaType)
#define SetQuantumDepth PrependMagickMethod(SetQuantumDepth)
#define SetQuantumEndian PrependMagickMethod(SetQuantumEndian)
#define SetQuantumFormat PrependMagickMethod(SetQuantumFormat)
#define SetQuantumImageType PrependMagickMethod(SetQuantumImageType)
#define SetQuantumMinIsWhite PrependMagickMethod(SetQuantumMinIsWhite)
#define SetQuantumPack PrependMagickMethod(SetQuantumPack)
#define SetQuantumPad PrependMagickMethod(SetQuantumPad)
#define SetQuantumQuantum PrependMagickMethod(SetQuantumQuantum)
#define SetQuantumScale PrependMagickMethod(SetQuantumScale)
#define SetRandomKey PrependMagickMethod(SetRandomKey)
#define SetRandomSecretKey PrependMagickMethod(SetRandomSecretKey)
#define SetRandomTrueRandom PrependMagickMethod(SetRandomTrueRandom)
#define SetResampleFilterInterpolateMethod PrependMagickMethod(SetResampleFilterInterpolateMethod)
#define SetResampleFilter PrependMagickMethod(SetResampleFilter)
#define SetResampleFilterVirtualPixelMethod PrependMagickMethod(SetResampleFilterVirtualPixelMethod)
#define SetSignatureDigest PrependMagickMethod(SetSignatureDigest)
#define SetStreamInfoClientData PrependMagickMethod(SetStreamInfoClientData)
#define SetStreamInfoMap PrependMagickMethod(SetStreamInfoMap)
#define SetStreamInfoStorageType PrependMagickMethod(SetStreamInfoStorageType)
#define SetStringInfoDatum PrependMagickMethod(SetStringInfoDatum)
#define SetStringInfoLength PrependMagickMethod(SetStringInfoLength)
#define SetStringInfoName PrependMagickMethod(SetStringInfoName)
#define SetStringInfoPath PrependMagickMethod(SetStringInfoPath)
#define SetStringInfo PrependMagickMethod(SetStringInfo)
#define SetWarningHandler PrependMagickMethod(SetWarningHandler)
#define SetXMLTreeAttribute PrependMagickMethod(SetXMLTreeAttribute)
#define SetXMLTreeContent PrependMagickMethod(SetXMLTreeContent)
#define ShadeImage PrependMagickMethod(ShadeImage)
#define ShadowImage PrependMagickMethod(ShadowImage)
#define SharpenImageChannel PrependMagickMethod(SharpenImageChannel)
#define SharpenImage PrependMagickMethod(SharpenImage)
#define ShaveImage PrependMagickMethod(ShaveImage)
#define ShearImage PrependMagickMethod(ShearImage)
#define ShearRotateImage PrependMagickMethod(ShearRotateImage)
#define ShiftImageList PrependMagickMethod(ShiftImageList)
#define ShowKernelInfo PrependMagickMethod(ShowKernelInfo)
#define ShredFile PrependMagickMethod(ShredFile)
#define ShredMagickMemory PrependMagickMethod(ShredMagickMemory)
#define SigmoidalContrastImageChannel PrependMagickMethod(SigmoidalContrastImageChannel)
#define SigmoidalContrastImage PrependMagickMethod(SigmoidalContrastImage)
#define SignatureImage PrependMagickMethod(SignatureImage)
#define SimilarityImage PrependMagickMethod(SimilarityImage)
#define SimilarityMetricImage PrependMagickMethod(SimilarityMetricImage)
#define sixel_decode PrependMagickMethod(sixel_decode)
#define sixel_output_create PrependMagickMethod(sixel_output_create)
#define SizeBlob PrependMagickMethod(SizeBlob)
#define SketchImage PrependMagickMethod(SketchImage)
#define SmushImages PrependMagickMethod(SmushImages)
#define SolarizeImageChannel PrependMagickMethod(SolarizeImageChannel)
#define SolarizeImage PrependMagickMethod(SolarizeImage)
#define SortColormapByIntensity PrependMagickMethod(SortColormapByIntensity)
#define SparseColorImage PrependMagickMethod(SparseColorImage)
#define SpliceImageIntoList PrependMagickMethod(SpliceImageIntoList)
#define SpliceImageList PrependMagickMethod(SpliceImageList)
#define SpliceImage PrependMagickMethod(SpliceImage)
#define SplitImageList PrependMagickMethod(SplitImageList)
#define SplitStringInfo PrependMagickMethod(SplitStringInfo)
#define SpreadImage PrependMagickMethod(SpreadImage)
#define sRGBCompandor PrependMagickMethod(sRGBCompandor)
#define StartTimer PrependMagickMethod(StartTimer)
#define StatisticImageChannel PrependMagickMethod(StatisticImageChannel)
#define StatisticImage PrependMagickMethod(StatisticImage)
#define SteganoImage PrependMagickMethod(SteganoImage)
#define StereoAnaglyphImage PrependMagickMethod(StereoAnaglyphImage)
#define StereoImage PrependMagickMethod(StereoImage)
#define StreamImage PrependMagickMethod(StreamImage)
#define StringInfoToHexString PrependMagickMethod(StringInfoToHexString)
#define StringInfoToString PrependMagickMethod(StringInfoToString)
#define StringToArgv PrependMagickMethod(StringToArgv)
#define StringToArrayOfDoubles PrependMagickMethod(StringToArrayOfDoubles)
#define StringToken PrependMagickMethod(StringToken)
#define StringToList PrependMagickMethod(StringToList)
#define StringToStringInfo PrependMagickMethod(StringToStringInfo)
#define StringToStrings PrependMagickMethod(StringToStrings)
#define StripImage PrependMagickMethod(StripImage)
#define Strip PrependMagickMethod(Strip)
#define StripString PrependMagickMethod(StripString)
#define SubstituteString PrependMagickMethod(SubstituteString)
#define SwirlImage PrependMagickMethod(SwirlImage)
#define SyncAuthenticPixelCacheNexus PrependMagickMethod(SyncAuthenticPixelCacheNexus)
#define SyncAuthenticPixels PrependMagickMethod(SyncAuthenticPixels)
#define SyncCacheViewAuthenticPixels PrependMagickMethod(SyncCacheViewAuthenticPixels)
#define SyncCacheViewPixels PrependMagickMethod(SyncCacheViewPixels)
#define SyncCacheView PrependMagickMethod(SyncCacheView)
#define SyncImageList PrependMagickMethod(SyncImageList)
#define SyncImagePixelCache PrependMagickMethod(SyncImagePixelCache)
#define SyncImagePixels PrependMagickMethod(SyncImagePixels)
#define SyncImage PrependMagickMethod(SyncImage)
#define SyncImageProfiles PrependMagickMethod(SyncImageProfiles)
#define SyncImageSettings PrependMagickMethod(SyncImageSettings)
#define SyncImagesSettings PrependMagickMethod(SyncImagesSettings)
#define SyncNextImageInList PrependMagickMethod(SyncNextImageInList)
#define SystemCommand PrependMagickMethod(SystemCommand)
#define TellBlob PrependMagickMethod(TellBlob)
#define TemporaryFilename PrependMagickMethod(TemporaryFilename)
#define TextureImage PrependMagickMethod(TextureImage)
#define ThresholdImageChannel PrependMagickMethod(ThresholdImageChannel)
#define ThresholdImage PrependMagickMethod(ThresholdImage)
#define ThrowMagickExceptionList PrependMagickMethod(ThrowMagickExceptionList)
#define ThrowMagickException PrependMagickMethod(ThrowMagickException)
#define ThumbnailImage PrependMagickMethod(ThumbnailImage)
#define TintImage PrependMagickMethod(TintImage)
#define Tokenizer PrependMagickMethod(Tokenizer)
#define TransferImageViewIterator PrependMagickMethod(TransferImageViewIterator)
#define TransformColorspace PrependMagickMethod(TransformColorspace)
#define TransformHSL PrependMagickMethod(TransformHSL)
#define TransformImageColorspace PrependMagickMethod(TransformImageColorspace)
#define TransformImage PrependMagickMethod(TransformImage)
#define TransformImages PrependMagickMethod(TransformImages)
#define TransformRGBImage PrependMagickMethod(TransformRGBImage)
#define TranslateText PrependMagickMethod(TranslateText)
#define TransparentImage PrependMagickMethod(TransparentImage)
#define TransparentPaintImageChroma PrependMagickMethod(TransparentPaintImageChroma)
#define TransparentPaintImage PrependMagickMethod(TransparentPaintImage)
#define TransposeImage PrependMagickMethod(TransposeImage)
#define TransverseImage PrependMagickMethod(TransverseImage)
#define TrimImage PrependMagickMethod(TrimImage)
#define TypeComponentGenesis PrependMagickMethod(TypeComponentGenesis)
#define TypeComponentTerminus PrependMagickMethod(TypeComponentTerminus)
#define UniqueImageColors PrependMagickMethod(UniqueImageColors)
#define UnityAddKernelInfo PrependMagickMethod(UnityAddKernelInfo)
#define UnlockSemaphoreInfo PrependMagickMethod(UnlockSemaphoreInfo)
#define UnmapBlob PrependMagickMethod(UnmapBlob)
#define UnregisterAAIImage PrependMagickMethod(UnregisterAAIImage)
#define UnregisterARTImage PrependMagickMethod(UnregisterARTImage)
#define UnregisterAVSImage PrependMagickMethod(UnregisterAVSImage)
#define UnregisterBGRImage PrependMagickMethod(UnregisterBGRImage)
#define UnregisterBMPImage PrependMagickMethod(UnregisterBMPImage)
#define UnregisterBRAILLEImage PrependMagickMethod(UnregisterBRAILLEImage)
#define UnregisterCALSImage PrependMagickMethod(UnregisterCALSImage)
#define UnregisterCAPTIONImage PrependMagickMethod(UnregisterCAPTIONImage)
#define UnregisterCINImage PrependMagickMethod(UnregisterCINImage)
#define UnregisterCIPImage PrependMagickMethod(UnregisterCIPImage)
#define UnregisterCLIPImage PrependMagickMethod(UnregisterCLIPImage)
#define UnregisterCMYKImage PrependMagickMethod(UnregisterCMYKImage)
#define UnregisterCUTImage PrependMagickMethod(UnregisterCUTImage)
#define UnregisterDCMImage PrependMagickMethod(UnregisterDCMImage)
#define UnregisterDDSImage PrependMagickMethod(UnregisterDDSImage)
#define UnregisterDEBUGImage PrependMagickMethod(UnregisterDEBUGImage)
#define UnregisterDIBImage PrependMagickMethod(UnregisterDIBImage)
#define UnregisterDJVUImage PrependMagickMethod(UnregisterDJVUImage)
#define UnregisterDNGImage PrependMagickMethod(UnregisterDNGImage)
#define UnregisterDOTImage PrependMagickMethod(UnregisterDOTImage)
#define UnregisterDPXImage PrependMagickMethod(UnregisterDPXImage)
#define UnregisterEPTImage PrependMagickMethod(UnregisterEPTImage)
#define UnregisterEXRImage PrependMagickMethod(UnregisterEXRImage)
#define UnregisterFAXImage PrependMagickMethod(UnregisterFAXImage)
#define UnregisterFITSImage PrependMagickMethod(UnregisterFITSImage)
#define UnregisterGIFImage PrependMagickMethod(UnregisterGIFImage)
#define UnregisterGRADIENTImage PrependMagickMethod(UnregisterGRADIENTImage)
#define UnregisterGRAYImage PrependMagickMethod(UnregisterGRAYImage)
#define UnregisterHALDImage PrependMagickMethod(UnregisterHALDImage)
#define UnregisterHDRImage PrependMagickMethod(UnregisterHDRImage)
#define UnregisterHEICImage PrependMagickMethod(UnregisterHEICImage)
#define UnregisterHISTOGRAMImage PrependMagickMethod(UnregisterHISTOGRAMImage)
#define UnregisterHRZImage PrependMagickMethod(UnregisterHRZImage)
#define UnregisterHTMLImage PrependMagickMethod(UnregisterHTMLImage)
#define UnregisterICONImage PrependMagickMethod(UnregisterICONImage)
#define UnregisterINFOImage PrependMagickMethod(UnregisterINFOImage)
#define UnregisterINLINEImage PrependMagickMethod(UnregisterINLINEImage)
#define UnregisterIPLImage PrependMagickMethod(UnregisterIPLImage)
#define UnregisterJBIGImage PrependMagickMethod(UnregisterJBIGImage)
#define UnregisterJNXImage PrependMagickMethod(UnregisterJNXImage)
#define UnregisterJP2Image PrependMagickMethod(UnregisterJP2Image)
#define UnregisterJPEGImage PrependMagickMethod(UnregisterJPEGImage)
#define UnregisterJSONImage PrependMagickMethod(UnregisterJSONImage)
#define UnregisterLABELImage PrependMagickMethod(UnregisterLABELImage)
#define UnregisterMACImage PrependMagickMethod(UnregisterMACImage)
#define UnregisterMAGICKImage PrependMagickMethod(UnregisterMAGICKImage)
#define UnregisterMagickInfo PrependMagickMethod(UnregisterMagickInfo)
#define UnregisterMAPImage PrependMagickMethod(UnregisterMAPImage)
#define UnregisterMASKImage PrependMagickMethod(UnregisterMASKImage)
#define UnregisterMATImage PrependMagickMethod(UnregisterMATImage)
#define UnregisterMATTEImage PrependMagickMethod(UnregisterMATTEImage)
#define UnregisterMETAImage PrependMagickMethod(UnregisterMETAImage)
#define UnregisterMIFFImage PrependMagickMethod(UnregisterMIFFImage)
#define UnregisterMONOImage PrependMagickMethod(UnregisterMONOImage)
#define UnregisterMPCImage PrependMagickMethod(UnregisterMPCImage)
#define UnregisterMPRImage PrependMagickMethod(UnregisterMPRImage)
#define UnregisterMSLImage PrependMagickMethod(UnregisterMSLImage)
#define UnregisterMTVImage PrependMagickMethod(UnregisterMTVImage)
#define UnregisterMVGImage PrependMagickMethod(UnregisterMVGImage)
#define UnregisterNULLImage PrependMagickMethod(UnregisterNULLImage)
#define UnregisterOTBImage PrependMagickMethod(UnregisterOTBImage)
#define UnregisterPALMImage PrependMagickMethod(UnregisterPALMImage)
#define UnregisterPANGOImage PrependMagickMethod(UnregisterPANGOImage)
#define UnregisterPATTERNImage PrependMagickMethod(UnregisterPATTERNImage)
#define UnregisterPCDImage PrependMagickMethod(UnregisterPCDImage)
#define UnregisterPCLImage PrependMagickMethod(UnregisterPCLImage)
#define UnregisterPCXImage PrependMagickMethod(UnregisterPCXImage)
#define UnregisterPDBImage PrependMagickMethod(UnregisterPDBImage)
#define UnregisterPDFImage PrependMagickMethod(UnregisterPDFImage)
#define UnregisterPESImage PrependMagickMethod(UnregisterPESImage)
#define UnregisterPGXImage PrependMagickMethod(UnregisterPGXImage)
#define UnregisterPICTImage PrependMagickMethod(UnregisterPICTImage)
#define UnregisterPIXImage PrependMagickMethod(UnregisterPIXImage)
#define UnregisterPLASMAImage PrependMagickMethod(UnregisterPLASMAImage)
#define UnregisterPNGImage PrependMagickMethod(UnregisterPNGImage)
#define UnregisterPNMImage PrependMagickMethod(UnregisterPNMImage)
#define UnregisterPREVIEWImage PrependMagickMethod(UnregisterPREVIEWImage)
#define UnregisterPS2Image PrependMagickMethod(UnregisterPS2Image)
#define UnregisterPS3Image PrependMagickMethod(UnregisterPS3Image)
#define UnregisterPSDImage PrependMagickMethod(UnregisterPSDImage)
#define UnregisterPSImage PrependMagickMethod(UnregisterPSImage)
#define UnregisterPWPImage PrependMagickMethod(UnregisterPWPImage)
#define UnregisterRAWImage PrependMagickMethod(UnregisterRAWImage)
#define UnregisterRGBImage PrependMagickMethod(UnregisterRGBImage)
#define UnregisterRGFImage PrependMagickMethod(UnregisterRGFImage)
#define UnregisterRLAImage PrependMagickMethod(UnregisterRLAImage)
#define UnregisterRLEImage PrependMagickMethod(UnregisterRLEImage)
#define UnregisterSCREENSHOTImage PrependMagickMethod(UnregisterSCREENSHOTImage)
#define UnregisterSCRImage PrependMagickMethod(UnregisterSCRImage)
#define UnregisterSCTImage PrependMagickMethod(UnregisterSCTImage)
#define UnregisterSFWImage PrependMagickMethod(UnregisterSFWImage)
#define UnregisterSGIImage PrependMagickMethod(UnregisterSGIImage)
#define UnregisterSIXELImage PrependMagickMethod(UnregisterSIXELImage)
#define UnregisterStaticModule PrependMagickMethod(UnregisterStaticModule)
#define UnregisterStaticModules PrependMagickMethod(UnregisterStaticModules)
#define UnregisterSTEGANOImage PrependMagickMethod(UnregisterSTEGANOImage)
#define UnregisterSUNImage PrependMagickMethod(UnregisterSUNImage)
#define UnregisterSVGImage PrependMagickMethod(UnregisterSVGImage)
#define UnregisterTGAImage PrependMagickMethod(UnregisterTGAImage)
#define UnregisterTHUMBNAILImage PrependMagickMethod(UnregisterTHUMBNAILImage)
#define UnregisterTIFFImage PrependMagickMethod(UnregisterTIFFImage)
#define UnregisterTILEImage PrependMagickMethod(UnregisterTILEImage)
#define UnregisterTIMImage PrependMagickMethod(UnregisterTIMImage)
#define UnregisterTTFImage PrependMagickMethod(UnregisterTTFImage)
#define UnregisterTXTImage PrependMagickMethod(UnregisterTXTImage)
#define UnregisterUILImage PrependMagickMethod(UnregisterUILImage)
#define UnregisterUndefinedImage PrependMagickMethod(UnregisterUndefinedImage)
#define UnregisterURLImage PrependMagickMethod(UnregisterURLImage)
#define UnregisterUYVYImage PrependMagickMethod(UnregisterUYVYImage)
#define UnregisterVICARImage PrependMagickMethod(UnregisterVICARImage)
#define UnregisterVIDEOImage PrependMagickMethod(UnregisterVIDEOImage)
#define UnregisterVIDImage PrependMagickMethod(UnregisterVIDImage)
#define UnregisterVIFFImage PrependMagickMethod(UnregisterVIFFImage)
#define UnregisterVIPSImage PrependMagickMethod(UnregisterVIPSImage)
#define UnregisterWBMPImage PrependMagickMethod(UnregisterWBMPImage)
#define UnregisterWEBPImage PrependMagickMethod(UnregisterWEBPImage)
#define UnregisterWPGImage PrependMagickMethod(UnregisterWPGImage)
#define UnregisterXBMImage PrependMagickMethod(UnregisterXBMImage)
#define UnregisterXCFImage PrependMagickMethod(UnregisterXCFImage)
#define UnregisterXCImage PrependMagickMethod(UnregisterXCImage)
#define UnregisterXImage PrependMagickMethod(UnregisterXImage)
#define UnregisterXPMImage PrependMagickMethod(UnregisterXPMImage)
#define UnregisterXPSImage PrependMagickMethod(UnregisterXPSImage)
#define UnregisterXWDImage PrependMagickMethod(UnregisterXWDImage)
#define UnregisterYCBCRImage PrependMagickMethod(UnregisterYCBCRImage)
#define UnregisterYUVImage PrependMagickMethod(UnregisterYUVImage)
#define UnsharpMaskImageChannel PrependMagickMethod(UnsharpMaskImageChannel)
#define UnsharpMaskImage PrependMagickMethod(UnsharpMaskImage)
#define UnshiftImageList PrependMagickMethod(UnshiftImageList)
#define UpdateImageViewIterator PrependMagickMethod(UpdateImageViewIterator)
#define UpdateSignature PrependMagickMethod(UpdateSignature)
#define ValidateColormapIndex PrependMagickMethod(ValidateColormapIndex)
#define VignetteImage PrependMagickMethod(VignetteImage)
#define WaveImage PrependMagickMethod(WaveImage)
#define WaveletDenoiseImage PrependMagickMethod(WaveletDenoiseImage)
#define WhiteThresholdImageChannel PrependMagickMethod(WhiteThresholdImageChannel)
#define WhiteThresholdImage PrependMagickMethod(WhiteThresholdImage)
#define WriteBlobByte PrependMagickMethod(WriteBlobByte)
#define WriteBlobFloat PrependMagickMethod(WriteBlobFloat)
#define WriteBlobLong PrependMagickMethod(WriteBlobLong)
#define WriteBlobLSBLong PrependMagickMethod(WriteBlobLSBLong)
#define WriteBlobLSBShort PrependMagickMethod(WriteBlobLSBShort)
#define WriteBlobLSBSignedLong PrependMagickMethod(WriteBlobLSBSignedLong)
#define WriteBlobLSBSignedShort PrependMagickMethod(WriteBlobLSBSignedShort)
#define WriteBlobMSBLongLong PrependMagickMethod(WriteBlobMSBLongLong)
#define WriteBlobMSBLong PrependMagickMethod(WriteBlobMSBLong)
#define WriteBlobMSBShort PrependMagickMethod(WriteBlobMSBShort)
#define WriteBlobMSBSignedLong PrependMagickMethod(WriteBlobMSBSignedLong)
#define WriteBlobMSBSignedShort PrependMagickMethod(WriteBlobMSBSignedShort)
#define WriteBlob PrependMagickMethod(WriteBlob)
#define WriteBlobShort PrependMagickMethod(WriteBlobShort)
#define WriteBlobString PrependMagickMethod(WriteBlobString)
#define WriteDistributePixelCacheIndexes PrependMagickMethod(WriteDistributePixelCacheIndexes)
#define WriteDistributePixelCachePixels PrependMagickMethod(WriteDistributePixelCachePixels)
#define WriteImage PrependMagickMethod(WriteImage)
#define WriteImages PrependMagickMethod(WriteImages)
#define WriteStream PrependMagickMethod(WriteStream)
#define XAnimateBackgroundImage PrependMagickMethod(XAnimateBackgroundImage)
#define XAnimateImages PrependMagickMethod(XAnimateImages)
#define XAnnotateImage PrependMagickMethod(XAnnotateImage)
#define XBestFont PrependMagickMethod(XBestFont)
#define XBestIconSize PrependMagickMethod(XBestIconSize)
#define XBestPixel PrependMagickMethod(XBestPixel)
#define XBestVisualInfo PrependMagickMethod(XBestVisualInfo)
#define XCheckDefineCursor PrependMagickMethod(XCheckDefineCursor)
#define XCheckRefreshWindows PrependMagickMethod(XCheckRefreshWindows)
#define XClientMessage PrependMagickMethod(XClientMessage)
#define XColorBrowserWidget PrependMagickMethod(XColorBrowserWidget)
#define XCommandWidget PrependMagickMethod(XCommandWidget)
#define XComponentGenesis PrependMagickMethod(XComponentGenesis)
#define XComponentTerminus PrependMagickMethod(XComponentTerminus)
#define XConfigureImageColormap PrependMagickMethod(XConfigureImageColormap)
#define XConfirmWidget PrependMagickMethod(XConfirmWidget)
#define XConstrainWindowPosition PrependMagickMethod(XConstrainWindowPosition)
#define XDelay PrependMagickMethod(XDelay)
#define XDestroyResourceInfo PrependMagickMethod(XDestroyResourceInfo)
#define XDestroyWindowColors PrependMagickMethod(XDestroyWindowColors)
#define XDialogWidget PrependMagickMethod(XDialogWidget)
#define XDisplayBackgroundImage PrependMagickMethod(XDisplayBackgroundImage)
#define XDisplayImageInfo PrependMagickMethod(XDisplayImageInfo)
#define XDisplayImage PrependMagickMethod(XDisplayImage)
#define XDrawImage PrependMagickMethod(XDrawImage)
#define XError PrependMagickMethod(XError)
#define XFileBrowserWidget PrependMagickMethod(XFileBrowserWidget)
#define XFontBrowserWidget PrependMagickMethod(XFontBrowserWidget)
#define XFreeResources PrependMagickMethod(XFreeResources)
#define XFreeStandardColormap PrependMagickMethod(XFreeStandardColormap)
#define XGetAnnotateInfo PrependMagickMethod(XGetAnnotateInfo)
#define XGetImportInfo PrependMagickMethod(XGetImportInfo)
#define XGetMapInfo PrependMagickMethod(XGetMapInfo)
#define XGetPixelPacket PrependMagickMethod(XGetPixelPacket)
#define XGetResourceClass PrependMagickMethod(XGetResourceClass)
#define XGetResourceDatabase PrependMagickMethod(XGetResourceDatabase)
#define XGetResourceInfo PrependMagickMethod(XGetResourceInfo)
#define XGetResourceInstance PrependMagickMethod(XGetResourceInstance)
#define XGetScreenDensity PrependMagickMethod(XGetScreenDensity)
#define XGetWindowColor PrependMagickMethod(XGetWindowColor)
#define XGetWindowInfo PrependMagickMethod(XGetWindowInfo)
#define XHighlightEllipse PrependMagickMethod(XHighlightEllipse)
#define XHighlightLine PrependMagickMethod(XHighlightLine)
#define XHighlightRectangle PrependMagickMethod(XHighlightRectangle)
#define XImportImage PrependMagickMethod(XImportImage)
#define XInfoWidget PrependMagickMethod(XInfoWidget)
#define XInitializeWindows PrependMagickMethod(XInitializeWindows)
#define XListBrowserWidget PrependMagickMethod(XListBrowserWidget)
#define XMagickProgressMonitor PrependMagickMethod(XMagickProgressMonitor)
#define XMakeCursor PrependMagickMethod(XMakeCursor)
#define XMakeImage PrependMagickMethod(XMakeImage)
#define XMakeMagnifyImage PrependMagickMethod(XMakeMagnifyImage)
#define XMakeStandardColormap PrependMagickMethod(XMakeStandardColormap)
#define XMakeWindow PrependMagickMethod(XMakeWindow)
#define XMenuWidget PrependMagickMethod(XMenuWidget)
#define XMLTreeInfoToXML PrependMagickMethod(XMLTreeInfoToXML)
#define XNoticeWidget PrependMagickMethod(XNoticeWidget)
#define XPreferencesWidget PrependMagickMethod(XPreferencesWidget)
#define XProgressMonitorWidget PrependMagickMethod(XProgressMonitorWidget)
#define XQueryColorDatabase PrependMagickMethod(XQueryColorDatabase)
#define XQueryPosition PrependMagickMethod(XQueryPosition)
#define XRefreshWindow PrependMagickMethod(XRefreshWindow)
#define XRemoteCommand PrependMagickMethod(XRemoteCommand)
#define XRenderImage PrependMagickMethod(XRenderImage)
#define XRetainWindowColors PrependMagickMethod(XRetainWindowColors)
#define XSetCursorState PrependMagickMethod(XSetCursorState)
#define XSetWindows PrependMagickMethod(XSetWindows)
#define XTextViewWidget PrependMagickMethod(XTextViewWidget)
#define XUserPreferences PrependMagickMethod(XUserPreferences)
#define XWarning PrependMagickMethod(XWarning)
#define XWindowByID PrependMagickMethod(XWindowByID)
#define XWindowByName PrependMagickMethod(XWindowByName)
#define XWindowByProperty PrependMagickMethod(XWindowByProperty)
#define ZeroKernelNans PrependMagickMethod(ZeroKernelNans)
#define ZLIBEncodeImage PrependMagickMethod(ZLIBEncodeImage)
#define ZoomImage PrependMagickMethod(ZoomImage)
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/morphology.h 0000644 00000011072 14751151177 0010361 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore morphology methods.
*/
#ifndef MAGICKCORE_MORPHOLOGY_H
#define MAGICKCORE_MORPHOLOGY_H
#include "magick/geometry.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedKernel, /* equivalent to UnityKernel */
UnityKernel, /* The no-op or 'original image' kernel */
GaussianKernel, /* Convolution Kernels, Gaussian Based */
DoGKernel,
LoGKernel,
BlurKernel,
CometKernel,
LaplacianKernel, /* Convolution Kernels, by Name */
SobelKernel,
FreiChenKernel,
RobertsKernel,
PrewittKernel,
CompassKernel,
KirschKernel,
DiamondKernel, /* Shape Kernels */
SquareKernel,
RectangleKernel,
OctagonKernel,
DiskKernel,
PlusKernel,
CrossKernel,
RingKernel,
PeaksKernel, /* Hit And Miss Kernels */
EdgesKernel,
CornersKernel,
DiagonalsKernel,
LineEndsKernel,
LineJunctionsKernel,
RidgesKernel,
ConvexHullKernel,
ThinSEKernel,
SkeletonKernel,
ChebyshevKernel, /* Distance Measuring Kernels */
ManhattanKernel,
OctagonalKernel,
EuclideanKernel,
UserDefinedKernel, /* User Specified Kernel Array */
BinomialKernel
} KernelInfoType;
typedef enum
{
UndefinedMorphology,
/* Convolve / Correlate weighted sums */
ConvolveMorphology, /* Weighted Sum with reflected kernel */
CorrelateMorphology, /* Weighted Sum using a sliding window */
/* Low-level Morphology methods */
ErodeMorphology, /* Minimum Value in Neighbourhood */
DilateMorphology, /* Maximum Value in Neighbourhood */
ErodeIntensityMorphology, /* Pixel Pick using GreyScale Erode */
DilateIntensityMorphology, /* Pixel Pick using GreyScale Dialate */
DistanceMorphology, /* Add Kernel Value, take Minimum */
/* Second-level Morphology methods */
OpenMorphology, /* Dilate then Erode */
CloseMorphology, /* Erode then Dilate */
OpenIntensityMorphology, /* Pixel Pick using GreyScale Open */
CloseIntensityMorphology, /* Pixel Pick using GreyScale Close */
SmoothMorphology, /* Open then Close */
/* Difference Morphology methods */
EdgeInMorphology, /* Dilate difference from Original */
EdgeOutMorphology, /* Erode difference from Original */
EdgeMorphology, /* Dilate difference with Erode */
TopHatMorphology, /* Close difference from Original */
BottomHatMorphology, /* Open difference from Original */
/* Recursive Morphology methods */
HitAndMissMorphology, /* Foreground/Background pattern matching */
ThinningMorphology, /* Remove matching pixels from image */
ThickenMorphology, /* Add matching pixels from image */
/* Experimental Morphology methods */
VoronoiMorphology, /* distance matte channel copy nearest color */
IterativeDistanceMorphology /* Add Kernel Value, take Minimum */
} MorphologyMethod;
typedef struct KernelInfo
{
KernelInfoType
type;
size_t
width,
height;
ssize_t
x,
y;
double
*values,
minimum,
maximum,
negative_range,
positive_range,
angle;
struct KernelInfo
*next;
size_t
signature;
} KernelInfo;
extern MagickExport KernelInfo
*AcquireKernelInfo(const char *),
*AcquireKernelBuiltIn(const KernelInfoType,const GeometryInfo *),
*CloneKernelInfo(const KernelInfo *),
*DestroyKernelInfo(KernelInfo *);
extern MagickExport Image
*MorphologyImage(const Image *,const MorphologyMethod,const ssize_t,
const KernelInfo *,ExceptionInfo *),
*MorphologyImageChannel(const Image *,const ChannelType,
const MorphologyMethod,const ssize_t,const KernelInfo *,ExceptionInfo *);
extern MagickExport void
ScaleGeometryKernelInfo(KernelInfo *,const char *),
ScaleKernelInfo(KernelInfo *,const double,const GeometryFlags),
ShowKernelInfo(const KernelInfo *),
UnityAddKernelInfo(KernelInfo *,const double);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/xwindow.h 0000644 00000002130 14751151177 0007654 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore X11 window methods.
*/
#ifndef MAGICKCORE_XWINDOW_H
#define MAGICKCORE_XWINDOW_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _XImportInfo
{
MagickBooleanType
frame,
borders,
screen,
descend,
silent;
} XImportInfo;
extern MagickExport Image
*XImportImage(const ImageInfo *,XImportInfo *);
extern MagickExport void
XGetImportInfo(XImportInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/timer.h 0000644 00000003101 14751151177 0007274 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore timer methods.
*/
#ifndef MAGICKCORE_TIMER_H
#define MAGICKCORE_TIMER_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedTimerState,
StoppedTimerState,
RunningTimerState
} TimerState;
typedef struct _Timer
{
double
start,
stop,
total;
} Timer;
typedef struct _TimerInfo
{
Timer
user,
elapsed;
TimerState
state;
size_t
signature;
} TimerInfo;
extern MagickExport double
GetElapsedTime(TimerInfo *),
GetUserTime(TimerInfo *);
extern MagickExport MagickBooleanType
ContinueTimer(TimerInfo *);
extern MagickExport ssize_t
FormatMagickTime(const time_t,const size_t,char *);
extern MagickExport TimerInfo
*AcquireTimerInfo(void),
*DestroyTimerInfo(TimerInfo *);
extern MagickExport void
GetTimerInfo(TimerInfo *),
ResetTimer(TimerInfo *),
StartTimer(TimerInfo *,const MagickBooleanType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/montage.h 0000644 00000003351 14751151177 0007615 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore montage methods.
*/
#ifndef MAGICKCORE_MONTAGE_H
#define MAGICKCORE_MONTAGE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedMode,
FrameMode,
UnframeMode,
ConcatenateMode
} MontageMode;
typedef struct _MontageInfo
{
char
*geometry,
*tile,
*title,
*frame,
*texture,
*font;
double
pointsize;
size_t
border_width;
MagickBooleanType
shadow;
PixelPacket
fill,
stroke,
background_color,
border_color,
matte_color;
GravityType
gravity;
char
filename[MaxTextExtent];
MagickBooleanType
debug;
size_t
signature;
} MontageInfo;
extern MagickExport Image
*MontageImages(const Image *,const MontageInfo *,ExceptionInfo *),
*MontageImageList(const ImageInfo *,const MontageInfo *,const Image *,
ExceptionInfo *);
extern MagickExport MontageInfo
*CloneMontageInfo(const ImageInfo *,const MontageInfo *),
*DestroyMontageInfo(MontageInfo *);
extern MagickExport void
GetMontageInfo(const ImageInfo *,MontageInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/fourier.h 0000644 00000002611 14751151177 0007634 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore discrete Fourier transform (DFT) methods.
*/
#ifndef MAGICKCORE_FFT_H
#define MAGICKCORE_FFT_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedComplexOperator,
AddComplexOperator,
ConjugateComplexOperator,
DivideComplexOperator,
MagnitudePhaseComplexOperator,
MultiplyComplexOperator,
RealImaginaryComplexOperator,
SubtractComplexOperator
} ComplexOperator;
extern MagickExport Image
*ComplexImages(const Image *,const ComplexOperator,ExceptionInfo *),
*ForwardFourierTransformImage(const Image *,const MagickBooleanType,
ExceptionInfo *),
*InverseFourierTransformImage(const Image *,const Image *,
const MagickBooleanType,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/paint.h 0000644 00000003355 14751151177 0007302 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image paint methods.
*/
#ifndef MAGICKCORE_PAINT_H
#define MAGICKCORE_PAINT_H
#include "magick/color.h"
#include "magick/draw.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport Image
*OilPaintImage(const Image *,const double,ExceptionInfo *);
extern MagickExport MagickBooleanType
FloodfillPaintImage(Image *,const ChannelType,const DrawInfo *,
const MagickPixelPacket *,const ssize_t,const ssize_t,
const MagickBooleanType),
GradientImage(Image *,const GradientType,const SpreadMethod,
const PixelPacket *,const PixelPacket *),
OpaquePaintImage(Image *,const MagickPixelPacket *,const MagickPixelPacket *,
const MagickBooleanType),
OpaquePaintImageChannel(Image *,const ChannelType,const MagickPixelPacket *,
const MagickPixelPacket *,const MagickBooleanType),
TransparentPaintImage(Image *,const MagickPixelPacket *,
const Quantum,const MagickBooleanType),
TransparentPaintImageChroma(Image *,const MagickPixelPacket *,
const MagickPixelPacket *,const Quantum,const MagickBooleanType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/magick-config.h 0000644 00000000303 14751151177 0010653 0 ustar 00 #include <bits/wordsize.h>
#if __WORDSIZE == 32
# include "magick-config-32.h"
#elif __WORDSIZE == 64
# include "magick-config-64.h"
#else
# error "unexpected value for __WORDSIZE macro"
#endif
magick/api.h 0000644 00000001703 14751151177 0006733 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Deprecated as of ImageMagick 6.2.3.
MagickCore Application Programming Interface declarations.
*/
#ifndef MAGICKCORE_API_DEPRECATED_H
#define MAGICKCORE_API_DEPRECATED_H
#include "magick/MagickCore.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/opencl.h 0000644 00000004725 14751151177 0007451 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore OpenCL public methods.
*/
#ifndef MAGICKCORE_OPENCL_H
#define MAGICKCORE_OPENCL_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/* OpenCL program modules */
typedef enum {
MAGICK_OPENCL_ACCELERATE = 0,
MAGICK_OPENCL_NUM_PROGRAMS /* !!! This has to be the last entry !!! */
} MagickOpenCLProgram;
typedef enum {
MAGICK_OPENCL_OFF = 0
, MAGICK_OPENCL_DEVICE_SELECT_AUTO = 1
, MAGICK_OPENCL_DEVICE_SELECT_USER = 2
, MAGICK_OPENCL_DEVICE_SELECT_AUTO_CLEAR_CACHE = 3
} ImageMagickOpenCLMode;
/* Parameter type accepted by SetMagickOpenCLEnvParm and GetMagickOpenCLEnvParm */
typedef enum {
MAGICK_OPENCL_ENV_PARAM_DEVICE /* cl_device_id (from OpenCL) */
, MAGICK_OPENCL_ENV_PARAM_OPENCL_DISABLED /* MagickBooleanType */
, MAGICK_OPENCL_ENV_PARAM_OPENCL_INITIALIZED /* MagickBooleanType */
, MAGICK_OPENCL_ENV_PARAM_PROGRAM_CACHE_DISABLED /* MagickBooleanType */
/* if true, disable the kernel binary cache */
, MAGICK_OPENCL_ENV_PARAM_REGENERATE_PROFILE /* MagickBooleanType */
/* if true, rerun microbenchmark in auto device selection */
, MAGICK_OPENCL_ENV_PARAM_PLATFORM_VENDOR /* char* */
, MAGICK_OPENCL_ENV_PARAM_DEVICE_NAME /* char* */
} MagickOpenCLEnvParam;
typedef struct _MagickCLEnv* MagickCLEnv;
extern MagickExport MagickBooleanType
GetMagickOpenCLEnvParam(MagickCLEnv,MagickOpenCLEnvParam,size_t,void*,
ExceptionInfo*),
InitImageMagickOpenCL(ImageMagickOpenCLMode,void*,void*,ExceptionInfo*),
InitOpenCLEnv(MagickCLEnv,ExceptionInfo*),
SetMagickOpenCLEnvParam(MagickCLEnv,MagickOpenCLEnvParam,size_t,void*,
ExceptionInfo*);
extern MagickExport MagickCLEnv
GetDefaultOpenCLEnv();
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/enhance.h 0000644 00000005662 14751151177 0007573 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image enhance methods.
*/
#ifndef MAGICKCORE_ENHANCE_H
#define MAGICKCORE_ENHANCE_H
#include "magick/pixel.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
AutoGammaImage(Image *),
AutoGammaImageChannel(Image *,const ChannelType),
AutoLevelImage(Image *),
AutoLevelImageChannel(Image *,const ChannelType),
BrightnessContrastImage(Image *,const double,const double),
BrightnessContrastImageChannel(Image *,const ChannelType,const double,
const double),
ClutImage(Image *,const Image *),
ClutImageChannel(Image *,const ChannelType,const Image *),
ColorDecisionListImage(Image *,const char *),
ContrastImage(Image *,const MagickBooleanType),
ContrastStretchImage(Image *,const char *),
ContrastStretchImageChannel(Image *,const ChannelType,const double,
const double),
EqualizeImage(Image *image),
EqualizeImageChannel(Image *image,const ChannelType),
GammaImage(Image *,const char *),
GammaImageChannel(Image *,const ChannelType,const double),
GrayscaleImage(Image *,const PixelIntensityMethod),
HaldClutImage(Image *,const Image *),
HaldClutImageChannel(Image *,const ChannelType,const Image *),
LevelImage(Image *,const char *),
LevelImageChannel(Image *,const ChannelType,const double,const double,
const double),
LevelizeImage(Image *,const double,const double,const double),
LevelizeImageChannel(Image *,const ChannelType,const double,const double,
const double),
LevelColorsImage(Image *,const MagickPixelPacket *,const MagickPixelPacket *,
const MagickBooleanType),
LevelColorsImageChannel(Image *,const ChannelType,const MagickPixelPacket *,
const MagickPixelPacket *,const MagickBooleanType),
LinearStretchImage(Image *,const double,const double),
ModulateImage(Image *,const char *),
NegateImage(Image *,const MagickBooleanType),
NegateImageChannel(Image *,const ChannelType,const MagickBooleanType),
NormalizeImage(Image *),
NormalizeImageChannel(Image *,const ChannelType),
SigmoidalContrastImage(Image *,const MagickBooleanType,const char *),
SigmoidalContrastImageChannel(Image *,const ChannelType,
const MagickBooleanType,const double,const double);
extern MagickExport Image
*EnhanceImage(const Image *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/feature.h 0000644 00000003322 14751151177 0007614 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore feature methods.
*/
#ifndef MAGICKCORE_FEATURE_H
#define MAGICKCORE_FEATURE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/*
Haralick texture features.
*/
typedef struct _ChannelFeatures
{
double
angular_second_moment[4],
contrast[4],
correlation[4],
variance_sum_of_squares[4],
inverse_difference_moment[4],
sum_average[4],
sum_variance[4],
sum_entropy[4],
entropy[4],
difference_variance[4],
difference_entropy[4],
measure_of_correlation_1[4],
measure_of_correlation_2[4],
maximum_correlation_coefficient[4];
} ChannelFeatures;
extern MagickExport ChannelFeatures
*GetImageChannelFeatures(const Image *,const size_t,ExceptionInfo *);
extern MagickExport Image
*CannyEdgeImage(const Image *,const double,const double,const double,
const double,ExceptionInfo *),
*HoughLineImage(const Image *,const size_t,const size_t,const size_t,
ExceptionInfo *),
*MeanShiftImage(const Image *,const size_t,const size_t,const double,
ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/artifact.h 0000644 00000002541 14751151177 0007760 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore artifact methods.
*/
#ifndef MAGICKCORE_ARTIFACT_H
#define MAGICKCORE_ARTIFACT_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport char
*GetNextImageArtifact(const Image *),
*RemoveImageArtifact(Image *,const char *);
extern MagickExport const char
*GetImageArtifact(const Image *,const char *);
extern MagickExport MagickBooleanType
CloneImageArtifacts(Image *,const Image *),
DefineImageArtifact(Image *,const char *),
DeleteImageArtifact(Image *,const char *),
SetImageArtifact(Image *,const char *,const char *);
extern MagickExport void
DestroyImageArtifacts(Image *),
ResetImageArtifactIterator(const Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/colormap.h 0000644 00000001775 14751151177 0010007 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image colormap methods.
*/
#ifndef MAGICKCORE_COLORMAP_H
#define MAGICKCORE_COLORMAP_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
AcquireImageColormap(Image *,const size_t),
CycleColormapImage(Image *,const ssize_t),
SortColormapByIntensity(Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/exception.h 0000644 00000010761 14751151177 0010164 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore exception methods.
*/
#ifndef MAGICKCORE_EXCEPTION_H
#define MAGICKCORE_EXCEPTION_H
#include <stdarg.h>
#include "magick/semaphore.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedException,
WarningException = 300,
ResourceLimitWarning = 300,
TypeWarning = 305,
OptionWarning = 310,
DelegateWarning = 315,
MissingDelegateWarning = 320,
CorruptImageWarning = 325,
FileOpenWarning = 330,
BlobWarning = 335,
StreamWarning = 340,
CacheWarning = 345,
CoderWarning = 350,
FilterWarning = 352,
ModuleWarning = 355,
DrawWarning = 360,
ImageWarning = 365,
WandWarning = 370,
RandomWarning = 375,
XServerWarning = 380,
MonitorWarning = 385,
RegistryWarning = 390,
ConfigureWarning = 395,
PolicyWarning = 399,
ErrorException = 400,
ResourceLimitError = 400,
TypeError = 405,
OptionError = 410,
DelegateError = 415,
MissingDelegateError = 420,
CorruptImageError = 425,
FileOpenError = 430,
BlobError = 435,
StreamError = 440,
CacheError = 445,
CoderError = 450,
FilterError = 452,
ModuleError = 455,
DrawError = 460,
ImageError = 465,
WandError = 470,
RandomError = 475,
XServerError = 480,
MonitorError = 485,
RegistryError = 490,
ConfigureError = 495,
PolicyError = 499,
FatalErrorException = 700,
ResourceLimitFatalError = 700,
TypeFatalError = 705,
OptionFatalError = 710,
DelegateFatalError = 715,
MissingDelegateFatalError = 720,
CorruptImageFatalError = 725,
FileOpenFatalError = 730,
BlobFatalError = 735,
StreamFatalError = 740,
CacheFatalError = 745,
CoderFatalError = 750,
FilterFatalError = 752,
ModuleFatalError = 755,
DrawFatalError = 760,
ImageFatalError = 765,
WandFatalError = 770,
RandomFatalError = 775,
XServerFatalError = 780,
MonitorFatalError = 785,
RegistryFatalError = 790,
ConfigureFatalError = 795,
PolicyFatalError = 799
} ExceptionType;
struct _ExceptionInfo
{
ExceptionType
severity;
int
error_number;
char
*reason,
*description;
void
*exceptions;
MagickBooleanType
relinquish;
SemaphoreInfo
*semaphore;
size_t
signature;
};
typedef void
(*ErrorHandler)(const ExceptionType,const char *,const char *);
typedef void
(*FatalErrorHandler)(const ExceptionType,const char *,const char *)
magick_attribute((__noreturn__));
typedef void
(*WarningHandler)(const ExceptionType,const char *,const char *);
extern MagickExport char
*GetExceptionMessage(const int);
extern MagickExport const char
*GetLocaleExceptionMessage(const ExceptionType,const char *);
extern MagickExport ErrorHandler
SetErrorHandler(ErrorHandler);
extern MagickExport ExceptionInfo
*AcquireExceptionInfo(void),
*CloneExceptionInfo(ExceptionInfo *),
*DestroyExceptionInfo(ExceptionInfo *);
extern MagickExport FatalErrorHandler
SetFatalErrorHandler(FatalErrorHandler);
extern MagickExport MagickBooleanType
ThrowException(ExceptionInfo *,const ExceptionType,const char *,
const char *),
ThrowMagickException(ExceptionInfo *,const char *,const char *,const size_t,
const ExceptionType,const char *,const char *,...)
magick_attribute((__format__ (__printf__,7,8))),
ThrowMagickExceptionList(ExceptionInfo *,const char *,const char *,
const size_t,const ExceptionType,const char *,const char *,va_list)
magick_attribute((__format__ (__printf__,7,0)));
extern MagickExport void
CatchException(ExceptionInfo *),
ClearMagickException(ExceptionInfo *),
InheritException(ExceptionInfo *,const ExceptionInfo *),
MagickError(const ExceptionType,const char *,const char *),
MagickFatalError(const ExceptionType,const char *,const char *)
magick_attribute((__noreturn__)),
MagickWarning(const ExceptionType,const char *,const char *);
extern MagickExport WarningHandler
SetWarningHandler(WarningHandler);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/magick-config-64.h 0000644 00000015104 14751151177 0011107 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickConfig not autogenerated (fixed stuff)
*/
#ifndef MAGICKCORE_MAGICK_CONFIG_H
#define MAGICKCORE_MAGICK_CONFIG_H
#include "magick/magick-baseconfig.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/* Compatibility block */
#if !defined(MAGICKCORE_QUANTUM_DEPTH) && defined(MAGICKCORE_QUANTUM_DEPTH_OBSOLETE_IN_H)
# warning "you should set MAGICKCORE_QUANTUM_DEPTH to sensible default set it to configure time default"
# warning "this is an obsolete behavior please fix your makefile"
# define MAGICKCORE_QUANTUM_DEPTH MAGICKCORE_QUANTUM_DEPTH_OBSOLETE_IN_H
#endif
/* Number of bits in a pixel Quantum (8/16/32/64) */
#ifndef MAGICKCORE_QUANTUM_DEPTH
# error "you should set MAGICKCORE_QUANTUM_DEPTH"
#endif
/* check values */
#if MAGICKCORE_QUANTUM_DEPTH != 8
# if MAGICKCORE_QUANTUM_DEPTH != 16
# if MAGICKCORE_QUANTUM_DEPTH != 32
# if MAGICKCORE_QUANTUM_DEPTH != 64
# error "MAGICKCORE_QUANTUM_DEPTH is not 8/16/32/64 bits"
# endif
# endif
# endif
#endif
#if !defined(MAGICKCORE_HDRI_ENABLE) && defined(MAGICKCORE_HDRI_ENABLE_OBSOLETE_IN_H)
# warning "you should set MAGICKCORE_HDRI_ENABLE to sensible default set it to configure time default"
# warning "this is an obsolete behavior please fix yours makefile"
# define MAGICKCORE_HDRI_ENABLE MAGICKCORE_HDRI_ENABLE_OBSOLETE_IN_H
#endif
/* whether HDRI is enable */
#if !defined(MAGICKCORE_HDRI_ENABLE)
# error "you should set MAGICKCORE_HDRI_ENABLE"
#endif
#if MAGICKCORE_HDRI_ENABLE
# define MAGICKCORE_HDRI_SUPPORT 1
#endif
#if defined __CYGWIN32__ && !defined __CYGWIN__
/* For backwards compatibility with Cygwin b19 and
earlier, we define __CYGWIN__ here, so that
we can rely on checking just for that macro. */
# define __CYGWIN__ __CYGWIN32__
#endif
/*! stringify */
#define MAGICKCORE_STRING_QUOTE(str) #str
#define MAGICKCORE_STRING_XQUOTE(str) MAGICKCORE_STRING_QUOTE(str)
/* ABI SUFFIX */
#ifndef MAGICKCORE_HDRI_SUPPORT
#define MAGICKCORE_ABI_SUFFIX "Q" MAGICKCORE_STRING_XQUOTE(MAGICKCORE_QUANTUM_DEPTH)
#else
#define MAGICKCORE_ABI_SUFFIX "Q" MAGICKCORE_STRING_XQUOTE(MAGICKCORE_QUANTUM_DEPTH) "HDRI"
#endif
/* some path game */
#if !defined __CYGWIN__
# if defined (_WIN32) || defined (_WIN64) || defined (__MSDOS__) || defined (__DJGPP__) || defined (__OS2__)
/* Use Windows separators on all _WIN32 defining
environments, except Cygwin. */
# define MAGICKCORE_DIR_SEPARATOR_CHAR '\\'
# define MAGICKCORE_DIR_SEPARATOR "\\"
# define MAGICKCORE_PATH_SEPARATOR_CHAR ';'
# define MAGICKCORE_PATH_SEPARATOR ";"
# endif
#endif
/* posix */
#ifndef MAGICKCORE_DIR_SEPARATOR_CHAR
/* Assume that not having this is an indicator that all
are missing. */
# define MAGICKCORE_DIR_SEPARATOR_CHAR '/'
# define MAGICKCORE_DIR_SEPARATOR "/"
# define MAGICKCORE_PATH_SEPARATOR_CHAR ':'
# define MAGICKCORE_PATH_SEPARATOR ":"
#endif /* !DIR_SEPARATOR_CHAR */
# if defined(MAGICKCORE_POSIX_SUPPORT) || defined(__MINGW32__)
/* module dir */
#ifndef MAGICKCORE_MODULES_DIRNAME
# define MAGICKCORE_MODULES_DIRNAME MAGICKCORE_MODULES_BASEDIRNAME "-" MAGICKCORE_ABI_SUFFIX
#endif
#ifndef MAGICKCORE_MODULES_PATH
# define MAGICKCORE_MODULES_PATH MAGICKCORE_LIBRARY_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
/* for Clang compatibility */
#ifndef __has_builtin
# define __has_builtin(x) 0
#endif
#if defined(__GNUC__) && !defined(__clang__)
# define MAGICKCORE_DIAGNOSTIC_PUSH() \
_Pragma("GCC diagnostic push")
# define MAGICKCORE_DIAGNOSTIC_IGNORE_MAYBE_UNINITIALIZED() \
_Pragma("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
# define MAGICKCORE_DIAGNOSTIC_POP() \
_Pragma("GCC diagnostic pop")
#else
# define MAGICKCORE_DIAGNOSTIC_PUSH()
# define MAGICKCORE_DIAGNOSTIC_IGNORE_MAYBE_UNINITIALIZED()
# define MAGICKCORE_DIAGNOSTIC_POP()
#endif
#define MAGICKCORE_BITS_BELOW(power_of_2) \
((power_of_2)-1)
#define MAGICKCORE_MAX_ALIGNMENT_PADDING(power_of_2) \
MAGICKCORE_BITS_BELOW(power_of_2)
#define MAGICKCORE_IS_NOT_ALIGNED(n, power_of_2) \
((n) & MAGICKCORE_BITS_BELOW(power_of_2))
#define MAGICKCORE_IS_NOT_POWER_OF_2(n) \
MAGICKCORE_IS_NOT_ALIGNED((n), (n))
#define MAGICKCORE_ALIGN_DOWN(n, power_of_2) \
((n) & ~MAGICKCORE_BITS_BELOW(power_of_2))
#define MAGICKCORE_ALIGN_UP(n, power_of_2) \
MAGICKCORE_ALIGN_DOWN((n) + MAGICKCORE_MAX_ALIGNMENT_PADDING(power_of_2),power_of_2)
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/utility.h 0000644 00000003642 14751151177 0007671 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore utility methods.
*/
#ifndef MAGICKCORE_UTILITY_H
#define MAGICKCORE_UTILITY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedPath,
MagickPath,
RootPath,
HeadPath,
TailPath,
BasePath,
ExtensionPath,
SubimagePath,
CanonicalPath,
SubcanonicalPath,
BasePathSansCompressExtension
} PathType;
extern MagickExport char
*Base64Encode(const unsigned char *,const size_t,size_t *),
**GetPathComponents(const char *,size_t *),
**ListFiles(const char *,const char *,size_t *);
extern MagickExport MagickBooleanType
AcquireUniqueFilename(char *),
AcquireUniqueSymbolicLink(const char *,char *),
ExpandFilenames(int *,char ***),
GetPathAttributes(const char *,void *),
GetExecutionPath(char *,const size_t),
IsPathAccessible(const char *);
extern MagickExport size_t
MultilineCensus(const char *) magick_attribute((__pure__));
extern MagickExport ssize_t
GetMagickPageSize(void);
extern MagickExport unsigned char
*Base64Decode(const char *, size_t *);
extern MagickExport void
AppendImageFormat(const char *,char *),
ChopPathComponents(char *,const size_t),
ExpandFilename(char *),
GetPathComponent(const char *,PathType,char *),
MagickDelay(const MagickSizeType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/random_.h 0000644 00000003203 14751151177 0007576 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore random methods.
*/
#ifndef MAGICKCORE_RANDOM__H
#define MAGICKCORE_RANDOM__H
#include "magick/string_.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/*
Typedef declarations.
*/
typedef struct _RandomInfo
RandomInfo;
/*
Method declarations.
*/
extern MagickExport double
GetRandomValue(RandomInfo *),
GetPseudoRandomValue(RandomInfo *magick_restrict);
extern MagickExport MagickBooleanType
RandomComponentGenesis(void);
extern MagickExport RandomInfo
*AcquireRandomInfo(void),
*DestroyRandomInfo(RandomInfo *);
extern MagickExport StringInfo
*GetRandomKey(RandomInfo *,const size_t);
extern MagickExport unsigned long
GetRandomSecretKey(const RandomInfo *);
extern MagickExport void
RandomComponentTerminus(void),
SeedPseudoRandomGenerator(const unsigned long),
SetRandomKey(RandomInfo *,const size_t,unsigned char *),
SetRandomSecretKey(const unsigned long),
SetRandomTrueRandom(const MagickBooleanType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/color.h 0000644 00000005715 14751151177 0007307 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image color methods.
*/
#ifndef MAGICKCORE_COLOR_H
#define MAGICKCORE_COLOR_H
#include "magick/pixel.h"
#include "magick/exception.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedCompliance,
NoCompliance = 0x0000,
CSSCompliance = 0x0001,
SVGCompliance = 0x0001,
X11Compliance = 0x0002,
XPMCompliance = 0x0004,
MVGCompliance = 0x0008,
AllCompliance = 0x7fffffff
} ComplianceType;
typedef struct _ColorInfo
{
char
*path,
*name;
ComplianceType
compliance;
MagickPixelPacket
color;
MagickBooleanType
exempt,
stealth;
struct _ColorInfo
*previous,
*next; /* deprecated, use GetColorInfoList() */
size_t
signature;
} ColorInfo;
typedef struct _ErrorInfo
{
double
mean_error_per_pixel,
normalized_mean_error,
normalized_maximum_error;
} ErrorInfo;
extern MagickExport char
**GetColorList(const char *,size_t *,ExceptionInfo *);
extern MagickExport const ColorInfo
*GetColorInfo(const char *,ExceptionInfo *),
**GetColorInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport MagickBooleanType
ColorComponentGenesis(void),
IsColorSimilar(const Image *,const PixelPacket *,const PixelPacket *),
IsImageSimilar(const Image *,const Image *,ssize_t *x,ssize_t *y,
ExceptionInfo *),
IsMagickColorSimilar(const MagickPixelPacket *,const MagickPixelPacket *),
IsOpacitySimilar(const Image *,const PixelPacket *,const PixelPacket *),
ListColorInfo(FILE *,ExceptionInfo *),
QueryColorCompliance(const char *,const ComplianceType,PixelPacket *,
ExceptionInfo *),
QueryColorDatabase(const char *,PixelPacket *,ExceptionInfo *),
QueryColorname(const Image *,const PixelPacket *,const ComplianceType,char *,
ExceptionInfo *),
QueryMagickColorCompliance(const char *,const ComplianceType,
MagickPixelPacket *,ExceptionInfo *),
QueryMagickColor(const char *,MagickPixelPacket *,ExceptionInfo *),
QueryMagickColorname(const Image *,const MagickPixelPacket *,
const ComplianceType,char *,ExceptionInfo *);
extern MagickExport void
ColorComponentTerminus(void),
ConcatenateColorComponent(const MagickPixelPacket *,const ChannelType,
const ComplianceType,char *),
GetColorTuple(const MagickPixelPacket *,const MagickBooleanType,char *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/semaphore.h 0000644 00000002503 14751151177 0010144 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore methods to lock and unlock semaphores.
*/
#ifndef MAGICKCORE_SEMAPHORE_H
#define MAGICKCORE_SEMAPHORE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct SemaphoreInfo
SemaphoreInfo;
extern MagickExport void
SemaphoreComponentTerminus(void);
extern MagickExport MagickBooleanType
SemaphoreComponentGenesis(void);
extern MagickExport SemaphoreInfo
*AllocateSemaphoreInfo(void);
extern MagickExport void
ActivateSemaphoreInfo(SemaphoreInfo **),
DestroySemaphoreInfo(SemaphoreInfo **),
LockSemaphoreInfo(SemaphoreInfo *),
SemaphoreComponentTerminus(void),
UnlockSemaphoreInfo(SemaphoreInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/string_.h 0000644 00000007205 14751151177 0007632 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore string methods.
*/
#ifndef MAGICKCORE_STRING_H_
#define MAGICKCORE_STRING_H_
#include <stdarg.h>
#include <time.h>
#include "magick/exception.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _StringInfo
{
char
path[MaxTextExtent];
unsigned char
*datum;
size_t
length,
signature;
char
*name;
} StringInfo;
extern MagickExport char
*AcquireString(const char *),
*CloneString(char **,const char *),
*ConstantString(const char *),
*DestroyString(char *),
**DestroyStringList(char **),
*EscapeString(const char *,const char),
*FileToString(const char *,const size_t,ExceptionInfo *),
*GetEnvironmentValue(const char *),
*SanitizeString(const char *),
*StringInfoToHexString(const StringInfo *),
*StringInfoToString(const StringInfo *),
**StringToArgv(const char *,int *),
*StringToken(const char *,char **),
**StringToList(const char *),
**StringToStrings(const char *,size_t *);
extern MagickExport const char
*GetStringInfoName(const StringInfo *),
*GetStringInfoPath(const StringInfo *);
extern MagickExport double
InterpretSiPrefixValue(const char *magick_restrict,char **magick_restrict),
*StringToArrayOfDoubles(const char *,ssize_t *, ExceptionInfo *);
extern MagickExport int
CompareStringInfo(const StringInfo *,const StringInfo *);
extern MagickExport MagickBooleanType
ConcatenateString(char **magick_restrict,const char *magick_restrict),
IsStringTrue(const char *) magick_attribute((__pure__)),
IsStringNotFalse(const char *) magick_attribute((__pure__)),
SubstituteString(char **,const char *,const char *);
extern MagickExport size_t
ConcatenateMagickString(char *magick_restrict,const char *magick_restrict,
const size_t) magick_attribute((__nonnull__)),
CopyMagickString(char *magick_restrict,const char *magick_restrict,
const size_t) magick_attribute((__nonnull__)),
GetStringInfoLength(const StringInfo *);
extern MagickExport ssize_t
FormatMagickSize(const MagickSizeType,const MagickBooleanType,char *);
extern MagickExport StringInfo
*AcquireStringInfo(const size_t),
*BlobToStringInfo(const void *,const size_t),
*CloneStringInfo(const StringInfo *),
*ConfigureFileToStringInfo(const char *),
*DestroyStringInfo(StringInfo *),
*FileToStringInfo(const char *,const size_t,ExceptionInfo *),
*SplitStringInfo(StringInfo *,const size_t),
*StringToStringInfo(const char *);
extern MagickExport unsigned char
*GetStringInfoDatum(const StringInfo *);
extern MagickExport void
ConcatenateStringInfo(StringInfo *,const StringInfo *)
magick_attribute((__nonnull__)),
PrintStringInfo(FILE *file,const char *,const StringInfo *),
ResetStringInfo(StringInfo *),
SetStringInfo(StringInfo *,const StringInfo *),
SetStringInfoDatum(StringInfo *,const unsigned char *),
SetStringInfoLength(StringInfo *,const size_t),
SetStringInfoName(StringInfo *,const char *),
SetStringInfoPath(StringInfo *,const char *),
StripString(char *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/constitute.h 0000644 00000003036 14751151177 0010364 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image constitute methods.
*/
#ifndef MAGICKCORE_CONSTITUTE_H
#define MAGICKCORE_CONSTITUTE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedPixel,
CharPixel,
DoublePixel,
FloatPixel,
IntegerPixel,
LongPixel,
QuantumPixel,
ShortPixel
} StorageType;
extern MagickExport Image
*ConstituteImage(const size_t,const size_t,const char *,const StorageType,
const void *,ExceptionInfo *),
*PingImage(const ImageInfo *,ExceptionInfo *),
*PingImages(const ImageInfo *,ExceptionInfo *),
*ReadImage(const ImageInfo *,ExceptionInfo *),
*ReadImages(const ImageInfo *,ExceptionInfo *),
*ReadInlineImage(const ImageInfo *,const char *,ExceptionInfo *);
extern MagickExport MagickBooleanType
WriteImage(const ImageInfo *,Image *),
WriteImages(const ImageInfo *,Image *,const char *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/segment.h 0000644 00000002116 14751151177 0007623 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image segment methods.
*/
#ifndef MAGICKCORE_SEGMENT_H
#define MAGICKCORE_SEGMENT_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
GetImageDynamicThreshold(const Image *,const double,const double,
MagickPixelPacket *,ExceptionInfo *),
SegmentImage(Image *,const ColorspaceType,const MagickBooleanType,
const double,const double);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/magick-type.h 0000644 00000015631 14751151177 0010401 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore types.
*/
#ifndef MAGICKCORE_MAGICK_TYPE_H
#define MAGICKCORE_MAGICK_TYPE_H
#include "magick/magick-config.h"
#if defined(MAGICKCORE_HAVE_UINTPTR_T)
# include <stdint.h>
#endif
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if !defined(MAGICKCORE_QUANTUM_DEPTH)
#define MAGICKCORE_QUANTUM_DEPTH 16
#endif
#if !defined(MagickPathExtent)
#define MagickPathExtent MaxTextExtent
#endif
#if defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(__MINGW32__)
# define MagickLLConstant(c) ((MagickOffsetType) (c ## i64))
# define MagickULLConstant(c) ((MagickSizeType) (c ## ui64))
#else
# define MagickLLConstant(c) ((MagickOffsetType) (c ## LL))
# define MagickULLConstant(c) ((MagickSizeType) (c ## ULL))
#endif
#if MAGICKCORE_SIZEOF_FLOAT_T == 0
typedef float MagickFloatType;
#elif (MAGICKCORE_SIZEOF_FLOAT_T == MAGICKCORE_SIZEOF_FLOAT)
typedef float MagickFloatType;
#elif (MAGICKCORE_SIZEOF_FLOAT_T == MAGICKCORE_SIZEOF_DOUBLE)
typedef double MagickFloatType;
#elif (MAGICKCORE_SIZEOF_FLOAT_T == MAGICKCORE_SIZEOF_LONG_DOUBLE)
typedef double MagickFloatType;
#else
#error Your MagickFloatType type is neither a float, nor a double, nor a long double
#endif
#if MAGICKCORE_SIZEOF_DOUBLE_T == 0
typedef double MagickDoubleType;
#elif (MAGICKCORE_SIZEOF_DOUBLE_T == MAGICKCORE_SIZEOF_DOUBLE)
typedef double MagickDoubleType;
#elif (MAGICKCORE_SIZEOF_DOUBLE_T == MAGICKCORE_SIZEOF_LONG_DOUBLE)
typedef long double MagickDoubleType;
#else
#error Your MagickDoubleType type is neither a float, nor a double, nor a long double
#endif
#if (MAGICKCORE_QUANTUM_DEPTH == 8)
#define MaxColormapSize 256UL
#define MaxMap 255UL
typedef ssize_t SignedQuantum;
#if defined(MAGICKCORE_HDRI_SUPPORT)
typedef MagickFloatType Quantum;
#define QuantumRange ((Quantum) 255.0)
#define QuantumFormat "%g"
#else
typedef unsigned char Quantum;
#define QuantumRange ((Quantum) 255)
#define QuantumFormat "%u"
#endif
#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
#define MaxColormapSize 65536UL
#define MaxMap 65535UL
typedef ssize_t SignedQuantum;
#if defined(MAGICKCORE_HDRI_SUPPORT)
typedef MagickFloatType Quantum;
#define QuantumRange ((Quantum) 65535.0)
#define QuantumFormat "%g"
#else
typedef unsigned short Quantum;
#define QuantumRange ((Quantum) 65535)
#define QuantumFormat "%u"
#endif
#elif (MAGICKCORE_QUANTUM_DEPTH == 32)
#define MaxColormapSize 65536UL
#define MaxMap 65535UL
typedef MagickDoubleType SignedQuantum;
#if defined(MAGICKCORE_HDRI_SUPPORT)
typedef MagickDoubleType Quantum;
#define QuantumRange ((Quantum) 4294967295.0)
#define QuantumFormat "%g"
#else
typedef unsigned int Quantum;
#define QuantumRange ((Quantum) 4294967295)
#define QuantumFormat "%u"
#endif
#elif (MAGICKCORE_QUANTUM_DEPTH == 64)
#define MAGICKCORE_HDRI_SUPPORT 1
#define MaxColormapSize 65536UL
#define MaxMap 65535UL
typedef MagickDoubleType SignedQuantum;
typedef MagickDoubleType Quantum;
#define QuantumRange ((Quantum) 18446744073709551615.0)
#define QuantumFormat "%g"
#else
#if !defined(_CH_)
# error "MAGICKCORE_QUANTUM_DEPTH must be one of 8, 16, 32, or 64"
#endif
#endif
#define MagickEpsilon (1.0e-12)
#define MagickMaximumValue 1.79769313486231570E+308
#define MagickMinimumValue 2.22507385850720140E-308
#define MagickStringify(macro_or_string) MagickStringifyArg(macro_or_string)
#define MagickStringifyArg(contents) #contents
#define QuantumScale ((double) 1.0/(double) QuantumRange)
/*
Typedef declarations.
*/
typedef MagickDoubleType MagickRealType;
typedef unsigned int MagickStatusType;
#if !defined(MAGICKCORE_WINDOWS_SUPPORT)
#if (MAGICKCORE_SIZEOF_UNSIGNED_LONG_LONG == 8)
typedef long long MagickOffsetType;
typedef unsigned long long MagickSizeType;
#define MagickOffsetFormat "lld"
#define MagickSizeFormat "llu"
#else
typedef ssize_t MagickOffsetType;
typedef size_t MagickSizeType;
#define MagickOffsetFormat "ld"
#define MagickSizeFormat "lu"
#endif
#else
typedef __int64 MagickOffsetType;
typedef unsigned __int64 MagickSizeType;
#define MagickOffsetFormat "I64i"
#define MagickSizeFormat "I64u"
#endif
#if defined(MAGICKCORE_HAVE_UINTPTR_T) || defined(uintptr_t)
typedef uintptr_t MagickAddressType;
#else
/* Hope for the best, I guess. */
typedef size_t MagickAddressType;
#endif
#if defined(_MSC_VER) && (_MSC_VER == 1200)
typedef MagickOffsetType QuantumAny;
#else
typedef MagickSizeType QuantumAny;
#endif
#if defined(macintosh)
#define ExceptionInfo MagickExceptionInfo
#endif
typedef enum
{
UndefinedChannel,
RedChannel = 0x0001,
GrayChannel = 0x0001,
CyanChannel = 0x0001,
GreenChannel = 0x0002,
MagentaChannel = 0x0002,
BlueChannel = 0x0004,
YellowChannel = 0x0004,
AlphaChannel = 0x0008,
OpacityChannel = 0x0008,
MatteChannel = 0x0008, /* deprecated */
BlackChannel = 0x0020,
IndexChannel = 0x0020,
CompositeChannels = 0x002F,
AllChannels = 0x7ffffff,
/*
Special purpose channel types.
*/
TrueAlphaChannel = 0x0040, /* extract actual alpha channel from opacity */
RGBChannels = 0x0080, /* set alpha from grayscale mask in RGB */
GrayChannels = 0x0080,
SyncChannels = 0x0100, /* channels should be modified equally */
DefaultChannels = ((AllChannels | SyncChannels) &~ OpacityChannel)
} ChannelType;
typedef enum
{
UndefinedClass,
DirectClass,
PseudoClass
} ClassType;
typedef enum
{
MagickFalse = 0,
MagickTrue = 1
} MagickBooleanType;
/*
The IsNaN test is for special floating point numbers of value Nan (not a
number). NaN's are defined as part of the IEEE standard for floating point
number representation, and need to be watched out for. Morphology Kernels
often use these special numbers as neighbourhood masks.
The special property that two NaN's are never equal, even if they are from
the same variable allows you to test if a value is special NaN value.
The macros are thus is only true if the value given is NaN.
*/
#if defined(MAGICKCORE_HAVE_ISNAN) && !defined(__cplusplus) && !defined(c_plusplus)
# define IsNaN(a) isnan(a)
#elif defined(_MSC_VER) && (_MSC_VER >= 1310)
# include <float.h>
# define IsNaN(a) _isnan(a)
#else
# define IsNaN(a) ((a) != (a))
#endif
#if !defined(INFINITY)
# define INFINITY ((double) -logf(0f))
#endif
typedef struct _BlobInfo BlobInfo;
typedef struct _ExceptionInfo ExceptionInfo;
typedef struct _Image Image;
typedef struct _ImageInfo ImageInfo;
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/magick-baseconfig.h 0000644 00000000313 14751151177 0011507 0 ustar 00 #include <bits/wordsize.h>
#if __WORDSIZE == 32
# include "magick-baseconfig-32.h"
#elif __WORDSIZE == 64
# include "magick-baseconfig-64.h"
#else
# error "unexpected value for __WORDSIZE macro"
#endif
magick/mime.h 0000644 00000002643 14751151177 0007115 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
The ImageMagick mime methods.
*/
#ifndef MAGICKCORE_MIME_H
#define MAGICKCORE_MIME_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _MimeInfo
MimeInfo;
extern MagickExport char
**GetMimeList(const char *,size_t *,ExceptionInfo *),
*MagickToMime(const char *);
extern MagickExport const char
*GetMimeDescription(const MimeInfo *),
*GetMimeType(const MimeInfo *);
extern MagickExport MagickBooleanType
ListMimeInfo(FILE *,ExceptionInfo *),
MimeComponentGenesis(void);
extern MagickExport const MimeInfo
*GetMimeInfo(const char *,const unsigned char *,const size_t,ExceptionInfo *),
**GetMimeInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport void
MimeComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/policy.h 0000644 00000003562 14751151177 0007466 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore security policy methods.
*/
#ifndef MAGICKCORE_POLICY_H
#define MAGICKCORE_POLICY_H
#include "magick/pixel.h"
#include "magick/exception.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedPolicyDomain,
CoderPolicyDomain,
DelegatePolicyDomain,
FilterPolicyDomain,
PathPolicyDomain,
ResourcePolicyDomain,
SystemPolicyDomain,
CachePolicyDomain,
ModulePolicyDomain
} PolicyDomain;
typedef enum
{
UndefinedPolicyRights = 0x00,
NoPolicyRights = 0x00,
ReadPolicyRights = 0x01,
WritePolicyRights = 0x02,
ExecutePolicyRights = 0x04,
AllPolicyRights = 0xff
} PolicyRights;
typedef struct _PolicyInfo
PolicyInfo;
extern MagickExport char
*GetPolicyValue(const char *name),
**GetPolicyList(const char *,size_t *,ExceptionInfo *);
extern MagickExport const PolicyInfo
**GetPolicyInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport MagickBooleanType
IsRightsAuthorized(const PolicyDomain,const PolicyRights,const char *),
ListPolicyInfo(FILE *,ExceptionInfo *),
PolicyComponentGenesis(void),
SetMagickSecurityPolicy(const char *,ExceptionInfo *);
extern MagickExport void
PolicyComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/prepress.h 0000644 00000001626 14751151177 0010031 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore prepress methods.
*/
#ifndef MAGICKCORE_PREPRESS_H
#define MAGICKCORE_PREPRESS_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport double
GetImageTotalInkDensity(Image *image);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/resample.h 0000644 00000005142 14751151177 0007773 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore graphic resample methods.
*/
#ifndef MAGICKCORE_RESAMPLE_H
#define MAGICKCORE_RESAMPLE_H
#include "magick/cache-view.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/*
WARNING: The order of this table must also match the order of a table
located in AcquireResizeFilter() in "resize.c" otherwise the users filter
will not match the actual filter that is setup.
*/
typedef enum
{
UndefinedFilter,
PointFilter,
BoxFilter,
TriangleFilter,
HermiteFilter,
HanningFilter,
HammingFilter,
BlackmanFilter,
GaussianFilter,
QuadraticFilter,
CubicFilter,
CatromFilter,
MitchellFilter,
JincFilter,
SincFilter,
SincFastFilter,
KaiserFilter,
WelshFilter,
ParzenFilter,
BohmanFilter,
BartlettFilter,
LagrangeFilter,
LanczosFilter,
LanczosSharpFilter,
Lanczos2Filter,
Lanczos2SharpFilter,
RobidouxFilter,
RobidouxSharpFilter,
CosineFilter,
SplineFilter,
LanczosRadiusFilter,
SentinelFilter /* a count of all the filters, not a real filter */
} FilterTypes;
/*
Backward compatibility for the more correctly named Jinc Filter. Original
source of this filter is from "zoom" but it refers to a reference by Pratt,
who does not actualy name the filter.
*/
#define BesselFilter JincFilter
typedef struct _ResampleFilter
ResampleFilter;
extern MagickExport MagickBooleanType
ResamplePixelColor(ResampleFilter *,const double,const double,
MagickPixelPacket *),
SetResampleFilterInterpolateMethod(ResampleFilter *,
const InterpolatePixelMethod),
SetResampleFilterVirtualPixelMethod(ResampleFilter *,
const VirtualPixelMethod);
extern MagickExport ResampleFilter
*AcquireResampleFilter(const Image *,ExceptionInfo *),
*DestroyResampleFilter(ResampleFilter *);
extern MagickExport void
ScaleResampleFilter(ResampleFilter *,const double,const double,const double,
const double),
SetResampleFilter(ResampleFilter *,const FilterTypes,const double);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/image.h 0000644 00000025766 14751151177 0007263 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image methods.
*/
#ifndef MAGICKCORE_IMAGE_H
#define MAGICKCORE_IMAGE_H
#include "magick/color.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#define OpaqueOpacity ((Quantum) 0UL)
#define TransparentOpacity (QuantumRange)
typedef enum
{
UndefinedType,
BilevelType,
GrayscaleType,
GrayscaleMatteType,
PaletteType,
PaletteMatteType,
TrueColorType,
TrueColorMatteType,
ColorSeparationType,
ColorSeparationMatteType,
OptimizeType,
PaletteBilevelMatteType
} ImageType;
typedef enum
{
UndefinedInterlace,
NoInterlace,
LineInterlace,
PlaneInterlace,
PartitionInterlace,
GIFInterlace,
JPEGInterlace,
PNGInterlace
} InterlaceType;
typedef enum
{
UndefinedOrientation,
TopLeftOrientation,
TopRightOrientation,
BottomRightOrientation,
BottomLeftOrientation,
LeftTopOrientation,
RightTopOrientation,
RightBottomOrientation,
LeftBottomOrientation
} OrientationType;
typedef enum
{
UndefinedResolution,
PixelsPerInchResolution,
PixelsPerCentimeterResolution
} ResolutionType;
typedef struct _PrimaryInfo
{
double
x,
y,
z;
} PrimaryInfo;
typedef struct _SegmentInfo
{
double
x1,
y1,
x2,
y2;
} SegmentInfo;
typedef enum
{
UndefinedTransmitType,
FileTransmitType,
BlobTransmitType,
StreamTransmitType,
ImageTransmitType
} TransmitType;
typedef struct _ChromaticityInfo
{
PrimaryInfo
red_primary,
green_primary,
blue_primary,
white_point;
} ChromaticityInfo;
#include "magick/blob.h"
#include "magick/colorspace.h"
#include "magick/cache-view.h"
#include "magick/color.h"
#include "magick/composite.h"
#include "magick/compress.h"
#include "magick/effect.h"
#include "magick/geometry.h"
#include "magick/layer.h"
#include "magick/locale_.h"
#include "magick/monitor.h"
#include "magick/pixel.h"
#include "magick/profile.h"
#include "magick/quantum.h"
#include "magick/resample.h"
#include "magick/resize.h"
#include "magick/semaphore.h"
#include "magick/stream.h"
#include "magick/timer.h"
struct _Image
{
ClassType
storage_class;
ColorspaceType
colorspace; /* colorspace of image data */
CompressionType
compression; /* compression of image when read/write */
size_t
quality; /* compression quality setting, meaning varies */
OrientationType
orientation; /* photo orientation of image */
MagickBooleanType
taint, /* has image been modified since reading */
matte; /* is transparency channel defined and active */
size_t
columns, /* physical size of image */
rows,
depth, /* depth of image on read/write */
colors; /* size of color table on read */
PixelPacket
*colormap,
background_color, /* current background color attribute */
border_color, /* current bordercolor attribute */
matte_color; /* current mattecolor attribute */
double
gamma;
ChromaticityInfo
chromaticity;
RenderingIntent
rendering_intent;
void
*profiles;
ResolutionType
units; /* resolution/density ppi or ppc */
char
*montage,
*directory,
*geometry;
ssize_t
offset;
double
x_resolution, /* image resolution/density */
y_resolution;
RectangleInfo
page, /* virtual canvas size and offset of image */
extract_info,
tile_info; /* deprecated */
double
bias,
blur, /* deprecated */
fuzz; /* current color fuzz attribute */
FilterTypes
filter; /* resize/distort filter to apply */
InterlaceType
interlace;
EndianType
endian; /* raw data integer ordering on read/write */
GravityType
gravity; /* Gravity attribute for positioning in image */
CompositeOperator
compose; /* alpha composition method for layered images */
DisposeType
dispose; /* GIF animation disposal method */
struct _Image
*clip_mask;
size_t
scene, /* index of image in multi-image file */
delay; /* Animation delay time */
ssize_t
ticks_per_second; /* units for delay time, default 100 for GIF */
size_t
iterations,
total_colors;
ssize_t
start_loop;
ErrorInfo
error;
TimerInfo
timer;
MagickProgressMonitor
progress_monitor;
void
*client_data,
*cache,
*attributes; /* deprecated */
Ascii85Info
*ascii85;
BlobInfo
*blob;
char
filename[MaxTextExtent], /* images input filename */
magick_filename[MaxTextExtent], /* ditto with coders, and read_mods */
magick[MaxTextExtent]; /* Coder used to decode image */
size_t
magick_columns,
magick_rows;
ExceptionInfo
exception; /* Error handling report */
MagickBooleanType
debug; /* debug output attribute */
ssize_t
reference_count;
SemaphoreInfo
*semaphore;
ProfileInfo
color_profile,
iptc_profile,
*generic_profile;
size_t
generic_profiles; /* this & ProfileInfo is deprecated */
size_t
signature;
struct _Image
*previous, /* Image list links */
*list, /* Undo/Redo image processing list (for display) */
*next; /* Image list links */
InterpolatePixelMethod
interpolate; /* Interpolation of color for between pixel lookups */
MagickBooleanType
black_point_compensation;
PixelPacket
transparent_color; /* color for 'transparent' color index in GIF */
struct _Image
*mask;
RectangleInfo
tile_offset;
void
*properties, /* per image properities */
*artifacts; /* per image sequence image artifacts */
ImageType
type;
MagickBooleanType
dither; /* dithering method during color reduction */
MagickSizeType
extent;
MagickBooleanType
ping;
size_t
channels;
time_t
timestamp;
PixelIntensityMethod
intensity; /* method to generate an intensity value from a pixel */
size_t
duration; /* Total animation duration sum(delay*iterations) */
long
tietz_offset;
time_t
ttl;
};
struct _ImageInfo
{
CompressionType
compression;
OrientationType
orientation;
MagickBooleanType
temporary,
adjoin,
affirm,
antialias;
char
*size,
*extract,
*page,
*scenes;
size_t
scene,
number_scenes,
depth;
InterlaceType
interlace;
EndianType
endian;
ResolutionType
units;
size_t
quality;
char
*sampling_factor, /* Chroma subsampling ratio string */
*server_name,
*font,
*texture,
*density;
double
pointsize,
fuzz;
PixelPacket
background_color,
border_color,
matte_color;
MagickBooleanType
dither,
monochrome;
size_t
colors;
ColorspaceType
colorspace;
ImageType
type;
PreviewType
preview_type;
ssize_t
group;
MagickBooleanType
ping,
verbose;
char
*view,
*authenticate;
ChannelType
channel;
Image
*attributes; /* deprecated */
void
*options;
MagickProgressMonitor
progress_monitor;
void
*client_data,
*cache;
StreamHandler
stream;
FILE
*file;
void
*blob;
size_t
length;
char
magick[MaxTextExtent],
unique[MaxTextExtent],
zero[MaxTextExtent],
filename[MaxTextExtent];
MagickBooleanType
debug;
char
*tile; /* deprecated */
size_t
subimage, /* deprecated */
subrange; /* deprecated */
PixelPacket
pen; /* deprecated */
size_t
signature;
VirtualPixelMethod
virtual_pixel_method;
PixelPacket
transparent_color;
void
*profile;
MagickBooleanType
synchronize;
};
extern MagickExport ExceptionType
CatchImageException(Image *);
extern MagickExport FILE
*GetImageInfoFile(const ImageInfo *);
extern MagickExport Image
*AcquireImage(const ImageInfo *),
*AppendImages(const Image *,const MagickBooleanType,ExceptionInfo *),
*CloneImage(const Image *,const size_t,const size_t,const MagickBooleanType,
ExceptionInfo *),
*DestroyImage(Image *),
*GetImageClipMask(const Image *,ExceptionInfo *) magick_attribute((__pure__)),
*GetImageMask(const Image *,ExceptionInfo *) magick_attribute((__pure__)),
*NewMagickImage(const ImageInfo *,const size_t,const size_t,
const MagickPixelPacket *),
*ReferenceImage(Image *),
*SmushImages(const Image *,const MagickBooleanType,const ssize_t,
ExceptionInfo *);
extern MagickExport ImageInfo
*AcquireImageInfo(void),
*CloneImageInfo(const ImageInfo *),
*DestroyImageInfo(ImageInfo *);
extern MagickExport MagickBooleanType
ClipImage(Image *),
ClipImagePath(Image *,const char *,const MagickBooleanType),
CopyImagePixels(Image *,const Image *,const RectangleInfo *,
const OffsetInfo *,ExceptionInfo *),
IsTaintImage(const Image *),
IsMagickConflict(const char *) magick_attribute((__pure__)),
IsHighDynamicRangeImage(const Image *,ExceptionInfo *),
IsImageObject(const Image *),
ListMagickInfo(FILE *,ExceptionInfo *),
ModifyImage(Image **,ExceptionInfo *),
ResetImagePage(Image *,const char *),
ResetImagePixels(Image *,ExceptionInfo *),
SetImageBackgroundColor(Image *),
SetImageClipMask(Image *,const Image *),
SetImageColor(Image *,const MagickPixelPacket *),
SetImageExtent(Image *,const size_t,const size_t),
SetImageInfo(ImageInfo *,const unsigned int,ExceptionInfo *),
SetImageMask(Image *,const Image *),
SetImageOpacity(Image *,const Quantum),
SetImageChannels(Image *,const size_t),
SetImageStorageClass(Image *,const ClassType),
StripImage(Image *),
SyncImage(Image *),
SyncImageSettings(const ImageInfo *,Image *),
SyncImagesSettings(ImageInfo *,Image *);
extern MagickExport size_t
InterpretImageFilename(const ImageInfo *,Image *,const char *,int,char *);
extern MagickExport ssize_t
GetImageReferenceCount(Image *);
extern MagickExport size_t
GetImageChannels(Image *);
extern MagickExport VirtualPixelMethod
GetImageVirtualPixelMethod(const Image *),
SetImageVirtualPixelMethod(const Image *,const VirtualPixelMethod);
extern MagickExport void
AcquireNextImage(const ImageInfo *,Image *),
DestroyImagePixels(Image *),
DisassociateImageStream(Image *),
GetImageException(Image *,ExceptionInfo *),
GetImageInfo(ImageInfo *),
SetImageInfoBlob(ImageInfo *,const void *,const size_t),
SetImageInfoFile(ImageInfo *,FILE *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/attribute.h 0000644 00000003421 14751151177 0010164 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore methods to set or get image attributes.
*/
#ifndef MAGICKCORE_ATTRIBUTE_H
#define MAGICKCORE_ATTRIBUTE_H
#include "magick/image.h"
#include "magick/exception.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport ImageType
GetImageType(const Image *,ExceptionInfo *),
IdentifyImageGray(const Image *,ExceptionInfo *),
IdentifyImageType(const Image *,ExceptionInfo *);
extern MagickExport MagickBooleanType
IdentifyImageMonochrome(const Image *,ExceptionInfo *),
IsGrayImage(const Image *,ExceptionInfo *),
IsMonochromeImage(const Image *,ExceptionInfo *),
IsOpaqueImage(const Image *,ExceptionInfo *),
SetImageChannelDepth(Image *,const ChannelType,const size_t),
SetImageDepth(Image *,const size_t),
SetImageType(Image *,const ImageType);
extern MagickExport RectangleInfo
GetImageBoundingBox(const Image *,ExceptionInfo *exception);
extern MagickExport size_t
GetImageChannelDepth(const Image *,const ChannelType,ExceptionInfo *),
GetImageDepth(const Image *,ExceptionInfo *),
GetImageQuantumDepth(const Image *,const MagickBooleanType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/cache-view.h 0000644 00000007374 14751151177 0010207 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore cache view methods.
*/
#ifndef MAGICKCORE_CACHE_VIEW_H
#define MAGICKCORE_CACHE_VIEW_H
#include "magick/pixel.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedVirtualPixelMethod,
BackgroundVirtualPixelMethod,
ConstantVirtualPixelMethod, /* deprecated */
DitherVirtualPixelMethod,
EdgeVirtualPixelMethod,
MirrorVirtualPixelMethod,
RandomVirtualPixelMethod,
TileVirtualPixelMethod,
TransparentVirtualPixelMethod,
MaskVirtualPixelMethod,
BlackVirtualPixelMethod,
GrayVirtualPixelMethod,
WhiteVirtualPixelMethod,
HorizontalTileVirtualPixelMethod,
VerticalTileVirtualPixelMethod,
HorizontalTileEdgeVirtualPixelMethod,
VerticalTileEdgeVirtualPixelMethod,
CheckerTileVirtualPixelMethod
} VirtualPixelMethod;
typedef struct _CacheView
CacheView;
extern MagickExport CacheView
*AcquireAuthenticCacheView(const Image *,ExceptionInfo *),
*AcquireCacheView(const Image *),
*AcquireVirtualCacheView(const Image *,ExceptionInfo *),
*CloneCacheView(const CacheView *),
*DestroyCacheView(CacheView *);
extern MagickExport ClassType
GetCacheViewStorageClass(const CacheView *) magick_attribute((__pure__));
extern MagickExport ColorspaceType
GetCacheViewColorspace(const CacheView *) magick_attribute((__pure__));
extern MagickExport const IndexPacket
*GetCacheViewVirtualIndexQueue(const CacheView *)
magick_attribute((__pure__));
extern MagickExport const PixelPacket
*GetCacheViewVirtualPixels(const CacheView *,const ssize_t,const ssize_t,
const size_t,const size_t,ExceptionInfo *) magick_hot_spot,
*GetCacheViewVirtualPixelQueue(const CacheView *) magick_hot_spot;
extern MagickExport ExceptionInfo
*GetCacheViewException(const CacheView *) magick_attribute((__pure__));
extern MagickExport IndexPacket
*GetCacheViewAuthenticIndexQueue(CacheView *) magick_attribute((__pure__));
extern MagickExport MagickBooleanType
GetOneCacheViewAuthenticPixel(const CacheView *magick_restrict,const ssize_t,
const ssize_t,PixelPacket *magick_restrict,ExceptionInfo *),
GetOneCacheViewVirtualMethodPixel(const CacheView *,
const VirtualPixelMethod,const ssize_t,const ssize_t,PixelPacket *,
ExceptionInfo *),
GetOneCacheViewVirtualPixel(const CacheView *magick_restrict,const ssize_t,
const ssize_t,PixelPacket *magick_restrict,ExceptionInfo *),
SetCacheViewStorageClass(CacheView *,const ClassType),
SetCacheViewVirtualPixelMethod(CacheView *magick_restrict,
const VirtualPixelMethod),
SyncCacheViewAuthenticPixels(CacheView *magick_restrict,ExceptionInfo *)
magick_hot_spot;
extern MagickExport MagickSizeType
GetCacheViewExtent(const CacheView *);
extern MagickExport size_t
GetCacheViewChannels(const CacheView *);
extern MagickExport PixelPacket
*GetCacheViewAuthenticPixelQueue(CacheView *) magick_hot_spot,
*GetCacheViewAuthenticPixels(CacheView *,const ssize_t,const ssize_t,
const size_t,const size_t,ExceptionInfo *) magick_hot_spot,
*QueueCacheViewAuthenticPixels(CacheView *,const ssize_t,const ssize_t,
const size_t,const size_t,ExceptionInfo *) magick_hot_spot;
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/type.h 0000644 00000004154 14751151177 0007146 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image type methods.
*/
#ifndef MAGICKCORE_TYPE_H
#define MAGICKCORE_TYPE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedStretch,
NormalStretch,
UltraCondensedStretch,
ExtraCondensedStretch,
CondensedStretch,
SemiCondensedStretch,
SemiExpandedStretch,
ExpandedStretch,
ExtraExpandedStretch,
UltraExpandedStretch,
AnyStretch
} StretchType;
typedef enum
{
UndefinedStyle,
NormalStyle,
ItalicStyle,
ObliqueStyle,
AnyStyle,
BoldStyle /* deprecated */
} StyleType;
typedef struct _TypeInfo
{
size_t
face;
char
*path,
*name,
*description,
*family;
StyleType
style;
StretchType
stretch;
size_t
weight;
char
*encoding,
*foundry,
*format,
*metrics,
*glyphs;
MagickBooleanType
stealth;
struct _TypeInfo
*previous,
*next; /* deprecated, use GetTypeInfoList() */
size_t
signature;
} TypeInfo;
extern MagickExport char
**GetTypeList(const char *,size_t *,ExceptionInfo *);
extern MagickExport MagickBooleanType
ListTypeInfo(FILE *,ExceptionInfo *),
TypeComponentGenesis(void);
extern MagickExport const TypeInfo
*GetTypeInfo(const char *,ExceptionInfo *),
*GetTypeInfoByFamily(const char *,const StyleType,const StretchType,
const size_t,ExceptionInfo *),
**GetTypeInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport void
TypeComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/display.h 0000644 00000002036 14751151177 0007627 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore methods to interactively display and edit an image.
*/
#ifndef MAGICKCORE_DISPLAY_H
#define MAGICKCORE_DISPLAY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
DisplayImages(const ImageInfo *,Image *),
RemoteDisplayCommand(const ImageInfo *,const char *,const char *,
ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/animate.h 0000644 00000001676 14751151177 0007611 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore methods to interactively animate an image sequence.
*/
#ifndef MAGICKCORE_ANIMATE_H
#define MAGICKCORE_ANIMATE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
AnimateImages(const ImageInfo *,Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/deprecate.h 0000644 00000042106 14751151177 0010120 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore deprecated methods.
*/
#ifndef MAGICKCORE_DEPRECATE_H
#define MAGICKCORE_DEPRECATE_H
#include <stdarg.h>
#include "magick/blob.h"
#include "magick/cache-view.h"
#include "magick/draw.h"
#include "magick/constitute.h"
#include "magick/magick-config.h"
#include "magick/pixel.h"
#include "magick/quantize.h"
#include "magick/quantum.h"
#include "magick/registry.h"
#include "magick/semaphore.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if !defined(MAGICKCORE_EXCLUDE_DEPRECATED)
#if !defined(magick_attribute)
# if !defined(__clang__) && !defined(__GNUC__)
# define magick_attribute(x) /*nothing*/
# else
# define magick_attribute __attribute__
# endif
#endif
#define Downscale(quantum) ScaleQuantumToChar(quantum)
#define LABColorspace LabColorspace
#define CompressPixelGamma(pixel) DecodePixelGamma(pixel)
#define DecodesRGBGamma(pixel) DecodePixelGamma(pixel)
#define EncodesRGBGamma(pixel) EncodePixelGamma(pixel)
#define ExpandPixelGamma(pixel) EncodePixelGamma(pixel)
#define Intensity(color) PixelIntensityToQuantum(color)
#define LiberateUniqueFileResource(resource) \
RelinquishUniqueFileResource(resource)
#define LiberateMagickResource(resource) RelinquishMagickResource(resource)
#define LiberateSemaphore(semaphore) RelinquishSemaphore(semaphore)
#define MagickHuge 3.4e+38F
#define MaxRGB QuantumRange /* deprecated */
#define QuantumDepth MAGICKCORE_QUANTUM_DEPTH
#define RunlengthEncodedCompression RLECompression
#define Upscale(value) ScaleCharToQuantum(value)
#define XDownscale(value) ScaleShortToQuantum(value)
#define XUpscale(quantum) ScaleQuantumToShort(quantum)
typedef enum
{
UndefinedMagickLayerMethod
} MagickLayerMethod;
typedef MagickOffsetType ExtendedSignedIntegralType;
typedef MagickSizeType ExtendedUnsignedIntegralType;
typedef MagickRealType ExtendedRationalType;
typedef struct _ViewInfo ViewInfo;
typedef MagickBooleanType
(*MonitorHandler)(const char *,const MagickOffsetType,const MagickSizeType,
ExceptionInfo *);
typedef struct _ImageAttribute
{
char
*key,
*value;
MagickBooleanType
compression;
struct _ImageAttribute
*previous,
*next; /* deprecated */
} ImageAttribute;
extern MagickExport CacheView
*CloseCacheView(CacheView *) magick_attribute((deprecated)),
*OpenCacheView(const Image *) magick_attribute((deprecated));
extern MagickExport char
*AllocateString(const char *) magick_attribute((deprecated)),
*InterpretImageAttributes(const ImageInfo *,Image *,const char *)
magick_attribute((deprecated)),
*PostscriptGeometry(const char *) magick_attribute((deprecated)),
*TranslateText(const ImageInfo *,Image *,const char *)
magick_attribute((deprecated));
extern MagickExport const ImageAttribute
*GetImageAttribute(const Image *,const char *),
*GetImageClippingPathAttribute(Image *) magick_attribute((deprecated)),
*GetNextImageAttribute(const Image *) magick_attribute((deprecated));
extern MagickExport const IndexPacket
*AcquireCacheViewIndexes(const CacheView *) magick_attribute((deprecated)),
*AcquireIndexes(const Image *) magick_attribute((deprecated));
extern MagickExport const PixelPacket
*AcquirePixels(const Image *) magick_attribute((deprecated)),
*AcquireCacheViewPixels(const CacheView *,const ssize_t,const ssize_t,
const size_t,const size_t,ExceptionInfo *)
magick_attribute((deprecated)),
*AcquireImagePixels(const Image *,const ssize_t,const ssize_t,const size_t,
const size_t,ExceptionInfo *) magick_attribute((deprecated));
extern MagickExport FILE
*OpenMagickStream(const char *,const char *);
extern MagickExport Image
*AllocateImage(const ImageInfo *) magick_attribute((deprecated)),
*AverageImages(const Image *,ExceptionInfo *),
*ExtractSubimageFromImage(Image *,const Image *,ExceptionInfo *)
magick_attribute((deprecated)),
*GetImageFromMagickRegistry(const char *,ssize_t *id,ExceptionInfo *)
magick_attribute((deprecated)),
*GetImageList(const Image *,const ssize_t,ExceptionInfo *)
magick_attribute((deprecated)),
*GetNextImage(const Image *) magick_attribute((deprecated)),
*GetPreviousImage(const Image *) magick_attribute((deprecated)),
*FlattenImages(Image *,ExceptionInfo *) magick_attribute((deprecated)),
*MaximumImages(const Image *,ExceptionInfo *),
*MedianFilterImage(const Image *,const double,ExceptionInfo *),
*ModeImage(const Image *,const double,ExceptionInfo *),
*MinimumImages(const Image *,ExceptionInfo *),
*MosaicImages(Image *,ExceptionInfo *) magick_attribute((deprecated)),
*PopImageList(Image **) magick_attribute((deprecated)),
*RadialBlurImage(const Image *,const double,ExceptionInfo *)
magick_attribute((deprecated)),
*RadialBlurImageChannel(const Image *,const ChannelType,const double,
ExceptionInfo *) magick_attribute((deprecated)),
*RecolorImage(const Image *,const size_t,const double *,ExceptionInfo *)
magick_attribute((deprecated)),
*ReduceNoiseImage(const Image *,const double,ExceptionInfo *),
*ShiftImageList(Image **) magick_attribute((deprecated)),
*SpliceImageList(Image *,const ssize_t,const size_t,const Image *,
ExceptionInfo *) magick_attribute((deprecated)),
*ZoomImage(const Image *,const size_t,const size_t,ExceptionInfo *)
magick_attribute((deprecated));
extern MagickExport IndexPacket
*GetCacheViewIndexes(CacheView *) magick_attribute((deprecated)),
*GetIndexes(const Image *) magick_attribute((deprecated)),
ValidateColormapIndex(Image *,const size_t) magick_attribute((deprecated));
extern MagickExport int
GetImageGeometry(Image *,const char *,const unsigned int,RectangleInfo *)
magick_attribute((deprecated)),
ParseImageGeometry(const char *,ssize_t *,ssize_t *,size_t *,size_t *)
magick_attribute((deprecated)),
SystemCommand(const MagickBooleanType,const MagickBooleanType,const char *,
ExceptionInfo *) magick_attribute((deprecated));
extern MagickExport MagickBooleanType
AcquireOneCacheViewPixel(const CacheView *,const ssize_t,const ssize_t,
PixelPacket *,ExceptionInfo *) magick_attribute((deprecated)),
AcquireOneCacheViewVirtualPixel(const CacheView *,const VirtualPixelMethod,
const ssize_t,const ssize_t,PixelPacket *,ExceptionInfo *)
magick_attribute((deprecated)),
AffinityImage(const QuantizeInfo *,Image *,const Image *)
magick_attribute((deprecated)),
AffinityImages(const QuantizeInfo *,Image *,const Image *)
magick_attribute((deprecated)),
AllocateImageColormap(Image *,const size_t)
magick_attribute((deprecated)),
ClipPathImage(Image *,const char *,const MagickBooleanType)
magick_attribute((deprecated)),
CloneImageAttributes(Image *,const Image *) magick_attribute((deprecated)),
ColorFloodfillImage(Image *,const DrawInfo *,const PixelPacket,const ssize_t,
const ssize_t,const PaintMethod) magick_attribute((deprecated)),
ConstituteComponentGenesis(void) magick_attribute((deprecated)),
DeleteImageAttribute(Image *,const char *) magick_attribute((deprecated)),
DeleteMagickRegistry(const ssize_t) magick_attribute((deprecated)),
DescribeImage(Image *,FILE *,const MagickBooleanType)
magick_attribute((deprecated)),
FormatImageAttribute(Image *,const char *,const char *,...)
magick_attribute((__format__ (__printf__,3,4)))
magick_attribute((deprecated)),
FormatImageAttributeList(Image *,const char *,const char *,va_list)
magick_attribute((__format__ (__printf__,3,0)))
magick_attribute((deprecated)),
FormatImagePropertyList(Image *,const char *,const char *,va_list)
magick_attribute((__format__ (__printf__,3,0))),
FuzzyColorCompare(const Image *,const PixelPacket *,const PixelPacket *)
magick_attribute((deprecated)),
FuzzyOpacityCompare(const Image *,const PixelPacket *,const PixelPacket *)
magick_attribute((deprecated)),
InitializeModuleList(ExceptionInfo *) magick_attribute((deprecated)),
IsMagickInstantiated(void) magick_attribute((deprecated)),
LevelImageColors(Image *,const ChannelType,const MagickPixelPacket *,
const MagickPixelPacket *, const MagickBooleanType)
magick_attribute((deprecated)),
LoadMimeLists(const char *,ExceptionInfo *) magick_attribute((deprecated)),
MagickMonitor(const char *,const MagickOffsetType,const MagickSizeType,
void *) magick_attribute((deprecated)),
MapImage(Image *,const Image *,const MagickBooleanType)
magick_attribute((deprecated)),
MapImages(Image *,const Image *,const MagickBooleanType)
magick_attribute((deprecated)),
MatteFloodfillImage(Image *,const PixelPacket,const Quantum,const ssize_t,
const ssize_t,const PaintMethod) magick_attribute((deprecated)),
OpaqueImage(Image *,const PixelPacket,const PixelPacket)
magick_attribute((deprecated)),
PaintFloodfillImage(Image *,const ChannelType,const MagickPixelPacket *,
const ssize_t,const ssize_t,const DrawInfo *,const PaintMethod)
magick_attribute((deprecated)),
PaintOpaqueImage(Image *,const MagickPixelPacket *,const MagickPixelPacket *)
magick_attribute((deprecated)),
PaintOpaqueImageChannel(Image *,const ChannelType,const MagickPixelPacket *,
const MagickPixelPacket *) magick_attribute((deprecated)),
PaintTransparentImage(Image *,const MagickPixelPacket *,const Quantum)
magick_attribute((deprecated)),
SetExceptionInfo(ExceptionInfo *,ExceptionType)
magick_attribute((deprecated)),
SetImageAttribute(Image *,const char *,const char *)
magick_attribute((deprecated)),
SyncCacheViewPixels(CacheView *) magick_attribute((deprecated)),
SyncImagePixels(Image *) magick_attribute((deprecated)),
TransparentImage(Image *,const PixelPacket,const Quantum)
magick_attribute((deprecated));
extern MagickExport MagickPixelPacket
AcquireOneMagickPixel(const Image *,const ssize_t,const ssize_t,
ExceptionInfo *) magick_attribute((deprecated));
extern MagickExport MonitorHandler
GetMonitorHandler(void) magick_attribute((deprecated)),
SetMonitorHandler(MonitorHandler) magick_attribute((deprecated));
extern MagickExport MagickOffsetType
SizeBlob(Image *image) magick_attribute((deprecated));
extern MagickExport MagickPixelPacket
InterpolatePixelColor(const Image *,CacheView *,const InterpolatePixelMethod,
const double,const double,ExceptionInfo *) magick_attribute((deprecated));
extern MagickExport MagickStatusType
ParseSizeGeometry(const Image *,const char *,RectangleInfo *)
magick_attribute((deprecated));
extern MagickExport PixelPacket
AcquireOnePixel(const Image *,const ssize_t,const ssize_t,ExceptionInfo *)
magick_attribute((deprecated)),
AcquireOneVirtualPixel(const Image *,const VirtualPixelMethod,const ssize_t,
const ssize_t,ExceptionInfo *) magick_attribute((deprecated)),
*GetCacheView(CacheView *,const ssize_t,const ssize_t,const size_t,
const size_t) magick_attribute((deprecated)),
*GetCacheViewPixels(CacheView *,const ssize_t,const ssize_t,const size_t,
const size_t) magick_attribute((deprecated)),
*GetImagePixels(Image *,const ssize_t,const ssize_t,const size_t,
const size_t) magick_attribute((deprecated)),
GetOnePixel(Image *,const ssize_t,const ssize_t)
magick_attribute((deprecated)),
*GetPixels(const Image *) magick_attribute((deprecated)),
*SetCacheViewPixels(CacheView *,const ssize_t,const ssize_t,const size_t,
const size_t) magick_attribute((deprecated)),
*SetImagePixels(Image *,const ssize_t,const ssize_t,const size_t,
const size_t) magick_attribute((deprecated));
extern MagickExport MagickRealType
InversesRGBCompandor(const MagickRealType) magick_attribute((deprecated)),
sRGBCompandor(const MagickRealType) magick_attribute((deprecated));
extern MagickExport size_t
GetImageListSize(const Image *) magick_attribute((deprecated)),
PopImagePixels(Image *,const QuantumType,unsigned char *)
magick_attribute((deprecated)),
PushImagePixels(Image *,const QuantumType,const unsigned char *)
magick_attribute((deprecated));
extern MagickExport ssize_t
FormatMagickString(char *,const size_t,const char *,...)
magick_attribute((__format__ (__printf__,3,4)))
magick_attribute((deprecated)),
FormatMagickStringList(char *,const size_t,const char *,va_list)
magick_attribute((__format__ (__printf__,3,0))),
GetImageListIndex(const Image *) magick_attribute((deprecated)),
SetMagickRegistry(const RegistryType,const void *,const size_t,
ExceptionInfo *) magick_attribute((deprecated));
extern MagickExport unsigned int
ChannelImage(Image *,const ChannelType) magick_attribute((deprecated)),
ChannelThresholdImage(Image *,const char *) magick_attribute((deprecated)),
DispatchImage(const Image *,const ssize_t,const ssize_t,const size_t,
const size_t,const char *,const StorageType,void *,ExceptionInfo *)
magick_attribute((deprecated)),
FuzzyColorMatch(const PixelPacket *,const PixelPacket *,const double)
magick_attribute((deprecated)),
GetNumberScenes(const Image *) magick_attribute((deprecated)),
GetMagickGeometry(const char *,ssize_t *,ssize_t *,size_t *,size_t *)
magick_attribute((deprecated)),
IsSubimage(const char *,const unsigned int) magick_attribute((deprecated)),
PushImageList(Image **,const Image *,ExceptionInfo *)
magick_attribute((deprecated)),
QuantizationError(Image *) magick_attribute((deprecated)),
RandomChannelThresholdImage(Image *,const char *,const char *,
ExceptionInfo *) magick_attribute((deprecated)),
SetImageList(Image **,const Image *,const ssize_t,ExceptionInfo *)
magick_attribute((deprecated)),
TransformColorspace(Image *,const ColorspaceType)
magick_attribute((deprecated)),
ThresholdImage(Image *,const double) magick_attribute((deprecated)),
ThresholdImageChannel(Image *,const char *) magick_attribute((deprecated)),
UnshiftImageList(Image **,const Image *,ExceptionInfo *)
magick_attribute((deprecated));
extern MagickExport void
*AcquireMemory(const size_t) magick_attribute((deprecated)),
AcquireSemaphoreInfo(SemaphoreInfo **) magick_attribute((deprecated)),
AllocateNextImage(const ImageInfo *,Image *) magick_attribute((deprecated)),
*CloneMemory(void *,const void *,const size_t) magick_attribute((deprecated)),
ConstituteComponentTerminus(void) magick_attribute((deprecated)),
DestroyConstitute(void),
DestroyImageAttributes(Image *) magick_attribute((deprecated)),
DestroyImages(Image *) magick_attribute((deprecated)),
DestroyMagick(void) magick_attribute((deprecated)),
DestroyMagickRegistry(void) magick_attribute((deprecated)),
*GetConfigureBlob(const char *,char *,size_t *,ExceptionInfo *)
magick_attribute((deprecated)),
GetExceptionInfo(ExceptionInfo *),
*GetMagickRegistry(const ssize_t,RegistryType *,size_t *,ExceptionInfo *)
magick_attribute((deprecated)),
GetTokenToken(const char *,const char **,char *),
IdentityAffine(AffineMatrix *) magick_attribute((deprecated)),
LiberateMemory(void **) magick_attribute((deprecated)),
LiberateSemaphoreInfo(SemaphoreInfo **) magick_attribute((deprecated)),
FormatString(char *,const char *,...)
magick_attribute((__format__ (__printf__,2,3)))
magick_attribute((deprecated)),
FormatStringList(char *,const char *,va_list)
magick_attribute((__format__ (__printf__,2,0)))
magick_attribute((deprecated)),
HSLTransform(const double,const double,const double,Quantum *,Quantum *,
Quantum *) magick_attribute((deprecated)),
InitializeMagick(const char *) magick_attribute((deprecated)),
MagickIncarnate(const char *) magick_attribute((deprecated)),
ReacquireMemory(void **,const size_t) magick_attribute((deprecated)),
RelinquishSemaphoreInfo(SemaphoreInfo *) magick_attribute((deprecated)),
ResetImageAttributeIterator(const Image *) magick_attribute((deprecated)),
SetCacheThreshold(const size_t) magick_attribute((deprecated)),
SetImage(Image *,const Quantum) magick_attribute((deprecated)),
Strip(char *) magick_attribute((deprecated)),
TemporaryFilename(char *) magick_attribute((deprecated)),
TransformHSL(const Quantum,const Quantum,const Quantum,double *,double *,
double *) magick_attribute((deprecated));
#if defined(MAGICKCORE_WINGDI32_DELEGATE)
extern MagickExport void
*CropImageToHBITMAP(Image *,const RectangleInfo *,ExceptionInfo *),
*ImageToHBITMAP(Image *,ExceptionInfo *);
#endif
/*
Inline methods.
*/
static inline double MagickEpsilonReciprocal(const double x)
{
double
sign;
sign=x < 0.0 ? -1.0 : 1.0;
if ((sign*x) >= MagickEpsilon)
return(1.0/x);
return(sign/MagickEpsilon);
}
static inline Quantum PixelIntensityToQuantum(
const Image *magick_restrict image,const PixelPacket *magick_restrict pixel)
{
return(ClampToQuantum(GetPixelIntensity(image,pixel)));
}
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/locale_.h 0000644 00000005161 14751151177 0007562 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore locale methods.
*/
#ifndef MAGICKCORE_LOCALE_H
#define MAGICKCORE_LOCALE_H
#include "magick/hashmap.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _LocaleInfo
{
char
*path,
*tag,
*message;
MagickBooleanType
stealth;
struct _LocaleInfo
*previous,
*next; /* deprecated, use GetLocaleInfoList() */
size_t
signature;
} LocaleInfo;
extern MagickExport char
**GetLocaleList(const char *,size_t *,ExceptionInfo *);
extern MagickExport const char
*GetLocaleMessage(const char *);
extern MagickExport const LocaleInfo
*GetLocaleInfo_(const char *,ExceptionInfo *),
**GetLocaleInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport double
InterpretLocaleValue(const char *magick_restrict,char **magick_restrict);
extern MagickExport int
LocaleCompare(const char *,const char *) magick_attribute((__pure__)),
LocaleLowercase(const int),
LocaleNCompare(const char *,const char *,const size_t)
magick_attribute((__pure__)),
LocaleUppercase(const int);
extern MagickExport LinkedListInfo
*DestroyLocaleOptions(LinkedListInfo *),
*GetLocaleOptions(const char *,ExceptionInfo *);
extern MagickExport MagickBooleanType
ListLocaleInfo(FILE *,ExceptionInfo *),
LocaleComponentGenesis(void);
extern MagickExport ssize_t
FormatLocaleFile(FILE *,const char *magick_restrict,...)
magick_attribute((__format__ (__printf__,2,3))),
FormatLocaleFileList(FILE *,const char *magick_restrict,va_list)
magick_attribute((__format__ (__printf__,2,0))),
FormatLocaleString(char *magick_restrict,const size_t,
const char *magick_restrict,...)
magick_attribute((__format__ (__printf__,3,4))),
FormatLocaleStringList(char *magick_restrict,const size_t,
const char *magick_restrict,
va_list) magick_attribute((__format__ (__printf__,3,0)));
extern MagickExport void
LocaleComponentTerminus(void),
LocaleLower(char *),
LocaleUpper(char *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/resource_.h 0000644 00000003466 14751151177 0010160 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore resource methods.
*/
#ifndef MAGICKCORE_RESOURCE_H
#define MAGICKCORE_RESOURCE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedResource,
AreaResource,
DiskResource,
FileResource,
MapResource,
MemoryResource,
ThreadResource,
TimeResource,
ThrottleResource,
WidthResource,
HeightResource,
ListLengthResource
} ResourceType;
#define MagickResourceInfinity (MagickULLConstant(~0) >> 1)
extern MagickExport int
AcquireUniqueFileResource(char *);
extern MagickExport MagickBooleanType
AcquireMagickResource(const ResourceType,const MagickSizeType),
GetPathTemplate(char *),
ListMagickResourceInfo(FILE *,ExceptionInfo *),
RelinquishUniqueFileResource(const char *),
ResourceComponentGenesis(void),
SetMagickResourceLimit(const ResourceType,const MagickSizeType);
extern MagickExport MagickSizeType
GetMagickResource(const ResourceType),
GetMagickResourceLimit(const ResourceType);
extern MagickExport void
AsynchronousResourceComponentTerminus(void),
RelinquishMagickResource(const ResourceType,const MagickSizeType),
ResourceComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/memory_.h 0000644 00000006325 14751151177 0007636 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore memory methods.
*/
#ifndef MAGICKCORE_MEMORY_H
#define MAGICKCORE_MEMORY_H
#include <errno.h>
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _MemoryInfo
MemoryInfo;
typedef void
*(*AcquireMemoryHandler)(size_t) magick_alloc_size(1),
(*DestroyMemoryHandler)(void *),
*(*ResizeMemoryHandler)(void *,size_t) magick_alloc_size(2),
*(*AcquireAlignedMemoryHandler)(const size_t,const size_t),
(*RelinquishAlignedMemoryHandler)(void *);
extern MagickExport MemoryInfo
*AcquireVirtualMemory(const size_t,const size_t) magick_alloc_sizes(1,2),
*RelinquishVirtualMemory(MemoryInfo *);
extern MagickExport size_t
GetMaxMemoryRequest(void);
extern MagickExport void
*AcquireAlignedMemory(const size_t,const size_t)
magick_attribute((__malloc__)) magick_alloc_sizes(1,2),
*AcquireMagickMemory(const size_t) magick_attribute((__malloc__))
magick_alloc_size(1),
*AcquireCriticalMemory(const size_t),
*AcquireQuantumMemory(const size_t,const size_t)
magick_attribute((__malloc__)) magick_alloc_sizes(1,2),
*CopyMagickMemory(void *magick_restrict,const void *magick_restrict,
const size_t) magick_attribute((__nonnull__)),
DestroyMagickMemory(void),
GetMagickMemoryMethods(AcquireMemoryHandler *,ResizeMemoryHandler *,
DestroyMemoryHandler *),
*GetVirtualMemoryBlob(const MemoryInfo *),
*RelinquishAlignedMemory(void *),
*RelinquishMagickMemory(void *),
*ResetMagickMemory(void *,int,const size_t),
*ResizeMagickMemory(void *,const size_t)
magick_attribute((__malloc__)) magick_alloc_size(2),
*ResizeQuantumMemory(void *,const size_t,const size_t)
magick_attribute((__malloc__)) magick_alloc_sizes(2,3),
SetMagickAlignedMemoryMethods(AcquireAlignedMemoryHandler,
RelinquishAlignedMemoryHandler),
SetMagickMemoryMethods(AcquireMemoryHandler,ResizeMemoryHandler,
DestroyMemoryHandler);
static inline MagickBooleanType HeapOverflowSanityCheck(
const size_t count,const size_t quantum)
{
if ((count == 0) || (quantum == 0))
return(MagickTrue);
if (quantum != ((count*quantum)/count))
{
errno=ENOMEM;
return(MagickTrue);
}
return(MagickFalse);
}
static inline MagickBooleanType HeapOverflowSanityCheckGetSize(
const size_t count,const size_t quantum,size_t *const extent)
{
size_t
length;
if ((count == 0) || (quantum == 0))
return(MagickTrue);
length=count*quantum;
if (quantum != (length/count))
{
errno=ENOMEM;
return(MagickTrue);
}
if (extent != (size_t *) NULL)
*extent=length;
return(MagickFalse);
}
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/identify.h 0000644 00000001666 14751151177 0010005 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image identify method.
*/
#ifndef MAGICKCORE_IDENTIFY_H
#define MAGICKCORE_IDENTIFY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport MagickBooleanType
IdentifyImage(Image *,FILE *,const MagickBooleanType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/module.h 0000644 00000004350 14751151177 0007450 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore module methods.
*/
#ifndef MAGICKCORE_MODULE_H
#define MAGICKCORE_MODULE_H
#include <time.h>
#include "magick/version.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#define MagickImageCoderSignature ((size_t) \
(((MagickLibInterface) << 8) | MAGICKCORE_QUANTUM_DEPTH))
#define MagickImageFilterSignature ((size_t) \
(((MagickLibInterface) << 8) | MAGICKCORE_QUANTUM_DEPTH))
typedef enum
{
MagickImageCoderModule,
MagickImageFilterModule
} MagickModuleType;
typedef struct _ModuleInfo
{
char
*path,
*tag;
void
*handle,
(*unregister_module)(void);
size_t
(*register_module)(void);
time_t
timestamp;
MagickBooleanType
stealth;
struct _ModuleInfo
*previous,
*next; /* deprecated, use GetModuleInfoList() */
size_t
signature;
} ModuleInfo;
typedef size_t
ImageFilterHandler(Image **,const int,const char **,ExceptionInfo *);
extern MagickExport char
**GetModuleList(const char *,const MagickModuleType,size_t *,ExceptionInfo *);
extern MagickExport const ModuleInfo
**GetModuleInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport MagickBooleanType
InvokeDynamicImageFilter(const char *,Image **,const int,const char **,
ExceptionInfo *),
ListModuleInfo(FILE *,ExceptionInfo *),
ModuleComponentGenesis(void),
OpenModule(const char *,ExceptionInfo *),
OpenModules(ExceptionInfo *);
extern MagickExport ModuleInfo
*GetModuleInfo(const char *,ExceptionInfo *);
extern MagickExport void
DestroyModuleList(void),
ModuleComponentTerminus(void);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/effect.h 0000644 00000010251 14751151177 0007414 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image effects methods.
*/
#ifndef MAGICKCORE_EFFECT_H
#define MAGICKCORE_EFFECT_H
#include "magick/morphology.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedPreview,
RotatePreview,
ShearPreview,
RollPreview,
HuePreview,
SaturationPreview,
BrightnessPreview,
GammaPreview,
SpiffPreview,
DullPreview,
GrayscalePreview,
QuantizePreview,
DespecklePreview,
ReduceNoisePreview,
AddNoisePreview,
SharpenPreview,
BlurPreview,
ThresholdPreview,
EdgeDetectPreview,
SpreadPreview,
SolarizePreview,
ShadePreview,
RaisePreview,
SegmentPreview,
SwirlPreview,
ImplodePreview,
WavePreview,
OilPaintPreview,
CharcoalDrawingPreview,
JPEGPreview
} PreviewType;
extern MagickExport Image
*AdaptiveBlurImage(const Image *,const double,const double,ExceptionInfo *),
*AdaptiveBlurImageChannel(const Image *,const ChannelType,const double,
const double,ExceptionInfo *),
*AdaptiveSharpenImage(const Image *,const double,const double,
ExceptionInfo *),
*AdaptiveSharpenImageChannel(const Image *,const ChannelType,const double,
const double,ExceptionInfo *),
*BlurImage(const Image *,const double,const double,ExceptionInfo *),
*BlurImageChannel(const Image *,const ChannelType,const double,const double,
ExceptionInfo *),
*ConvolveImage(const Image *,const size_t,const double *,ExceptionInfo *),
*ConvolveImageChannel(const Image *,const ChannelType,const size_t,
const double *,ExceptionInfo *),
*DespeckleImage(const Image *,ExceptionInfo *),
*EdgeImage(const Image *,const double,ExceptionInfo *),
*EmbossImage(const Image *,const double,const double,ExceptionInfo *),
*FilterImage(const Image *,const KernelInfo *,ExceptionInfo *),
*FilterImageChannel(const Image *,const ChannelType,const KernelInfo *,
ExceptionInfo *),
*GaussianBlurImage(const Image *,const double,const double,ExceptionInfo *),
*GaussianBlurImageChannel(const Image *,const ChannelType,const double,
const double,ExceptionInfo *),
*KuwaharaImage(const Image *,const double,const double,ExceptionInfo *),
*KuwaharaImageChannel(const Image *,const ChannelType,const double,
const double,ExceptionInfo *),
*LocalContrastImage(const Image *,const double,const double,ExceptionInfo *),
*MotionBlurImage(const Image *,const double,const double,const double,
ExceptionInfo *),
*MotionBlurImageChannel(const Image *,const ChannelType,const double,
const double,const double,ExceptionInfo *),
*PreviewImage(const Image *,const PreviewType,ExceptionInfo *),
*RotationalBlurImage(const Image *,const double,ExceptionInfo *),
*RotationalBlurImageChannel(const Image *,const ChannelType,const double,
ExceptionInfo *),
*SelectiveBlurImage(const Image *,const double,const double,const double,
ExceptionInfo *),
*SelectiveBlurImageChannel(const Image *,const ChannelType,const double,
const double,const double,ExceptionInfo *),
*ShadeImage(const Image *,const MagickBooleanType,const double,const double,
ExceptionInfo *),
*SharpenImage(const Image *,const double,const double,ExceptionInfo *),
*SharpenImageChannel(const Image *,const ChannelType,const double,
const double,ExceptionInfo *),
*SpreadImage(const Image *,const double,ExceptionInfo *),
*UnsharpMaskImage(const Image *,const double,const double,const double,
const double,ExceptionInfo *),
*UnsharpMaskImageChannel(const Image *,const ChannelType,const double,
const double,const double,const double,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/splay-tree.h 0000644 00000003743 14751151177 0010255 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore splay-tree methods.
*/
#ifndef MAGICKCORE_SPLAY_H
#define MAGICKCORE_SPLAY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _SplayTreeInfo
SplayTreeInfo;
extern MagickExport MagickBooleanType
AddValueToSplayTree(SplayTreeInfo *,const void *,const void *),
DeleteNodeByValueFromSplayTree(SplayTreeInfo *,const void *),
DeleteNodeFromSplayTree(SplayTreeInfo *,const void *);
extern MagickExport const void
*GetNextKeyInSplayTree(SplayTreeInfo *),
*GetNextValueInSplayTree(SplayTreeInfo *),
*GetRootValueFromSplayTree(SplayTreeInfo *),
*GetValueFromSplayTree(SplayTreeInfo *,const void *);
extern MagickExport int
CompareSplayTreeString(const void *,const void *),
CompareSplayTreeStringInfo(const void *,const void *);
extern MagickExport SplayTreeInfo
*CloneSplayTree(SplayTreeInfo *,void *(*)(void *),void *(*)(void *)),
*DestroySplayTree(SplayTreeInfo *),
*NewSplayTree(int (*)(const void *,const void *),void *(*)(void *),
void *(*)(void *));
extern MagickExport size_t
GetNumberOfNodesInSplayTree(const SplayTreeInfo *);
extern MagickExport void
*RemoveNodeByValueFromSplayTree(SplayTreeInfo *,const void *),
*RemoveNodeFromSplayTree(SplayTreeInfo *,const void *),
ResetSplayTree(SplayTreeInfo *),
ResetSplayTreeIterator(SplayTreeInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/magick-baseconfig-64.h 0000644 00000134750 14751151177 0011753 0 ustar 00 #ifndef _MAGICK_MAGICK_BASECONFIG_H
#define _MAGICK_MAGICK_BASECONFIG_H 1
/* magick/magick-baseconfig.h. Generated automatically at end of configure. */
/* config/config.h. Generated from config.h.in by configure. */
/* config/config.h.in. Generated from configure.ac by autoheader. */
/* Define if building universal (internal helper macro) */
/* #undef AC_APPLE_UNIVERSAL_BUILD */
/* Define if you have AUTOTRACE library */
/* #undef AUTOTRACE_DELEGATE */
/* Define if coders and filters are to be built as modules. */
#ifndef MAGICKCORE_BUILD_MODULES
#define MAGICKCORE_BUILD_MODULES 1
#endif
/* Define if you have the bzip2 library */
#ifndef MAGICKCORE_BZLIB_DELEGATE
#define MAGICKCORE_BZLIB_DELEGATE 1
#endif
/* Define if you have CAIRO library */
#ifndef MAGICKCORE_CAIRO_DELEGATE
#define MAGICKCORE_CAIRO_DELEGATE 1
#endif
/* permit enciphering and deciphering image pixels */
#ifndef MAGICKCORE_CIPHER_SUPPORT
#define MAGICKCORE_CIPHER_SUPPORT 1
#endif
/* coders subdirectory. */
#ifndef MAGICKCORE_CODER_DIRNAME
#define MAGICKCORE_CODER_DIRNAME "coders"
#endif
/* Directory where architecture-dependent configuration files live. */
#ifndef MAGICKCORE_CONFIGURE_PATH
#define MAGICKCORE_CONFIGURE_PATH "/etc/ImageMagick-6/"
#endif
/* Subdirectory of lib where architecture-dependent configuration files live.
*/
#ifndef MAGICKCORE_CONFIGURE_RELATIVE_PATH
#define MAGICKCORE_CONFIGURE_RELATIVE_PATH "ImageMagick-6"
#endif
/* Define if you have DJVU library */
#ifndef MAGICKCORE_DJVU_DELEGATE
#define MAGICKCORE_DJVU_DELEGATE 1
#endif
/* Directory where ImageMagick documents live. */
#ifndef MAGICKCORE_DOCUMENTATION_PATH
#define MAGICKCORE_DOCUMENTATION_PATH "/usr/share/doc/ImageMagick-6/"
#endif
/* Define if you have Display Postscript */
/* #undef DPS_DELEGATE */
/* exclude deprecated methods in MagickCore API */
/* #undef EXCLUDE_DEPRECATED */
/* Directory where executables are installed. */
#ifndef MAGICKCORE_EXECUTABLE_PATH
#define MAGICKCORE_EXECUTABLE_PATH "/usr/bin/"
#endif
/* Define if you have FFTW library */
/* #undef FFTW_DELEGATE */
/* filter subdirectory. */
#ifndef MAGICKCORE_FILTER_DIRNAME
#define MAGICKCORE_FILTER_DIRNAME "filters"
#endif
/* Define if you have FLIF library */
/* #undef FLIF_DELEGATE */
/* Define if you have FONTCONFIG library */
#ifndef MAGICKCORE_FONTCONFIG_DELEGATE
#define MAGICKCORE_FONTCONFIG_DELEGATE 1
#endif
/* Define if you have FlashPIX library */
/* #undef FPX_DELEGATE */
/* Define if you have FREETYPE library */
#ifndef MAGICKCORE_FREETYPE_DELEGATE
#define MAGICKCORE_FREETYPE_DELEGATE 1
#endif
/* Define if you have Ghostscript library or framework */
#ifndef MAGICKCORE_GS_DELEGATE
#define MAGICKCORE_GS_DELEGATE 1
#endif
/* Define if you have GVC library */
#ifndef MAGICKCORE_GVC_DELEGATE
#define MAGICKCORE_GVC_DELEGATE 1
#endif
/* Define to 1 if you have the `acosh' function. */
#ifndef MAGICKCORE_HAVE_ACOSH
#define MAGICKCORE_HAVE_ACOSH 1
#endif
/* Define to 1 if you have the `aligned_malloc' function. */
/* #undef HAVE_ALIGNED_MALLOC */
/* Define to 1 if you have the <arm/limits.h> header file. */
/* #undef HAVE_ARM_LIMITS_H */
/* Define to 1 if you have the <arpa/inet.h> header file. */
#ifndef MAGICKCORE_HAVE_ARPA_INET_H
#define MAGICKCORE_HAVE_ARPA_INET_H 1
#endif
/* Define to 1 if you have the `asinh' function. */
#ifndef MAGICKCORE_HAVE_ASINH
#define MAGICKCORE_HAVE_ASINH 1
#endif
/* Define to 1 if you have the `atanh' function. */
#ifndef MAGICKCORE_HAVE_ATANH
#define MAGICKCORE_HAVE_ATANH 1
#endif
/* Define to 1 if you have the `atexit' function. */
#ifndef MAGICKCORE_HAVE_ATEXIT
#define MAGICKCORE_HAVE_ATEXIT 1
#endif
/* Define to 1 if you have the `atoll' function. */
#ifndef MAGICKCORE_HAVE_ATOLL
#define MAGICKCORE_HAVE_ATOLL 1
#endif
/* define if bool is a built-in type */
#ifndef MAGICKCORE_HAVE_BOOL
#define MAGICKCORE_HAVE_BOOL /**/
#endif
/* Define to 1 if you have the `cabs' function. */
#ifndef MAGICKCORE_HAVE_CABS
#define MAGICKCORE_HAVE_CABS 1
#endif
/* Define to 1 if you have the `carg' function. */
#ifndef MAGICKCORE_HAVE_CARG
#define MAGICKCORE_HAVE_CARG 1
#endif
/* Define to 1 if you have the `cimag' function. */
#ifndef MAGICKCORE_HAVE_CIMAG
#define MAGICKCORE_HAVE_CIMAG 1
#endif
/* Define to 1 if you have the `clock' function. */
#ifndef MAGICKCORE_HAVE_CLOCK
#define MAGICKCORE_HAVE_CLOCK 1
#endif
/* Define to 1 if you have the `clock_getres' function. */
#ifndef MAGICKCORE_HAVE_CLOCK_GETRES
#define MAGICKCORE_HAVE_CLOCK_GETRES 1
#endif
/* Define to 1 if you have the `clock_gettime' function. */
#ifndef MAGICKCORE_HAVE_CLOCK_GETTIME
#define MAGICKCORE_HAVE_CLOCK_GETTIME 1
#endif
/* Define to 1 if clock_gettime supports CLOCK_REALTIME. */
#ifndef MAGICKCORE_HAVE_CLOCK_REALTIME
#define MAGICKCORE_HAVE_CLOCK_REALTIME 1
#endif
/* Define to 1 if you have the <CL/cl.h> header file. */
/* #undef HAVE_CL_CL_H */
/* Define to 1 if you have the <complex.h> header file. */
#ifndef MAGICKCORE_HAVE_COMPLEX_H
#define MAGICKCORE_HAVE_COMPLEX_H 1
#endif
/* Define to 1 if you have the `creal' function. */
#ifndef MAGICKCORE_HAVE_CREAL
#define MAGICKCORE_HAVE_CREAL 1
#endif
/* Define to 1 if you have the `ctime_r' function. */
#ifndef MAGICKCORE_HAVE_CTIME_R
#define MAGICKCORE_HAVE_CTIME_R 1
#endif
/* Define to 1 if you have the declaration of `pread', and to 0 if you don't.
*/
#ifndef MAGICKCORE_HAVE_DECL_PREAD
#define MAGICKCORE_HAVE_DECL_PREAD 1
#endif
/* Define to 1 if you have the declaration of `pwrite', and to 0 if you don't.
*/
#ifndef MAGICKCORE_HAVE_DECL_PWRITE
#define MAGICKCORE_HAVE_DECL_PWRITE 1
#endif
/* Define to 1 if you have the declaration of `strerror_r', and to 0 if you
don't. */
#ifndef MAGICKCORE_HAVE_DECL_STRERROR_R
#define MAGICKCORE_HAVE_DECL_STRERROR_R 1
#endif
/* Define to 1 if you have the declaration of `strlcpy', and to 0 if you
don't. */
#ifndef MAGICKCORE_HAVE_DECL_STRLCPY
#define MAGICKCORE_HAVE_DECL_STRLCPY 0
#endif
/* Define to 1 if you have the declaration of `tzname', and to 0 if you don't.
*/
/* #undef HAVE_DECL_TZNAME */
/* Define to 1 if you have the declaration of `vsnprintf', and to 0 if you
don't. */
#ifndef MAGICKCORE_HAVE_DECL_VSNPRINTF
#define MAGICKCORE_HAVE_DECL_VSNPRINTF 1
#endif
/* Define to 1 if you have the `directio' function. */
/* #undef HAVE_DIRECTIO */
/* Define to 1 if you have the <dirent.h> header file, and it defines `DIR'.
*/
#ifndef MAGICKCORE_HAVE_DIRENT_H
#define MAGICKCORE_HAVE_DIRENT_H 1
#endif
/* Define to 1 if you have the <dlfcn.h> header file. */
#ifndef MAGICKCORE_HAVE_DLFCN_H
#define MAGICKCORE_HAVE_DLFCN_H 1
#endif
/* Define to 1 if you have the `erf' function. */
#ifndef MAGICKCORE_HAVE_ERF
#define MAGICKCORE_HAVE_ERF 1
#endif
/* Define to 1 if you have the <errno.h> header file. */
#ifndef MAGICKCORE_HAVE_ERRNO_H
#define MAGICKCORE_HAVE_ERRNO_H 1
#endif
/* Define to 1 if you have the `execvp' function. */
#ifndef MAGICKCORE_HAVE_EXECVP
#define MAGICKCORE_HAVE_EXECVP 1
#endif
/* Define to 1 if you have the `fchmod' function. */
#ifndef MAGICKCORE_HAVE_FCHMOD
#define MAGICKCORE_HAVE_FCHMOD 1
#endif
/* Define to 1 if you have the <fcntl.h> header file. */
#ifndef MAGICKCORE_HAVE_FCNTL_H
#define MAGICKCORE_HAVE_FCNTL_H 1
#endif
/* Define to 1 if you have the <float.h> header file. */
#ifndef MAGICKCORE_HAVE_FLOAT_H
#define MAGICKCORE_HAVE_FLOAT_H 1
#endif
/* Define to 1 if you have the `floor' function. */
#ifndef MAGICKCORE_HAVE_FLOOR
#define MAGICKCORE_HAVE_FLOOR 1
#endif
/* Define to 1 if you have the `fork' function. */
#ifndef MAGICKCORE_HAVE_FORK
#define MAGICKCORE_HAVE_FORK 1
#endif
/* Define to 1 if fseeko (and 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 `getentropy' function. */
#ifndef MAGICKCORE_HAVE_GETENTROPY
#define MAGICKCORE_HAVE_GETENTROPY 1
#endif
/* Define to 1 if you have the `getexecname' function. */
/* #undef HAVE_GETEXECNAME */
/* Define to 1 if you have the `getpagesize' function. */
#ifndef MAGICKCORE_HAVE_GETPAGESIZE
#define MAGICKCORE_HAVE_GETPAGESIZE 1
#endif
/* Define to 1 if you have the `getpid' function. */
#ifndef MAGICKCORE_HAVE_GETPID
#define MAGICKCORE_HAVE_GETPID 1
#endif
/* Define to 1 if you have the `getpwnam_r' function. */
#ifndef MAGICKCORE_HAVE_GETPWNAM_R
#define MAGICKCORE_HAVE_GETPWNAM_R 1
#endif
/* Define to 1 if you have the `getrlimit' function. */
#ifndef MAGICKCORE_HAVE_GETRLIMIT
#define MAGICKCORE_HAVE_GETRLIMIT 1
#endif
/* Define to 1 if you have the `getrusage' function. */
#ifndef MAGICKCORE_HAVE_GETRUSAGE
#define MAGICKCORE_HAVE_GETRUSAGE 1
#endif
/* Define to 1 if you have the `gettimeofday' function. */
#ifndef MAGICKCORE_HAVE_GETTIMEOFDAY
#define MAGICKCORE_HAVE_GETTIMEOFDAY 1
#endif
/* Define to 1 if you have the `gmtime_r' function. */
#ifndef MAGICKCORE_HAVE_GMTIME_R
#define MAGICKCORE_HAVE_GMTIME_R 1
#endif
/* [Compile with hugepage support] */
/* #undef HAVE_HUGEPAGES */
/* Define to 1 if the system has the type `intmax_t'. */
#ifndef MAGICKCORE_HAVE_INTMAX_T
#define MAGICKCORE_HAVE_INTMAX_T 1
#endif
/* Define to 1 if the system has the type `intptr_t'. */
#ifndef MAGICKCORE_HAVE_INTPTR_T
#define MAGICKCORE_HAVE_INTPTR_T 1
#endif
/* Define to 1 if you have the <inttypes.h> header file. */
#ifndef MAGICKCORE_HAVE_INTTYPES_H
#define MAGICKCORE_HAVE_INTTYPES_H 1
#endif
/* Define to 1 if you have the `isnan' function. */
#ifndef MAGICKCORE_HAVE_ISNAN
#define MAGICKCORE_HAVE_ISNAN 1
#endif
/* Define to 1 if you have the `j0' function. */
#ifndef MAGICKCORE_HAVE_J0
#define MAGICKCORE_HAVE_J0 1
#endif
/* Define to 1 if you have the `j1' function. */
#ifndef MAGICKCORE_HAVE_J1
#define MAGICKCORE_HAVE_J1 1
#endif
/* Define if you have jemalloc memory allocation library */
/* #undef HAVE_JEMALLOC */
/* Define if you have the <lcms2.h> header file. */
#ifndef MAGICKCORE_HAVE_LCMS2_H
#define MAGICKCORE_HAVE_LCMS2_H 1
#endif
/* Define if you have the <lcms2/lcms2.h> header file. */
/* #undef HAVE_LCMS2_LCMS2_H */
/* Define to 1 if you have the `gcov' library (-lgcov). */
/* #undef HAVE_LIBGCOV */
/* Define to 1 if you have the <limits.h> header file. */
#ifndef MAGICKCORE_HAVE_LIMITS_H
#define MAGICKCORE_HAVE_LIMITS_H 1
#endif
/* Define if you have Linux-compatible sendfile() */
#ifndef MAGICKCORE_HAVE_LINUX_SENDFILE
#define MAGICKCORE_HAVE_LINUX_SENDFILE 1
#endif
/* Define to 1 if you have the <linux/unistd.h> header file. */
#ifndef MAGICKCORE_HAVE_LINUX_UNISTD_H
#define MAGICKCORE_HAVE_LINUX_UNISTD_H 1
#endif
/* Define to 1 if you have the `lltostr' function. */
/* #undef HAVE_LLTOSTR */
/* Define to 1 if you have the <locale.h> header file. */
#ifndef MAGICKCORE_HAVE_LOCALE_H
#define MAGICKCORE_HAVE_LOCALE_H 1
#endif
/* Define to 1 if you have the `localtime_r' function. */
#ifndef MAGICKCORE_HAVE_LOCALTIME_R
#define MAGICKCORE_HAVE_LOCALTIME_R 1
#endif
/* Define to 1 if the system has the type `long long int'. */
#ifndef MAGICKCORE_HAVE_LONG_LONG_INT
#define MAGICKCORE_HAVE_LONG_LONG_INT 1
#endif
/* Define to 1 if you have the `lstat' function. */
#ifndef MAGICKCORE_HAVE_LSTAT
#define MAGICKCORE_HAVE_LSTAT 1
#endif
/* Define to 1 if you have the <machine/param.h> header file. */
/* #undef HAVE_MACHINE_PARAM_H */
/* Define to 1 if you have the <mach-o/dyld.h> header file. */
/* #undef HAVE_MACH_O_DYLD_H */
/* Define to 1 if you have the <malloc.h> header file. */
#ifndef MAGICKCORE_HAVE_MALLOC_H
#define MAGICKCORE_HAVE_MALLOC_H 1
#endif
/* Define to 1 if <wchar.h> declares mbstate_t. */
#ifndef MAGICKCORE_HAVE_MBSTATE_T
#define MAGICKCORE_HAVE_MBSTATE_T 1
#endif
/* Define to 1 if you have the `memmove' function. */
#ifndef MAGICKCORE_HAVE_MEMMOVE
#define MAGICKCORE_HAVE_MEMMOVE 1
#endif
/* Define to 1 if you have the `memset' function. */
#ifndef MAGICKCORE_HAVE_MEMSET
#define MAGICKCORE_HAVE_MEMSET 1
#endif
/* Define to 1 if you have the <minix/config.h> header file. */
/* #undef HAVE_MINIX_CONFIG_H */
/* Define to 1 if you have the `mkdir' function. */
#ifndef MAGICKCORE_HAVE_MKDIR
#define MAGICKCORE_HAVE_MKDIR 1
#endif
/* Define to 1 if you have the `mkstemp' function. */
#ifndef MAGICKCORE_HAVE_MKSTEMP
#define MAGICKCORE_HAVE_MKSTEMP 1
#endif
/* Define to 1 if you have a working `mmap' system call. */
#ifndef MAGICKCORE_HAVE_MMAP
#define MAGICKCORE_HAVE_MMAP 1
#endif
/* Define if you have the mtmalloc memory allocation library */
/* #undef HAVE_MTMALLOC */
/* Define to 1 if you have the `munmap' function. */
#ifndef MAGICKCORE_HAVE_MUNMAP
#define MAGICKCORE_HAVE_MUNMAP 1
#endif
/* define if the compiler implements namespaces */
#ifndef MAGICKCORE_HAVE_NAMESPACES
#define MAGICKCORE_HAVE_NAMESPACES /**/
#endif
/* Define if g++ supports namespace std. */
#ifndef MAGICKCORE_HAVE_NAMESPACE_STD
#define MAGICKCORE_HAVE_NAMESPACE_STD /**/
#endif
/* Define to 1 if you have the `nanosleep' function. */
#ifndef MAGICKCORE_HAVE_NANOSLEEP
#define MAGICKCORE_HAVE_NANOSLEEP 1
#endif
/* Define to 1 if you have the <ndir.h> header file, and it defines `DIR'. */
/* #undef HAVE_NDIR_H */
/* Define to 1 if you have the <netdb.h> header file. */
#ifndef MAGICKCORE_HAVE_NETDB_H
#define MAGICKCORE_HAVE_NETDB_H 1
#endif
/* Define to 1 if you have the <netinet/in.h> header file. */
#ifndef MAGICKCORE_HAVE_NETINET_IN_H
#define MAGICKCORE_HAVE_NETINET_IN_H 1
#endif
/* Define to 1 if you have the `newlocale' function. */
#ifndef MAGICKCORE_HAVE_NEWLOCALE
#define MAGICKCORE_HAVE_NEWLOCALE 1
#endif
/* Define to 1 if you have the <OpenCL/cl.h> header file. */
/* #undef HAVE_OPENCL_CL_H */
/* Define to 1 if you have the <OS.h> header file. */
/* #undef HAVE_OS_H */
/* Define to 1 if you have the `pclose' function. */
#ifndef MAGICKCORE_HAVE_PCLOSE
#define MAGICKCORE_HAVE_PCLOSE 1
#endif
/* Define to 1 if you have the `poll' function. */
#ifndef MAGICKCORE_HAVE_POLL
#define MAGICKCORE_HAVE_POLL 1
#endif
/* Define to 1 if you have the `popen' function. */
#ifndef MAGICKCORE_HAVE_POPEN
#define MAGICKCORE_HAVE_POPEN 1
#endif
/* Define to 1 if you have the `posix_fadvise' function. */
#ifndef MAGICKCORE_HAVE_POSIX_FADVISE
#define MAGICKCORE_HAVE_POSIX_FADVISE 1
#endif
/* Define to 1 if you have the `posix_fallocate' function. */
#ifndef MAGICKCORE_HAVE_POSIX_FALLOCATE
#define MAGICKCORE_HAVE_POSIX_FALLOCATE 1
#endif
/* Define to 1 if you have the `posix_madvise' function. */
#ifndef MAGICKCORE_HAVE_POSIX_MADVISE
#define MAGICKCORE_HAVE_POSIX_MADVISE 1
#endif
/* Define to 1 if you have the `posix_memalign' function. */
#ifndef MAGICKCORE_HAVE_POSIX_MEMALIGN
#define MAGICKCORE_HAVE_POSIX_MEMALIGN 1
#endif
/* Define to 1 if you have the `posix_spawnp' function. */
#ifndef MAGICKCORE_HAVE_POSIX_SPAWNP
#define MAGICKCORE_HAVE_POSIX_SPAWNP 1
#endif
/* Define to 1 if you have the `pow' function. */
#ifndef MAGICKCORE_HAVE_POW
#define MAGICKCORE_HAVE_POW 1
#endif
/* Define to 1 if you have the `pread' function. */
#ifndef MAGICKCORE_HAVE_PREAD
#define MAGICKCORE_HAVE_PREAD 1
#endif
/* Define to 1 if you have the <process.h> header file. */
/* #undef HAVE_PROCESS_H */
/* Define if you have POSIX threads libraries and header files. */
#ifndef MAGICKCORE_HAVE_PTHREAD
#define MAGICKCORE_HAVE_PTHREAD 1
#endif
/* Have PTHREAD_PRIO_INHERIT. */
#ifndef MAGICKCORE_HAVE_PTHREAD_PRIO_INHERIT
#define MAGICKCORE_HAVE_PTHREAD_PRIO_INHERIT 1
#endif
/* Define to 1 if you have the `putenv' function. */
#ifndef MAGICKCORE_HAVE_PUTENV
#define MAGICKCORE_HAVE_PUTENV 1
#endif
/* Define to 1 if you have the `pwrite' function. */
#ifndef MAGICKCORE_HAVE_PWRITE
#define MAGICKCORE_HAVE_PWRITE 1
#endif
/* Define to 1 if you have the `qsort_r' function. */
#ifndef MAGICKCORE_HAVE_QSORT_R
#define MAGICKCORE_HAVE_QSORT_R 1
#endif
/* Define to 1 if you have the `raise' function. */
#ifndef MAGICKCORE_HAVE_RAISE
#define MAGICKCORE_HAVE_RAISE 1
#endif
/* Define to 1 if you have the `rand_r' function. */
#ifndef MAGICKCORE_HAVE_RAND_R
#define MAGICKCORE_HAVE_RAND_R 1
#endif
/* Define to 1 if you have the `readlink' function. */
#ifndef MAGICKCORE_HAVE_READLINK
#define MAGICKCORE_HAVE_READLINK 1
#endif
/* Define to 1 if you have the `realpath' function. */
#ifndef MAGICKCORE_HAVE_REALPATH
#define MAGICKCORE_HAVE_REALPATH 1
#endif
/* Define to 1 if you have the `seekdir' function. */
#ifndef MAGICKCORE_HAVE_SEEKDIR
#define MAGICKCORE_HAVE_SEEKDIR 1
#endif
/* Define to 1 if you have the `select' function. */
#ifndef MAGICKCORE_HAVE_SELECT
#define MAGICKCORE_HAVE_SELECT 1
#endif
/* Define to 1 if you have the `sendfile' function. */
#ifndef MAGICKCORE_HAVE_SENDFILE
#define MAGICKCORE_HAVE_SENDFILE 1
#endif
/* Define to 1 if you have the `setlocale' function. */
#ifndef MAGICKCORE_HAVE_SETLOCALE
#define MAGICKCORE_HAVE_SETLOCALE 1
#endif
/* Define to 1 if you have the `setvbuf' function. */
#ifndef MAGICKCORE_HAVE_SETVBUF
#define MAGICKCORE_HAVE_SETVBUF 1
#endif
/* X11 server supports shape extension */
#ifndef MAGICKCORE_HAVE_SHAPE
#define MAGICKCORE_HAVE_SHAPE 1
#endif
/* X11 server supports shared memory extension */
#ifndef MAGICKCORE_HAVE_SHARED_MEMORY
#define MAGICKCORE_HAVE_SHARED_MEMORY 1
#endif
/* Define to 1 if you have the `sigaction' function. */
#ifndef MAGICKCORE_HAVE_SIGACTION
#define MAGICKCORE_HAVE_SIGACTION 1
#endif
/* Define to 1 if you have the `sigemptyset' function. */
#ifndef MAGICKCORE_HAVE_SIGEMPTYSET
#define MAGICKCORE_HAVE_SIGEMPTYSET 1
#endif
/* Define to 1 if you have the `socket' function. */
#ifndef MAGICKCORE_HAVE_SOCKET
#define MAGICKCORE_HAVE_SOCKET 1
#endif
/* Define to 1 if you have the `spawnvp' function. */
/* #undef HAVE_SPAWNVP */
/* Define to 1 if you have the `sqrt' function. */
#ifndef MAGICKCORE_HAVE_SQRT
#define MAGICKCORE_HAVE_SQRT 1
#endif
/* Define to 1 if you have the `stat' function. */
#ifndef MAGICKCORE_HAVE_STAT
#define MAGICKCORE_HAVE_STAT 1
#endif
/* Define to 1 if you have the <stdarg.h> header file. */
#ifndef MAGICKCORE_HAVE_STDARG_H
#define MAGICKCORE_HAVE_STDARG_H 1
#endif
/* Define to 1 if stdbool.h conforms to C99. */
#ifndef MAGICKCORE_HAVE_STDBOOL_H
#define MAGICKCORE_HAVE_STDBOOL_H 1
#endif
/* Define to 1 if you have the <stddef.h> header file. */
#ifndef MAGICKCORE_HAVE_STDDEF_H
#define MAGICKCORE_HAVE_STDDEF_H 1
#endif
/* Define to 1 if you have the <stdint.h> header file. */
#ifndef MAGICKCORE_HAVE_STDINT_H
#define MAGICKCORE_HAVE_STDINT_H 1
#endif
/* Define to 1 if you have the <stdio.h> header file. */
/* #undef HAVE_STDIO_H */
/* Define to 1 if you have the <stdlib.h> header file. */
#ifndef MAGICKCORE_HAVE_STDLIB_H
#define MAGICKCORE_HAVE_STDLIB_H 1
#endif
/* Define to 1 if you have the `strcasecmp' function. */
#ifndef MAGICKCORE_HAVE_STRCASECMP
#define MAGICKCORE_HAVE_STRCASECMP 1
#endif
/* Define to 1 if you have the `strcasestr' function. */
#ifndef MAGICKCORE_HAVE_STRCASESTR
#define MAGICKCORE_HAVE_STRCASESTR 1
#endif
/* Define to 1 if you have the `strchr' function. */
#ifndef MAGICKCORE_HAVE_STRCHR
#define MAGICKCORE_HAVE_STRCHR 1
#endif
/* Define to 1 if you have the `strcspn' function. */
#ifndef MAGICKCORE_HAVE_STRCSPN
#define MAGICKCORE_HAVE_STRCSPN 1
#endif
/* Define to 1 if you have the `strdup' function. */
#ifndef MAGICKCORE_HAVE_STRDUP
#define MAGICKCORE_HAVE_STRDUP 1
#endif
/* Define to 1 if you have the `strerror' function. */
#ifndef MAGICKCORE_HAVE_STRERROR
#define MAGICKCORE_HAVE_STRERROR 1
#endif
/* Define if you have `strerror_r'. */
#ifndef MAGICKCORE_HAVE_STRERROR_R
#define MAGICKCORE_HAVE_STRERROR_R 1
#endif
/* Define to 1 if cpp supports the ANSI # stringizing operator. */
#ifndef MAGICKCORE_HAVE_STRINGIZE
#define MAGICKCORE_HAVE_STRINGIZE 1
#endif
/* Define to 1 if you have the <strings.h> header file. */
#ifndef MAGICKCORE_HAVE_STRINGS_H
#define MAGICKCORE_HAVE_STRINGS_H 1
#endif
/* Define to 1 if you have the <string.h> header file. */
#ifndef MAGICKCORE_HAVE_STRING_H
#define MAGICKCORE_HAVE_STRING_H 1
#endif
/* Define to 1 if you have the `strlcat' function. */
/* #undef HAVE_STRLCAT */
/* Define to 1 if you have the `strlcpy' function. */
/* #undef HAVE_STRLCPY */
/* Define to 1 if you have the `strncasecmp' function. */
#ifndef MAGICKCORE_HAVE_STRNCASECMP
#define MAGICKCORE_HAVE_STRNCASECMP 1
#endif
/* Define to 1 if you have the `strpbrk' function. */
#ifndef MAGICKCORE_HAVE_STRPBRK
#define MAGICKCORE_HAVE_STRPBRK 1
#endif
/* Define to 1 if you have the `strrchr' function. */
#ifndef MAGICKCORE_HAVE_STRRCHR
#define MAGICKCORE_HAVE_STRRCHR 1
#endif
/* Define to 1 if you have the `strspn' function. */
#ifndef MAGICKCORE_HAVE_STRSPN
#define MAGICKCORE_HAVE_STRSPN 1
#endif
/* Define to 1 if you have the `strstr' function. */
#ifndef MAGICKCORE_HAVE_STRSTR
#define MAGICKCORE_HAVE_STRSTR 1
#endif
/* Define to 1 if you have the `strtod' function. */
#ifndef MAGICKCORE_HAVE_STRTOD
#define MAGICKCORE_HAVE_STRTOD 1
#endif
/* Define to 1 if you have the `strtod_l' function. */
#ifndef MAGICKCORE_HAVE_STRTOD_L
#define MAGICKCORE_HAVE_STRTOD_L 1
#endif
/* Define to 1 if you have the `strtol' function. */
#ifndef MAGICKCORE_HAVE_STRTOL
#define MAGICKCORE_HAVE_STRTOL 1
#endif
/* Define to 1 if you have the `strtoul' function. */
#ifndef MAGICKCORE_HAVE_STRTOUL
#define MAGICKCORE_HAVE_STRTOUL 1
#endif
/* Define to 1 if `tm_zone' is a member of `struct tm'. */
#ifndef MAGICKCORE_HAVE_STRUCT_TM_TM_ZONE
#define MAGICKCORE_HAVE_STRUCT_TM_TM_ZONE 1
#endif
/* Define to 1 if you have the <sun_prefetch.h> header file. */
/* #undef HAVE_SUN_PREFETCH_H */
/* Define to 1 if you have the `symlink' function. */
#ifndef MAGICKCORE_HAVE_SYMLINK
#define MAGICKCORE_HAVE_SYMLINK 1
#endif
/* Define to 1 if you have the `sysconf' function. */
#ifndef MAGICKCORE_HAVE_SYSCONF
#define MAGICKCORE_HAVE_SYSCONF 1
#endif
/* Define to 1 if you have the `system' function. */
#ifndef MAGICKCORE_HAVE_SYSTEM
#define MAGICKCORE_HAVE_SYSTEM 1
#endif
/* Define to 1 if you have the <sys/dir.h> header file, and it defines `DIR'.
*/
/* #undef HAVE_SYS_DIR_H */
/* Define to 1 if you have the <sys/ipc.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_IPC_H
#define MAGICKCORE_HAVE_SYS_IPC_H 1
#endif
/* Define to 1 if you have the <sys/mman.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_MMAN_H
#define MAGICKCORE_HAVE_SYS_MMAN_H 1
#endif
/* Define to 1 if you have the <sys/ndir.h> header file, and it defines `DIR'.
*/
/* #undef HAVE_SYS_NDIR_H */
/* Define to 1 if you have the <sys/param.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_PARAM_H
#define MAGICKCORE_HAVE_SYS_PARAM_H 1
#endif
/* Define to 1 if you have the <sys/resource.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_RESOURCE_H
#define MAGICKCORE_HAVE_SYS_RESOURCE_H 1
#endif
/* Define to 1 if you have the <sys/sendfile.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_SENDFILE_H
#define MAGICKCORE_HAVE_SYS_SENDFILE_H 1
#endif
/* Define to 1 if you have the <sys/socket.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_SOCKET_H
#define MAGICKCORE_HAVE_SYS_SOCKET_H 1
#endif
/* Define to 1 if you have the <sys/stat.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_STAT_H
#define MAGICKCORE_HAVE_SYS_STAT_H 1
#endif
/* Define to 1 if you have the <sys/syslimits.h> header file. */
/* #undef HAVE_SYS_SYSLIMITS_H */
/* Define to 1 if you have the <sys/times.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_TIMES_H
#define MAGICKCORE_HAVE_SYS_TIMES_H 1
#endif
/* Define to 1 if you have the <sys/time.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_TIME_H
#define MAGICKCORE_HAVE_SYS_TIME_H 1
#endif
/* Define to 1 if you have the <sys/types.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_TYPES_H
#define MAGICKCORE_HAVE_SYS_TYPES_H 1
#endif
/* Define to 1 if you have the <sys/uio.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_UIO_H
#define MAGICKCORE_HAVE_SYS_UIO_H 1
#endif
/* Define to 1 if you have the <sys/wait.h> header file. */
#ifndef MAGICKCORE_HAVE_SYS_WAIT_H
#define MAGICKCORE_HAVE_SYS_WAIT_H 1
#endif
/* Define if you have the tcmalloc memory allocation library */
/* #undef HAVE_TCMALLOC */
/* Define to 1 if you have the `telldir' function. */
#ifndef MAGICKCORE_HAVE_TELLDIR
#define MAGICKCORE_HAVE_TELLDIR 1
#endif
/* Define to 1 if you have the `tempnam' function. */
#ifndef MAGICKCORE_HAVE_TEMPNAM
#define MAGICKCORE_HAVE_TEMPNAM 1
#endif
/* Define to 1 if you have the <tiffconf.h> header file. */
#ifndef MAGICKCORE_HAVE_TIFFCONF_H
#define MAGICKCORE_HAVE_TIFFCONF_H 1
#endif
/* Define to 1 if you have the `TIFFIsBigEndian' function. */
#ifndef MAGICKCORE_HAVE_TIFFISBIGENDIAN
#define MAGICKCORE_HAVE_TIFFISBIGENDIAN 1
#endif
/* Define to 1 if you have the `TIFFIsCODECConfigured' function. */
#ifndef MAGICKCORE_HAVE_TIFFISCODECCONFIGURED
#define MAGICKCORE_HAVE_TIFFISCODECCONFIGURED 1
#endif
/* Define to 1 if you have the `TIFFMergeFieldInfo' function. */
#ifndef MAGICKCORE_HAVE_TIFFMERGEFIELDINFO
#define MAGICKCORE_HAVE_TIFFMERGEFIELDINFO 1
#endif
/* Define to 1 if you have the `TIFFReadEXIFDirectory' function. */
#ifndef MAGICKCORE_HAVE_TIFFREADEXIFDIRECTORY
#define MAGICKCORE_HAVE_TIFFREADEXIFDIRECTORY 1
#endif
/* Define to 1 if you have the `TIFFReadGPSDirectory' function. */
/* #undef HAVE_TIFFREADGPSDIRECTORY */
/* Define to 1 if you have the `TIFFSetErrorHandlerExt' function. */
#ifndef MAGICKCORE_HAVE_TIFFSETERRORHANDLEREXT
#define MAGICKCORE_HAVE_TIFFSETERRORHANDLEREXT 1
#endif
/* Define to 1 if you have the `TIFFSetTagExtender' function. */
#ifndef MAGICKCORE_HAVE_TIFFSETTAGEXTENDER
#define MAGICKCORE_HAVE_TIFFSETTAGEXTENDER 1
#endif
/* Define to 1 if you have the `TIFFSetWarningHandlerExt' function. */
#ifndef MAGICKCORE_HAVE_TIFFSETWARNINGHANDLEREXT
#define MAGICKCORE_HAVE_TIFFSETWARNINGHANDLEREXT 1
#endif
/* Define to 1 if you have the `TIFFSwabArrayOfTriples' function. */
#ifndef MAGICKCORE_HAVE_TIFFSWABARRAYOFTRIPLES
#define MAGICKCORE_HAVE_TIFFSWABARRAYOFTRIPLES 1
#endif
/* Define to 1 if you have the `times' function. */
#ifndef MAGICKCORE_HAVE_TIMES
#define MAGICKCORE_HAVE_TIMES 1
#endif
/* Define to 1 if your `struct tm' has `tm_zone'. Deprecated, use
`HAVE_STRUCT_TM_TM_ZONE' instead. */
#ifndef MAGICKCORE_HAVE_TM_ZONE
#define MAGICKCORE_HAVE_TM_ZONE 1
#endif
/* Define to 1 if you don't have `tm_zone' but do have the external array
`tzname'. */
/* #undef HAVE_TZNAME */
/* Define to 1 if the system has the type `uintmax_t'. */
#ifndef MAGICKCORE_HAVE_UINTMAX_T
#define MAGICKCORE_HAVE_UINTMAX_T 1
#endif
/* Define to 1 if the system has the type `uintptr_t'. */
#ifndef MAGICKCORE_HAVE_UINTPTR_T
#define MAGICKCORE_HAVE_UINTPTR_T 1
#endif
/* Define to 1 if you have the `ulltostr' function. */
/* #undef HAVE_ULLTOSTR */
/* Define if you have umem memory allocation library */
/* #undef HAVE_UMEM */
/* Define to 1 if you have the <unistd.h> header file. */
#ifndef MAGICKCORE_HAVE_UNISTD_H
#define MAGICKCORE_HAVE_UNISTD_H 1
#endif
/* Define to 1 if the system has the type `unsigned long long int'. */
#ifndef MAGICKCORE_HAVE_UNSIGNED_LONG_LONG_INT
#define MAGICKCORE_HAVE_UNSIGNED_LONG_LONG_INT 1
#endif
/* Define to 1 if you have the `uselocale' function. */
#ifndef MAGICKCORE_HAVE_USELOCALE
#define MAGICKCORE_HAVE_USELOCALE 1
#endif
/* Define to 1 if you have the `usleep' function. */
#ifndef MAGICKCORE_HAVE_USLEEP
#define MAGICKCORE_HAVE_USLEEP 1
#endif
/* Define to 1 if you have the `utime' function. */
#ifndef MAGICKCORE_HAVE_UTIME
#define MAGICKCORE_HAVE_UTIME 1
#endif
/* Define to 1 if you have the <utime.h> header file. */
#ifndef MAGICKCORE_HAVE_UTIME_H
#define MAGICKCORE_HAVE_UTIME_H 1
#endif
/* Define to 1 if you have the `vfprintf' function. */
#ifndef MAGICKCORE_HAVE_VFPRINTF
#define MAGICKCORE_HAVE_VFPRINTF 1
#endif
/* Define to 1 if you have the `vfprintf_l' function. */
/* #undef HAVE_VFPRINTF_L */
/* Define to 1 if you have the `vsnprintf' function. */
#ifndef MAGICKCORE_HAVE_VSNPRINTF
#define MAGICKCORE_HAVE_VSNPRINTF 1
#endif
/* Define to 1 if you have the `vsnprintf_l' function. */
/* #undef HAVE_VSNPRINTF_L */
/* Define to 1 if you have the `vsprintf' function. */
#ifndef MAGICKCORE_HAVE_VSPRINTF
#define MAGICKCORE_HAVE_VSPRINTF 1
#endif
/* Define to 1 if you have the `waitpid' function. */
#ifndef MAGICKCORE_HAVE_WAITPID
#define MAGICKCORE_HAVE_WAITPID 1
#endif
/* Define to 1 if you have the <wchar.h> header file. */
#ifndef MAGICKCORE_HAVE_WCHAR_H
#define MAGICKCORE_HAVE_WCHAR_H 1
#endif
/* Define to 1 if you have the <xlocale.h> header file. */
/* #undef HAVE_XLOCALE_H */
/* Define to 1 if you have the `_aligned_malloc' function. */
/* #undef HAVE__ALIGNED_MALLOC */
/* Define to 1 if the system has the type `_Bool'. */
#ifndef MAGICKCORE_HAVE__BOOL
#define MAGICKCORE_HAVE__BOOL 1
#endif
/* Define to 1 if you have the `_exit' function. */
#ifndef MAGICKCORE_HAVE__EXIT
#define MAGICKCORE_HAVE__EXIT 1
#endif
/* Define to 1 if you have the `_NSGetExecutablePath' function. */
/* #undef HAVE__NSGETEXECUTABLEPATH */
/* Define to 1 if you have the `_pclose' function. */
/* #undef HAVE__PCLOSE */
/* Define to 1 if you have the `_popen' function. */
/* #undef HAVE__POPEN */
/* Define to 1 if you have the `_wfopen' function. */
/* #undef HAVE__WFOPEN */
/* Define to 1 if you have the `_wstat' function. */
/* #undef HAVE__WSTAT */
/* define if your compiler has __attribute__ */
#ifndef MAGICKCORE_HAVE___ATTRIBUTE__
#define MAGICKCORE_HAVE___ATTRIBUTE__ 1
#endif
/* Whether hdri is enabled or not */
#ifndef MAGICKCORE_HDRI_ENABLE_OBSOLETE_IN_H
#define MAGICKCORE_HDRI_ENABLE_OBSOLETE_IN_H 0
#endif
/* Define if you have libheif library */
/* #undef HEIC_DELEGATE */
/* Directory where ImageMagick architecture headers live. */
#ifndef MAGICKCORE_INCLUDEARCH_PATH
#define MAGICKCORE_INCLUDEARCH_PATH "/usr/include/ImageMagick-6/"
#endif
/* Directory where ImageMagick headers live. */
#ifndef MAGICKCORE_INCLUDE_PATH
#define MAGICKCORE_INCLUDE_PATH "/usr/include/ImageMagick-6/"
#endif
/* ImageMagick is formally installed under prefix */
#ifndef MAGICKCORE_INSTALLED_SUPPORT
#define MAGICKCORE_INSTALLED_SUPPORT 1
#endif
/* Define if you have JBIG library */
#ifndef MAGICKCORE_JBIG_DELEGATE
#define MAGICKCORE_JBIG_DELEGATE 1
#endif
/* Define if you have JPEG library */
#ifndef MAGICKCORE_JPEG_DELEGATE
#define MAGICKCORE_JPEG_DELEGATE 1
#endif
/* Define if you have LCMS library */
#ifndef MAGICKCORE_LCMS_DELEGATE
#define MAGICKCORE_LCMS_DELEGATE 1
#endif
/* Define if you have OPENJP2 library */
#ifndef MAGICKCORE_LIBOPENJP2_DELEGATE
#define MAGICKCORE_LIBOPENJP2_DELEGATE 1
#endif
/* Directory where architecture-dependent files live. */
#ifndef MAGICKCORE_LIBRARY_PATH
#define MAGICKCORE_LIBRARY_PATH "/usr/lib64/ImageMagick-6.9.13/"
#endif
/* Subdirectory of lib where ImageMagick architecture dependent files are
installed. */
#ifndef MAGICKCORE_LIBRARY_RELATIVE_PATH
#define MAGICKCORE_LIBRARY_RELATIVE_PATH "ImageMagick-6.9.13"
#endif
/* Binaries in libraries path base name (will be during install linked to bin)
*/
#ifndef MAGICKCORE_LIB_BIN_BASEDIRNAME
#define MAGICKCORE_LIB_BIN_BASEDIRNAME "bin"
#endif
/* Define if you have LQR library */
/* #undef LQR_DELEGATE */
/* Define if using libltdl to support dynamically loadable modules and OpenCL
*/
#ifndef MAGICKCORE_LTDL_DELEGATE
#define MAGICKCORE_LTDL_DELEGATE 1
#endif
/* Native module suffix */
#ifndef MAGICKCORE_LTDL_MODULE_EXT
#define MAGICKCORE_LTDL_MODULE_EXT ".so"
#endif
/* Define to the sub-directory where libtool stores uninstalled libraries. */
#ifndef MAGICKCORE_LT_OBJDIR
#define MAGICKCORE_LT_OBJDIR ".libs/"
#endif
/* Define if you have LZMA library */
#ifndef MAGICKCORE_LZMA_DELEGATE
#define MAGICKCORE_LZMA_DELEGATE 1
#endif
/* Define to prepend to default font search path. */
/* #undef MAGICK_FONT_PATH */
/* Target Host CPU */
#ifndef MAGICKCORE_MAGICK_TARGET_CPU
#define MAGICKCORE_MAGICK_TARGET_CPU x86_64
#endif
/* Target Host OS */
#ifndef MAGICKCORE_MAGICK_TARGET_OS
#define MAGICKCORE_MAGICK_TARGET_OS linux-gnu
#endif
/* Target Host Vendor */
#ifndef MAGICKCORE_MAGICK_TARGET_VENDOR
#define MAGICKCORE_MAGICK_TARGET_VENDOR redhat
#endif
/* Module directory name without ABI part. */
#ifndef MAGICKCORE_MODULES_BASEDIRNAME
#define MAGICKCORE_MODULES_BASEDIRNAME "modules"
#endif
/* Module directory dirname */
/* #undef MODULES_DIRNAME */
/* Magick API method prefix */
/* #undef NAMESPACE_PREFIX */
/* Magick API method prefix tag */
/* #undef NAMESPACE_PREFIX_TAG */
/* Define to 1 if assertions should be disabled. */
/* #undef NDEBUG */
/* Define if you have OPENEXR library */
#ifndef MAGICKCORE_OPENEXR_DELEGATE
#define MAGICKCORE_OPENEXR_DELEGATE 1
#endif
/* Define to the address where bug reports for this package should be sent. */
#ifndef MAGICKCORE_PACKAGE_BUGREPORT
#define MAGICKCORE_PACKAGE_BUGREPORT "https://github.com/ImageMagick/ImageMagick6/issues"
#endif
/* Define to the full name of this package. */
#ifndef MAGICKCORE_PACKAGE_NAME
#define MAGICKCORE_PACKAGE_NAME "ImageMagick"
#endif
/* Define to the full name and version of this package. */
#ifndef MAGICKCORE_PACKAGE_STRING
#define MAGICKCORE_PACKAGE_STRING "ImageMagick 6.9.13-14"
#endif
/* Define to the one symbol short name of this package. */
#ifndef MAGICKCORE_PACKAGE_TARNAME
#define MAGICKCORE_PACKAGE_TARNAME "ImageMagick"
#endif
/* Define to the home page for this package. */
#ifndef MAGICKCORE_PACKAGE_URL
#define MAGICKCORE_PACKAGE_URL "https://legacy.imagemagick.org"
#endif
/* Define to the version of this package. */
#ifndef MAGICKCORE_PACKAGE_VERSION
#define MAGICKCORE_PACKAGE_VERSION "6.9.13-14"
#endif
/* Define if you have PANGOCAIRO library */
#ifndef MAGICKCORE_PANGOCAIRO_DELEGATE
#define MAGICKCORE_PANGOCAIRO_DELEGATE 1
#endif
/* Define if you have PANGO library */
#ifndef MAGICKCORE_PANGO_DELEGATE
#define MAGICKCORE_PANGO_DELEGATE 1
#endif
/* enable pipes (|) in filenames */
/* #undef PIPES_SUPPORT */
/* Define if you have PNG library */
#ifndef MAGICKCORE_PNG_DELEGATE
#define MAGICKCORE_PNG_DELEGATE 1
#endif
/* Define to necessary symbol if this constant uses a non-standard name on
your system. */
/* #undef PTHREAD_CREATE_JOINABLE */
/* Pixel cache memory threshold (defaults to available memory) */
/* #undef PixelCacheThreshold */
/* Number of bits in a pixel Quantum (8/16/32/64) */
#ifndef MAGICKCORE_QUANTUM_DEPTH_OBSOLETE_IN_H
#define MAGICKCORE_QUANTUM_DEPTH_OBSOLETE_IN_H 16
#endif
/* Define if you have RAQM library */
#ifndef MAGICKCORE_RAQM_DELEGATE
#define MAGICKCORE_RAQM_DELEGATE 1
#endif
/* Define if you have LIBRAW library */
#ifndef MAGICKCORE_RAW_R_DELEGATE
#define MAGICKCORE_RAW_R_DELEGATE 1
#endif
/* Define if you have RSVG library */
#ifndef MAGICKCORE_RSVG_DELEGATE
#define MAGICKCORE_RSVG_DELEGATE 1
#endif
/* Setjmp/longjmp are thread safe */
#ifndef MAGICKCORE_SETJMP_IS_THREAD_SAFE
#define MAGICKCORE_SETJMP_IS_THREAD_SAFE 1
#endif
/* Sharearch directory name without ABI part. */
#ifndef MAGICKCORE_SHAREARCH_BASEDIRNAME
#define MAGICKCORE_SHAREARCH_BASEDIRNAME "config"
#endif
/* Sharearch directory dirname */
/* #undef SHAREARCH_DIRNAME */
/* Directory where architecture-independent configuration files live. */
#ifndef MAGICKCORE_SHARE_PATH
#define MAGICKCORE_SHARE_PATH "/usr/share/ImageMagick-6/"
#endif
/* Subdirectory of lib where architecture-independent configuration files
live. */
#ifndef MAGICKCORE_SHARE_RELATIVE_PATH
#define MAGICKCORE_SHARE_RELATIVE_PATH "ImageMagick-6"
#endif
/* The size of `double', as computed by sizeof. */
#ifndef MAGICKCORE_SIZEOF_DOUBLE
#define MAGICKCORE_SIZEOF_DOUBLE 8
#endif
/* The size of `double_t', as computed by sizeof. */
#ifndef MAGICKCORE_SIZEOF_DOUBLE_T
#define MAGICKCORE_SIZEOF_DOUBLE_T 8
#endif
/* The size of `float', as computed by sizeof. */
#ifndef MAGICKCORE_SIZEOF_FLOAT
#define MAGICKCORE_SIZEOF_FLOAT 4
#endif
/* The size of `float_t', as computed by sizeof. */
#ifndef MAGICKCORE_SIZEOF_FLOAT_T
#define MAGICKCORE_SIZEOF_FLOAT_T 4
#endif
/* The size of `long double', as computed by sizeof. */
#ifndef MAGICKCORE_SIZEOF_LONG_DOUBLE
#define MAGICKCORE_SIZEOF_LONG_DOUBLE 16
#endif
/* The size of `size_t', as computed by sizeof. */
#ifndef MAGICKCORE_SIZEOF_SIZE_T
#define MAGICKCORE_SIZEOF_SIZE_T 8
#endif
/* The size of `unsigned long long', as computed by sizeof. */
#ifndef MAGICKCORE_SIZEOF_UNSIGNED_LONG_LONG
#define MAGICKCORE_SIZEOF_UNSIGNED_LONG_LONG 8
#endif
/* The size of `void *', as computed by sizeof. */
#ifndef MAGICKCORE_SIZEOF_VOID_P
#define MAGICKCORE_SIZEOF_VOID_P 8
#endif
/* Define to 1 if the `S_IS*' macros in <sys/stat.h> do not work properly. */
/* #undef STAT_MACROS_BROKEN */
/* Define to 1 if all of the C90 standard headers exist (not just the ones
required in a freestanding environment). This macro is provided for
backward compatibility; new code need not use it. */
#ifndef MAGICKCORE_STDC_HEADERS
#define MAGICKCORE_STDC_HEADERS 1
#endif
/* Define to 1 if strerror_r returns char *. */
#ifndef MAGICKCORE_STRERROR_R_CHAR_P
#define MAGICKCORE_STRERROR_R_CHAR_P 1
#endif
/* Define if you have POSIX threads libraries and header files. */
#ifndef MAGICKCORE_THREAD_SUPPORT
#define MAGICKCORE_THREAD_SUPPORT 1
#endif
/* Define if you have TIFF library */
#ifndef MAGICKCORE_TIFF_DELEGATE
#define MAGICKCORE_TIFF_DELEGATE 1
#endif
/* Define to 1 if your <sys/time.h> declares `struct tm'. */
/* #undef TM_IN_SYS_TIME */
/* Enable extensions on AIX 3, Interix. */
#ifndef _ALL_SOURCE
# define _ALL_SOURCE 1
#endif
/* Enable general extensions on macOS. */
#ifndef _DARWIN_C_SOURCE
/* # undef _DARWIN_C_SOURCE */
#endif
/* Enable general extensions on Solaris. */
#ifndef __EXTENSIONS__
# define __EXTENSIONS__ 1
#endif
/* Enable GNU extensions on systems that have them. */
#ifndef _GNU_SOURCE
# define _GNU_SOURCE 1
#endif
/* Enable X/Open compliant socket functions that do not require linking
with -lxnet on HP-UX 11.11. */
#ifndef _HPUX_ALT_XOPEN_SOCKET_API
/* # undef _HPUX_ALT_XOPEN_SOCKET_API */
#endif
/* Identify the host operating system as Minix.
This macro does not affect the system headers' behavior.
A future release of Autoconf may stop defining this macro. */
#ifndef _MINIX
/* # undef _MINIX */
#endif
/* Enable general extensions on NetBSD.
Enable NetBSD compatibility extensions on Minix. */
#ifndef _NETBSD_SOURCE
/* # undef _NETBSD_SOURCE */
#endif
/* Enable OpenBSD compatibility extensions on NetBSD.
Oddly enough, this does nothing on OpenBSD. */
#ifndef _OPENBSD_SOURCE
/* # undef _OPENBSD_SOURCE */
#endif
/* Define to 1 if needed for POSIX-compatible behavior. */
#ifndef _POSIX_SOURCE
/* # undef _POSIX_SOURCE */
#endif
/* Define to 2 if needed for POSIX-compatible behavior. */
#ifndef _POSIX_1_SOURCE
/* # undef _POSIX_1_SOURCE */
#endif
/* Enable POSIX-compatible threading on Solaris. */
#ifndef _POSIX_PTHREAD_SEMANTICS
# define _POSIX_PTHREAD_SEMANTICS 1
#endif
/* Enable extensions specified by ISO/IEC TS 18661-5:2014. */
#ifndef __STDC_WANT_IEC_60559_ATTRIBS_EXT__
/* # undef __STDC_WANT_IEC_60559_ATTRIBS_EXT__ */
#endif
/* Enable extensions specified by ISO/IEC TS 18661-1:2014. */
#ifndef __STDC_WANT_IEC_60559_BFP_EXT__
/* # undef __STDC_WANT_IEC_60559_BFP_EXT__ */
#endif
/* Enable extensions specified by ISO/IEC TS 18661-2:2015. */
#ifndef __STDC_WANT_IEC_60559_DFP_EXT__
/* # undef __STDC_WANT_IEC_60559_DFP_EXT__ */
#endif
/* Enable extensions specified by ISO/IEC TS 18661-4:2015. */
#ifndef __STDC_WANT_IEC_60559_FUNCS_EXT__
/* # undef __STDC_WANT_IEC_60559_FUNCS_EXT__ */
#endif
/* Enable extensions specified by ISO/IEC TS 18661-3:2015. */
#ifndef __STDC_WANT_IEC_60559_TYPES_EXT__
/* # undef __STDC_WANT_IEC_60559_TYPES_EXT__ */
#endif
/* Enable extensions specified by ISO/IEC TR 24731-2:2010. */
#ifndef __STDC_WANT_LIB_EXT2__
/* # undef __STDC_WANT_LIB_EXT2__ */
#endif
/* Enable extensions specified by ISO/IEC 24747:2009. */
#ifndef __STDC_WANT_MATH_SPEC_FUNCS__
/* # undef __STDC_WANT_MATH_SPEC_FUNCS__ */
#endif
/* Enable extensions on HP NonStop. */
#ifndef _TANDEM_SOURCE
# define _TANDEM_SOURCE 1
#endif
/* Enable X/Open extensions. Define to 500 only if necessary
to make mbstate_t available. */
#ifndef _XOPEN_SOURCE
/* # undef _XOPEN_SOURCE */
#endif
/* Define if you have WEBPMUX library */
#ifndef MAGICKCORE_WEBPMUX_DELEGATE
#define MAGICKCORE_WEBPMUX_DELEGATE 1
#endif
/* Define if you have WEBP library */
#ifndef MAGICKCORE_WEBP_DELEGATE
#define MAGICKCORE_WEBP_DELEGATE 1
#endif
/* Define to use the Windows GDI32 library */
/* #undef WINGDI32_DELEGATE */
/* Define if using the dmalloc debugging malloc package */
/* #undef WITH_DMALLOC */
/* Define if you have WMF library */
#ifndef MAGICKCORE_WMF_DELEGATE
#define MAGICKCORE_WMF_DELEGATE 1
#endif
/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
significant byte first (like Motorola and SPARC, unlike Intel). */
#if defined AC_APPLE_UNIVERSAL_BUILD
# if defined __BIG_ENDIAN__
# define WORDS_BIGENDIAN 1
# endif
#else
# ifndef WORDS_BIGENDIAN
/* # undef WORDS_BIGENDIAN */
# endif
#endif
/* Location of X11 configure files */
#ifndef MAGICKCORE_X11_CONFIGURE_PATH
#define MAGICKCORE_X11_CONFIGURE_PATH ""
#endif
/* Define if you have X11 library */
#ifndef MAGICKCORE_X11_DELEGATE
#define MAGICKCORE_X11_DELEGATE 1
#endif
/* Define if you have XML library */
#ifndef MAGICKCORE_XML_DELEGATE
#define MAGICKCORE_XML_DELEGATE 1
#endif
/* Define to 1 if the X Window System is missing or not being used. */
/* #undef X_DISPLAY_MISSING */
/* Build self-contained, embeddable, zero-configuration ImageMagick */
/* #undef ZERO_CONFIGURATION_SUPPORT */
/* Define if you have ZLIB library */
#ifndef MAGICKCORE_ZLIB_DELEGATE
#define MAGICKCORE_ZLIB_DELEGATE 1
#endif
/* Define if you have ZSTD library */
#ifndef MAGICKCORE_ZSTD_DELEGATE
#define MAGICKCORE_ZSTD_DELEGATE 1
#endif
/* Number of bits in a file offset, on hosts where this is settable. */
/* #undef _FILE_OFFSET_BITS */
/* enable run-time bounds-checking */
/* #undef _FORTIFY_SOURCE */
/* Define to 1 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 for Solaris 2.5.1 so the uint32_t typedef from <sys/synch.h>,
<pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
#define below would cause a syntax error. */
/* #undef _UINT32_T */
/* Define for Solaris 2.5.1 so the uint64_t typedef from <sys/synch.h>,
<pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
#define below would cause a syntax error. */
/* #undef _UINT64_T */
/* Define for Solaris 2.5.1 so the uint8_t typedef from <sys/synch.h>,
<pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
#define below would cause a syntax error. */
/* #undef _UINT8_T */
/* Define to 1 if type `char' is unsigned and your compiler does not
predefine this macro. */
#ifndef __CHAR_UNSIGNED__
/* # undef __CHAR_UNSIGNED__ */
#endif
/* Define to appropriate substitute 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 <sys/types.h> doesn't define. */
/* #undef gid_t */
/* Define to `__inline__' or `__inline' if that's what the C compiler
calls it, or to nothing if 'inline' is not supported under any name. */
#ifndef __cplusplus
/* #undef inline */
#endif
/* Define to the type of a signed integer type of width exactly 16 bits if
such a type exists and the standard includes do not define it. */
/* #undef int16_t */
/* Define to the type of a signed integer type of width exactly 32 bits if
such a type exists and the standard includes do not define it. */
/* #undef int32_t */
/* Define to the type of a signed integer type of width exactly 64 bits if
such a type exists and the standard includes do not define it. */
/* #undef int64_t */
/* Define to the type of a signed integer type of width exactly 8 bits if such
a type exists and the standard includes do not define it. */
/* #undef int8_t */
/* Define to the widest signed integer type if <stdint.h> and <inttypes.h> do
not define. */
/* #undef intmax_t */
/* Define to the type of a signed integer type wide enough to hold a pointer,
if such a type exists, and if the system does not define it. */
/* #undef intptr_t */
/* Define to a type if <wchar.h> does not define. */
/* #undef mbstate_t */
/* Define to `int' if <sys/types.h> does not define. */
/* #undef mode_t */
/* Define to `long int' if <sys/types.h> does not define. */
/* #undef off_t */
/* Define as a signed integer type capable of holding a process identifier. */
/* #undef pid_t */
/* Define to the equivalent of the C99 'restrict' keyword, or to
nothing if this is not supported. Do not define if restrict is
supported only directly. */
#ifndef _magickcore_restrict
#define _magickcore_restrict __restrict
#endif
/* Work around a bug in older versions of Sun C++, which did not
#define __restrict__ or support _Restrict or __restrict__
even though the corresponding Sun C compiler ended up with
"#define restrict _Restrict" or "#define restrict __restrict__"
in the previous line. This workaround can be removed once
we assume Oracle Developer Studio 12.5 (2016) or later. */
#if defined __SUNPRO_CC && !defined __RESTRICT && !defined __restrict__
# define _Restrict
# define __restrict__
#endif
/* Define to `unsigned int' if <sys/types.h> does not define. */
/* #undef size_t */
/* Define to `int' if <sys/types.h> does not define. */
/* #undef ssize_t */
/* Define to `int' if <sys/types.h> doesn't define. */
/* #undef uid_t */
/* Define to the type of an unsigned integer type of width exactly 16 bits if
such a type exists and the standard includes do not define it. */
/* #undef uint16_t */
/* Define to the type of an unsigned integer type of width exactly 32 bits if
such a type exists and the standard includes do not define it. */
/* #undef uint32_t */
/* Define to the type of an unsigned integer type of width exactly 64 bits if
such a type exists and the standard includes do not define it. */
/* #undef uint64_t */
/* Define to the type of an unsigned integer type of width exactly 8 bits if
such a type exists and the standard includes do not define it. */
/* #undef uint8_t */
/* Define to the widest unsigned integer type if <stdint.h> and <inttypes.h>
do not define. */
/* #undef uintmax_t */
/* Define to the type of an unsigned integer type wide enough to hold a
pointer, if such a type exists, and if the system does not define it. */
/* #undef uintptr_t */
/* Define to empty if the keyword `volatile' does not work. Warning: valid
code using `volatile' can become incorrect without. Disable with care. */
/* #undef volatile */
/* once: _MAGICK_MAGICK_BASECONFIG_H */
#endif
magick/matrix.h 0000644 00000003343 14751151177 0007470 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore matrix methods.
*/
#ifndef MAGICKCORE_MATRIX_H
#define MAGICKCORE_MATRIX_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _MatrixInfo
MatrixInfo;
extern MagickExport double
**AcquireMagickMatrix(const size_t,const size_t),
**RelinquishMagickMatrix(double **,const size_t);
extern MagickExport Image
*MatrixToImage(const MatrixInfo *,ExceptionInfo *);
extern MagickExport MagickBooleanType
GaussJordanElimination(double **,double **,const size_t,const size_t),
GetMatrixElement(const MatrixInfo *,const ssize_t,const ssize_t,void *),
NullMatrix(MatrixInfo *),
SetMatrixElement(const MatrixInfo *,const ssize_t,const ssize_t,const void *);
MagickExport MatrixInfo
*AcquireMatrixInfo(const size_t,const size_t,const size_t,ExceptionInfo *),
*DestroyMatrixInfo(MatrixInfo *);
MagickExport size_t
GetMatrixColumns(const MatrixInfo *),
GetMatrixRows(const MatrixInfo *);
extern MagickExport void
LeastSquaresAddTerms(double **,double **,const double *,const double *,
const size_t,const size_t);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/list.h 0000644 00000004460 14751151177 0007140 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image list methods.
*/
#ifndef MAGICKCORE_LIST_H
#define MAGICKCORE_LIST_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern MagickExport Image
*CloneImageList(const Image *,ExceptionInfo *),
*CloneImages(const Image *,const char *,ExceptionInfo *),
*DestroyImageList(Image *),
*DuplicateImages(Image *,const size_t,const char *,ExceptionInfo *),
*GetFirstImageInList(const Image *) magick_attribute((__pure__)),
*GetImageFromList(const Image *,const ssize_t) magick_attribute((__pure__)),
*GetLastImageInList(const Image *) magick_attribute((__pure__)),
*GetNextImageInList(const Image *) magick_attribute((__pure__)),
*GetPreviousImageInList(const Image *) magick_attribute((__pure__)),
**ImageListToArray(const Image *,ExceptionInfo *),
*NewImageList(void) magick_attribute((__const__)),
*RemoveImageFromList(Image **),
*RemoveLastImageFromList(Image **),
*RemoveFirstImageFromList(Image **),
*SpliceImageIntoList(Image **,const size_t,const Image *),
*SplitImageList(Image *),
*SyncNextImageInList(const Image *);
extern MagickExport size_t
GetImageListLength(const Image *) magick_attribute((__pure__));
extern MagickExport ssize_t
GetImageIndexInList(const Image *) magick_attribute((__pure__));
extern MagickExport void
AppendImageToList(Image **,const Image *),
DeleteImageFromList(Image **),
DeleteImages(Image **,const char *,ExceptionInfo *),
InsertImageInList(Image **,Image *),
PrependImageToList(Image **,Image *),
ReplaceImageInList(Image **,Image *),
ReplaceImageInListReturnLast(Image **,Image *),
ReverseImageList(Image **),
SyncImageList(Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/draw.h 0000644 00000013177 14751151177 0007127 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore drawing methods.
*/
#ifndef MAGICKCORE_DRAW_H
#define MAGICKCORE_DRAW_H
#include "magick/geometry.h"
#include "magick/image.h"
#include "magick/pixel.h"
#include "magick/type.h"
#include "magick/color.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedAlign,
LeftAlign,
CenterAlign,
RightAlign
} AlignType;
typedef enum
{
UndefinedPathUnits,
UserSpace,
UserSpaceOnUse,
ObjectBoundingBox
} ClipPathUnits;
typedef enum
{
UndefinedDecoration,
NoDecoration,
UnderlineDecoration,
OverlineDecoration,
LineThroughDecoration
} DecorationType;
typedef enum
{
UndefinedDirection,
RightToLeftDirection,
LeftToRightDirection,
TopToBottomDirection
} DirectionType;
typedef enum
{
UndefinedRule,
#undef EvenOddRule
EvenOddRule,
NonZeroRule
} FillRule;
typedef enum
{
UndefinedGradient,
LinearGradient,
RadialGradient
} GradientType;
typedef enum
{
UndefinedCap,
ButtCap,
RoundCap,
SquareCap
} LineCap;
typedef enum
{
UndefinedJoin,
MiterJoin,
RoundJoin,
BevelJoin
} LineJoin;
typedef enum
{
UndefinedMethod,
PointMethod,
ReplaceMethod,
FloodfillMethod,
FillToBorderMethod,
ResetMethod
} PaintMethod;
typedef enum
{
UndefinedPrimitive,
PointPrimitive,
LinePrimitive,
RectanglePrimitive,
RoundRectanglePrimitive,
ArcPrimitive,
EllipsePrimitive,
CirclePrimitive,
PolylinePrimitive,
PolygonPrimitive,
BezierPrimitive,
ColorPrimitive,
MattePrimitive,
TextPrimitive,
ImagePrimitive,
PathPrimitive
} PrimitiveType;
typedef enum
{
UndefinedReference,
GradientReference
} ReferenceType;
typedef enum
{
UndefinedSpread,
PadSpread,
ReflectSpread,
RepeatSpread
} SpreadMethod;
typedef struct _PointInfo
{
double
x,
y;
} PointInfo;
typedef struct _StopInfo
{
MagickPixelPacket
color;
MagickRealType
offset;
} StopInfo;
typedef struct _GradientInfo
{
GradientType
type;
RectangleInfo
bounding_box;
SegmentInfo
gradient_vector;
StopInfo
*stops;
size_t
number_stops;
SpreadMethod
spread;
MagickBooleanType
debug;
size_t
signature;
PointInfo
center;
MagickRealType
radius,
angle;
PointInfo
radii;
} GradientInfo;
typedef struct _ElementReference
{
char
*id;
ReferenceType
type;
GradientInfo
gradient;
size_t
signature;
struct _ElementReference
*previous,
*next;
} ElementReference;
typedef struct _DrawInfo
{
char
*primitive,
*geometry;
RectangleInfo
viewbox;
AffineMatrix
affine;
GravityType
gravity;
PixelPacket
fill,
stroke;
double
stroke_width;
GradientInfo
gradient;
Image
*fill_pattern,
*tile,
*stroke_pattern;
MagickBooleanType
stroke_antialias,
text_antialias;
FillRule
fill_rule;
LineCap
linecap;
LineJoin
linejoin;
size_t
miterlimit;
double
dash_offset;
DecorationType
decorate;
CompositeOperator
compose;
char
*text;
size_t
face;
char
*font,
*metrics,
*family;
StyleType
style;
StretchType
stretch;
size_t
weight;
char
*encoding;
double
pointsize;
char
*density;
AlignType
align;
PixelPacket
undercolor,
border_color;
char
*server_name;
double
*dash_pattern;
char
*clip_mask;
SegmentInfo
bounds;
ClipPathUnits
clip_units;
Quantum
opacity;
MagickBooleanType
render;
ElementReference
element_reference;
MagickBooleanType
debug;
size_t
signature;
double
kerning,
interword_spacing,
interline_spacing;
DirectionType
direction;
double
fill_opacity,
stroke_opacity;
MagickBooleanType
clip_path;
Image
*clipping_mask;
ComplianceType
compliance;
Image
*composite_mask;
char
*id;
ImageInfo
*image_info;
} DrawInfo;
typedef struct _PrimitiveInfo
{
PointInfo
point;
size_t
coordinates;
PrimitiveType
primitive;
PaintMethod
method;
char
*text;
MagickBooleanType
closed_subpath;
} PrimitiveInfo;
typedef struct _TypeMetric
{
PointInfo
pixels_per_em;
double
ascent,
descent,
width,
height,
max_advance,
underline_position,
underline_thickness;
SegmentInfo
bounds;
PointInfo
origin;
} TypeMetric;
extern MagickExport DrawInfo
*AcquireDrawInfo(void),
*CloneDrawInfo(const ImageInfo *,const DrawInfo *),
*DestroyDrawInfo(DrawInfo *);
extern MagickExport MagickBooleanType
DrawAffineImage(Image *,const Image *,const AffineMatrix *),
DrawClipPath(Image *,const DrawInfo *,const char *),
DrawGradientImage(Image *,const DrawInfo *),
DrawImage(Image *,const DrawInfo *),
DrawPatternPath(Image *,const DrawInfo *,const char *,Image **),
DrawPrimitive(Image *,const DrawInfo *,const PrimitiveInfo *);
extern MagickExport void
GetAffineMatrix(AffineMatrix *),
GetDrawInfo(const ImageInfo *,DrawInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/compress.h 0000644 00000004035 14751151177 0010016 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image compression/decompression methods.
*/
#ifndef MAGICKCORE_COMPRESS_H
#define MAGICKCORE_COMPRESS_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedCompression,
NoCompression,
BZipCompression,
DXT1Compression,
DXT3Compression,
DXT5Compression,
FaxCompression,
Group4Compression,
JPEGCompression,
JPEG2000Compression, /* ISO/IEC std 15444-1 */
LosslessJPEGCompression,
LZWCompression,
RLECompression,
ZipCompression,
ZipSCompression,
PizCompression,
Pxr24Compression,
B44Compression,
B44ACompression,
LZMACompression, /* Lempel-Ziv-Markov chain algorithm */
JBIG1Compression, /* ISO/IEC std 11544 / ITU-T rec T.82 */
JBIG2Compression, /* ISO/IEC std 14492 / ITU-T rec T.88 */
ZstdCompression,
WebPCompression
} CompressionType;
typedef struct _Ascii85Info
Ascii85Info;
extern MagickExport MagickBooleanType
HuffmanDecodeImage(Image *),
HuffmanEncodeImage(const ImageInfo *,Image *,Image *),
LZWEncodeImage(Image *,const size_t,unsigned char *magick_restrict),
PackbitsEncodeImage(Image *,const size_t,unsigned char *magick_restrict),
ZLIBEncodeImage(Image *,const size_t,unsigned char *magick_restrict);
extern MagickExport void
Ascii85Encode(Image *,const unsigned char),
Ascii85Flush(Image *),
Ascii85Initialize(Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/decorate.h 0000644 00000002350 14751151177 0007747 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image decorate methods.
*/
#ifndef MAGICKCORE_DECORATE_H
#define MAGICKCORE_DECORATE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _FrameInfo
{
size_t
width,
height;
ssize_t
x,
y,
inner_bevel,
outer_bevel;
} FrameInfo;
extern MagickExport Image
*BorderImage(const Image *,const RectangleInfo *,ExceptionInfo *),
*FrameImage(const Image *,const FrameInfo *,ExceptionInfo *);
extern MagickExport MagickBooleanType
RaiseImage(Image *,const RectangleInfo *,const MagickBooleanType);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/ImageMagick.h 0000644 00000001723 14751151177 0010322 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Deprecated as of ImageMagick 6.2.3.
MagickCore Application Programming Interface declarations.
*/
#ifndef MAGICKCORE_IMAGEMAGICK_DEPRECATED_H
#define MAGICKCORE_IMAGEMAGICK_DEPRECATED_H
#include "magick/MagickCore.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/composite.h 0000644 00000006312 14751151177 0010165 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image composite methods.
*/
#ifndef MAGICKCORE_COMPOSITE_H
#define MAGICKCORE_COMPOSITE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UndefinedCompositeOp,
NoCompositeOp,
ModulusAddCompositeOp,
AtopCompositeOp,
BlendCompositeOp,
BumpmapCompositeOp,
ChangeMaskCompositeOp,
ClearCompositeOp,
ColorBurnCompositeOp,
ColorDodgeCompositeOp,
ColorizeCompositeOp,
CopyBlackCompositeOp,
CopyBlueCompositeOp,
CopyCompositeOp,
CopyCyanCompositeOp,
CopyGreenCompositeOp,
CopyMagentaCompositeOp,
CopyOpacityCompositeOp,
CopyRedCompositeOp,
CopyYellowCompositeOp,
DarkenCompositeOp,
DstAtopCompositeOp,
DstCompositeOp,
DstInCompositeOp,
DstOutCompositeOp,
DstOverCompositeOp,
DifferenceCompositeOp,
DisplaceCompositeOp,
DissolveCompositeOp,
ExclusionCompositeOp,
HardLightCompositeOp,
HueCompositeOp,
InCompositeOp,
LightenCompositeOp,
LinearLightCompositeOp,
LuminizeCompositeOp,
MinusDstCompositeOp,
ModulateCompositeOp,
MultiplyCompositeOp,
OutCompositeOp,
OverCompositeOp,
OverlayCompositeOp,
PlusCompositeOp,
ReplaceCompositeOp,
SaturateCompositeOp,
ScreenCompositeOp,
SoftLightCompositeOp,
SrcAtopCompositeOp,
SrcCompositeOp,
SrcInCompositeOp,
SrcOutCompositeOp,
SrcOverCompositeOp,
ModulusSubtractCompositeOp,
ThresholdCompositeOp,
XorCompositeOp,
/* These are new operators, added after the above was last sorted.
* The list should be re-sorted only when a new library version is
* created.
*/
DivideDstCompositeOp,
DistortCompositeOp,
BlurCompositeOp,
PegtopLightCompositeOp,
VividLightCompositeOp,
PinLightCompositeOp,
LinearDodgeCompositeOp,
LinearBurnCompositeOp,
MathematicsCompositeOp,
DivideSrcCompositeOp,
MinusSrcCompositeOp,
DarkenIntensityCompositeOp,
LightenIntensityCompositeOp,
HardMixCompositeOp,
StereoCompositeOp
} CompositeOperator;
/* Deprecated (renamed) Method Names for backward compatibility
* However the CompositeOp value has not changed, just renamed.
*/
#define AddCompositeOp ModulusAddCompositeOp
#define SubtractCompositeOp ModulusSubtractCompositeOp
#define MinusCompositeOp MinusDstCompositeOp
#define DivideCompositeOp DivideDstCompositeOp
extern MagickExport MagickBooleanType
CompositeImage(Image *,const CompositeOperator,const Image *,const ssize_t,
const ssize_t),
CompositeImageChannel(Image *,const ChannelType,const CompositeOperator,
const Image *,const ssize_t,const ssize_t),
TextureImage(Image *,const Image *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/distort.h 0000644 00000005227 14751151177 0007657 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image distortion methods.
*/
#ifndef MAGICKCORE_DISTORT_H
#define MAGICKCORE_DISTORT_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/*
These two enum are linked, with common enumerated values. Both
DistortImages() and SparseColor() often share code to determine functional
coefficients for common methods.
Caution should be taken to ensure that only the common methods contain the
same enumerated value, while all others remain unique across both
enumerations.
*/
typedef enum
{
UndefinedDistortion,
AffineDistortion,
AffineProjectionDistortion,
ScaleRotateTranslateDistortion,
PerspectiveDistortion,
PerspectiveProjectionDistortion,
BilinearForwardDistortion,
BilinearDistortion = BilinearForwardDistortion,
BilinearReverseDistortion,
PolynomialDistortion,
ArcDistortion,
PolarDistortion,
DePolarDistortion,
Cylinder2PlaneDistortion,
Plane2CylinderDistortion,
BarrelDistortion,
BarrelInverseDistortion,
ShepardsDistortion,
ResizeDistortion,
SentinelDistortion
} DistortImageMethod;
typedef enum
{
UndefinedColorInterpolate = UndefinedDistortion,
BarycentricColorInterpolate = AffineDistortion,
BilinearColorInterpolate = BilinearReverseDistortion,
PolynomialColorInterpolate = PolynomialDistortion,
ShepardsColorInterpolate = ShepardsDistortion,
/*
Methods unique to SparseColor().
*/
VoronoiColorInterpolate = SentinelDistortion,
InverseColorInterpolate,
ManhattanColorInterpolate
} SparseColorMethod;
extern MagickExport Image
*AffineTransformImage(const Image *,const AffineMatrix *,ExceptionInfo *),
*DistortImage(const Image *,const DistortImageMethod,const size_t,
const double *,MagickBooleanType,ExceptionInfo *exception),
*DistortResizeImage(const Image *,const size_t,const size_t,ExceptionInfo *),
*RotateImage(const Image *,const double,ExceptionInfo *),
*SparseColorImage(const Image *,const ChannelType,const SparseColorMethod,
const size_t,const double *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/pixel-accessor.h 0000644 00000020632 14751151177 0011105 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore pixel accessor methods.
*/
#ifndef MAGICKCORE_PIXEL_ACCESSOR_H
#define MAGICKCORE_PIXEL_ACCESSOR_H
#include <math.h>
#include "magick/gem.h"
#include "magick/pixel.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#define ClampPixelRed(pixel) ClampToQuantum((pixel)->red)
#define ClampPixelGreen(pixel) ClampToQuantum((pixel)->green)
#define ClampPixelBlue(pixel) ClampToQuantum((pixel)->blue)
#define ClampPixelIndex(indexes) ClampToQuantum(*(indexes))
#define ClampPixelOpacity(pixel) ClampToQuantum((pixel)->opacity)
#define GetPixela(pixel) ((pixel)->green)
#define GetPixelb(pixel) ((pixel)->blue)
#define GetPixelAlpha(pixel) ((double) QuantumRange-(double) (pixel)->opacity)
#define GetPixelBlack(indexes) (*(indexes))
#define GetPixelBlue(pixel) ((pixel)->blue)
#define GetPixelCb(pixel) ((pixel)->green)
#define GetPixelCr(pixel) ((pixel)->blue)
#define GetPixelCyan(pixel) ((pixel)->red)
#define GetPixelGray(pixel) ((pixel)->red)
#define GetPixelGreen(pixel) ((pixel)->green)
#define GetPixelIndex(indexes) (*(indexes))
#define GetPixelL(pixel) ((pixel)->red)
#define GetPixelLabel(pixel) ((ssize_t) (pixel)->red)
#define GetPixelMagenta(pixel) ((pixel)->green)
#define GetPixelNext(pixel) ((pixel)+1)
#define GetPixelOpacity(pixel) ((pixel)->opacity)
#define GetPixelRed(pixel) ((pixel)->red)
#define GetPixelRGB(pixel,packet) \
{ \
(packet)->red=GetPixelRed((pixel)); \
(packet)->green=GetPixelGreen((pixel)); \
(packet)->blue=GetPixelBlue((pixel)); \
}
#define GetPixelRGBO(pixel,packet) \
{ \
(packet)->red=GetPixelRed((pixel)); \
(packet)->green=GetPixelGreen((pixel)); \
(packet)->blue=GetPixelBlue((pixel)); \
(packet)->opacity=GetPixelOpacity((pixel)); \
}
#define GetPixelY(pixel) ((pixel)->red)
#define GetPixelYellow(pixel) ((pixel)->blue)
#define SetPixela(pixel,value) ((pixel)->green=(Quantum) (value))
#define SetPixelAlpha(pixel,value) \
((pixel)->opacity=(Quantum) ((double) QuantumRange-(double) (value)))
#define SetPixelb(pixel,value) ((pixel)->blue=(Quantum) (value))
#define SetPixelBlack(indexes,value) (*(indexes)=(Quantum) (value))
#define SetPixelBlue(pixel,value) ((pixel)->blue=(Quantum) (value))
#define SetPixelCb(pixel,value) ((pixel)->green=(Quantum) (value))
#define SetPixelCr(pixel,value) ((pixel)->blue=(Quantum) (value))
#define SetPixelCyan(pixel,value) ((pixel)->red=(Quantum) (value))
#define SetPixelGray(pixel,value) \
((pixel)->red=(pixel)->green=(pixel)->blue=(Quantum) (value))
#define SetPixelGreen(pixel,value) ((pixel)->green=(Quantum) (value))
#define SetPixelIndex(indexes,value) (*(indexes)=(IndexPacket) (value))
#define SetPixelL(pixel,value) ((pixel)->red=(Quantum) (value))
#define SetPixelMagenta(pixel,value) ((pixel)->green=(Quantum) (value))
#define SetPixelOpacity(pixel,value) ((pixel)->opacity=(Quantum) (value))
#define SetPixelRed(pixel,value) ((pixel)->red=(Quantum) (value))
#define SetPixelRgb(pixel,packet) \
{ \
SetPixelRed(pixel,(packet)->red); \
SetPixelGreen(pixel,(packet)->green); \
SetPixelBlue(pixel,(packet)->blue); \
}
#define SetPixelRGBA(pixel,packet) \
{ \
SetPixelRed(pixel,(packet)->red); \
SetPixelGreen(pixel,(packet)->green); \
SetPixelBlue(pixel,(packet)->blue); \
SetPixelAlpha(pixel,(QuantumRange-(packet)->opacity)); \
}
#define SetPixelRGBO(pixel,packet) \
{ \
SetPixelRed(pixel,(packet)->red); \
SetPixelGreen(pixel,(packet)->green); \
SetPixelBlue(pixel,(packet)->blue); \
SetPixelOpacity(pixel,(packet)->opacity); \
}
#define SetPixelYellow(pixel,value) ((pixel)->blue=(Quantum) (value))
#define SetPixelY(pixel,value) ((pixel)->red=(Quantum) (value))
static inline MagickRealType AbsolutePixelValue(const MagickRealType x)
{
return(x < 0.0 ? -x : x);
}
static inline Quantum ClampPixel(const MagickRealType value)
{
if (value < 0.0)
return((Quantum) 0);
if (value >= (MagickRealType) QuantumRange)
return((Quantum) QuantumRange);
#if !defined(MAGICKCORE_HDRI_SUPPORT)
return((Quantum) (value+0.5));
#else
return((Quantum) value);
#endif
}
static inline double PerceptibleReciprocal(const double x)
{
double
sign;
/*
Return 1/x where x is perceptible (not unlimited or infinitesimal).
*/
sign=x < 0.0 ? -1.0 : 1.0;
if ((sign*x) >= MagickEpsilon)
return(1.0/x);
return(sign/MagickEpsilon);
}
static inline MagickRealType GetPixelLuma(
const Image *magick_restrict image,const PixelPacket *magick_restrict pixel)
{
MagickRealType
intensity;
(void) image;
intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
0.072186f*pixel->blue);
return(intensity);
}
static inline MagickRealType GetPixelLuminance(
const Image *magick_restrict image,const PixelPacket *magick_restrict pixel)
{
MagickRealType
intensity;
if (image->colorspace != sRGBColorspace)
{
intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
0.072186f*pixel->blue);
return(intensity);
}
intensity=(MagickRealType) (0.212656*DecodePixelGamma((MagickRealType)
pixel->red)+0.715158*DecodePixelGamma((MagickRealType) pixel->green)+
0.072186*DecodePixelGamma((MagickRealType) pixel->blue));
return(intensity);
}
static inline void GetPixelPacketRGBA(const Quantum red,const Quantum green,
const Quantum blue,const Quantum opacity,PixelPacket *magick_restrict pixel)
{
pixel->red=red;
pixel->green=green;
pixel->blue=blue;
pixel->opacity=opacity;
}
static inline MagickBooleanType IsPixelAtDepth(const Quantum pixel,
const QuantumAny range)
{
Quantum
quantum;
if (range == 0)
return(MagickTrue);
#if !defined(MAGICKCORE_HDRI_SUPPORT)
quantum=(Quantum) (((MagickRealType) QuantumRange*((QuantumAny)
(((MagickRealType) range*pixel)/QuantumRange+0.5)))/range+0.5);
#else
quantum=(Quantum) (((MagickRealType) QuantumRange*((QuantumAny)
(((MagickRealType) range*(MagickRealType) pixel)/(MagickRealType) QuantumRange+
0.5)))/(MagickRealType) range);
#endif
return(pixel == quantum ? MagickTrue : MagickFalse);
}
static inline MagickBooleanType IsPixelGray(const PixelPacket *pixel)
{
MagickRealType
green_blue,
red_green;
red_green=(MagickRealType) pixel->red-(MagickRealType) pixel->green;
green_blue=(MagickRealType) pixel->green-(MagickRealType) pixel->blue;
if (((QuantumScale*AbsolutePixelValue(red_green)) < MagickEpsilon) &&
((QuantumScale*AbsolutePixelValue(green_blue)) < MagickEpsilon))
return(MagickTrue);
return(MagickFalse);
}
static inline MagickBooleanType IsPixelMonochrome(
const PixelPacket *pixel)
{
MagickRealType
green_blue,
red,
red_green;
red=(MagickRealType) pixel->red;
if ((AbsolutePixelValue(red) >= MagickEpsilon) &&
(AbsolutePixelValue(red-(double) QuantumRange) >= MagickEpsilon))
return(MagickFalse);
red_green=(MagickRealType) pixel->red-(double) pixel->green;
green_blue=(MagickRealType) pixel->green-(double) pixel->blue;
if (((QuantumScale*AbsolutePixelValue(red_green)) < MagickEpsilon) &&
((QuantumScale*AbsolutePixelValue(green_blue)) < MagickEpsilon))
return(MagickTrue);
return(MagickFalse);
}
static inline Quantum PixelPacketIntensity(const PixelPacket *pixel)
{
MagickRealType
intensity;
if ((pixel->red == pixel->green) && (pixel->green == pixel->blue))
return(pixel->red);
intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
0.072186f*pixel->blue);
return(ClampToQuantum(intensity));
}
static inline void SetPixelViaMagickPixel(const Image *magick_restrict image,
const MagickPixelPacket *magick_restrict magick_pixel,
PixelPacket *magick_restrict pixel)
{
pixel->red=ClampToQuantum(magick_pixel->red);
pixel->green=ClampToQuantum(magick_pixel->green);
pixel->blue=ClampToQuantum(magick_pixel->blue);
if (image->matte != MagickFalse)
pixel->opacity=ClampToQuantum(magick_pixel->opacity);
}
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/version-64.h 0000644 00000006076 14751151177 0010106 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License.
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore version methods.
*/
#ifndef _MAGICKCORE_VERSION_H
#define _MAGICKCORE_VERSION_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/*
Define declarations.
*/
#define MagickPackageName "ImageMagick"
#define MagickCopyright "(C) 1999 ImageMagick Studio LLC"
#define MagickLibVersion 0x69D
#define MagickLibVersionText "6.9.13"
#define MagickLibVersionNumber 7,0,0
#define MagickLibAddendum "-14"
#define MagickLibInterface 7
#define MagickLibMinInterface 7
#define MagickPlatform "x86_64"
#define MagickppLibVersionText "6.9.13"
#define MagickppLibVersionNumber 9:0:0
#define MagickppLibAddendum "-14"
#define MagickppLibInterface 9
#define MagickppLibMinInterface 9
#define MagickGitRevision "18442"
#define MagickReleaseDate "2024-07-27"
#define MagickHomeURL "file:///usr/share/doc/ImageMagick-6/index.html"
#define MagickAuthoritativeLicense \
"https://imagemagick.org/script/license.php"
#define MagickAuthoritativeURL "https://legacy.imagemagick.org"
#if (MAGICKCORE_QUANTUM_DEPTH == 8)
#define MagickQuantumDepth "Q8"
#define MagickQuantumRange "255"
#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
#define MagickQuantumDepth "Q16"
#define MagickQuantumRange "65535"
#elif (MAGICKCORE_QUANTUM_DEPTH == 32)
#define MagickQuantumDepth "Q32"
#define MagickQuantumRange "4294967295"
#elif (MAGICKCORE_QUANTUM_DEPTH == 64)
#define MagickQuantumDepth "Q64"
#define MagickQuantumRange "18446744073709551615.0"
#else
#define MagickQuantumDepth "Q?"
#define MagickQuantumRange "?"
#endif
#if defined(MAGICKCORE_HDRI_SUPPORT)
#define MagickHDRISupport "-HDRI"
#else
#define MagickHDRISupport ""
#endif
#define MagickVersion \
MagickPackageName " " MagickLibVersionText MagickLibAddendum " " \
MagickQuantumDepth MagickHDRISupport " " MagickPlatform " " \
MagickGitRevision " " MagickAuthoritativeURL
extern MagickExport char
*GetMagickHomeURL(void);
extern MagickExport const char
*GetMagickCopyright(void) magick_attribute((__const__)),
*GetMagickDelegates(void) magick_attribute((__const__)),
*GetMagickFeatures(void) magick_attribute((__const__)),
*GetMagickLicense(void) magick_attribute((__const__)),
*GetMagickPackageName(void) magick_attribute((__const__)),
*GetMagickQuantumDepth(size_t *),
*GetMagickQuantumRange(size_t *),
*GetMagickReleaseDate(void) magick_attribute((__const__)),
*GetMagickVersion(size_t *);
extern MagickExport void
ListMagickVersion(FILE *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
magick/layer.h 0000644 00000004035 14751151177 0007277 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore image layer methods.
*/
#ifndef MAGICKCORE_LAYER_H
#define MAGICKCORE_LAYER_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef enum
{
UnrecognizedDispose,
UndefinedDispose = 0,
NoneDispose = 1,
BackgroundDispose = 2,
PreviousDispose = 3
} DisposeType;
typedef enum
{
UndefinedLayer,
CoalesceLayer,
CompareAnyLayer,
CompareClearLayer,
CompareOverlayLayer,
DisposeLayer,
OptimizeLayer,
OptimizeImageLayer,
OptimizePlusLayer,
OptimizeTransLayer,
RemoveDupsLayer,
RemoveZeroLayer,
CompositeLayer,
MergeLayer,
FlattenLayer,
MosaicLayer,
TrimBoundsLayer
} ImageLayerMethod;
extern MagickExport Image
*CoalesceImages(const Image *,ExceptionInfo *),
*DisposeImages(const Image *,ExceptionInfo *),
*CompareImageLayers(const Image *,const ImageLayerMethod,ExceptionInfo *),
*DeconstructImages(const Image *,ExceptionInfo *),
*MergeImageLayers(Image *,const ImageLayerMethod,ExceptionInfo *),
*OptimizeImageLayers(const Image *,ExceptionInfo *),
*OptimizePlusImageLayers(const Image *,ExceptionInfo *);
extern MagickExport void
CompositeLayers(Image *,const CompositeOperator,Image *,const ssize_t,
const ssize_t,ExceptionInfo *),
OptimizeImageTransparency(const Image *,ExceptionInfo *),
RemoveDuplicateLayers(Image **,ExceptionInfo *),
RemoveZeroDelayLayers(Image **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/wand-view.h 0000644 00000004563 14751151177 0007570 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand wand view methods.
*/
#ifndef MAGICKWAND_WAND_VIEW_H
#define MAGICKWAND_WAND_VIEW_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _WandView
WandView;
typedef MagickBooleanType
(*DuplexTransferWandViewMethod)(const WandView *,const WandView *,WandView *,
const ssize_t,const int,void *),
(*GetWandViewMethod)(const WandView *,const ssize_t,const int,void *),
(*SetWandViewMethod)(WandView *,const ssize_t,const int,void *),
(*TransferWandViewMethod)(const WandView *,WandView *,const ssize_t,
const int,void *),
(*UpdateWandViewMethod)(WandView *,const ssize_t,const int,void *);
extern WandExport char
*GetWandViewException(const WandView *,ExceptionType *);
extern WandExport MagickBooleanType
DuplexTransferWandViewIterator(WandView *,WandView *,WandView *,
DuplexTransferWandViewMethod,void *),
GetWandViewIterator(WandView *,GetWandViewMethod,void *),
IsWandView(const WandView *),
SetWandViewIterator(WandView *,SetWandViewMethod,void *),
TransferWandViewIterator(WandView *,WandView *,TransferWandViewMethod,void *),
UpdateWandViewIterator(WandView *,UpdateWandViewMethod,void *);
extern WandExport MagickWand
*GetWandViewWand(const WandView *);
extern WandExport PixelWand
**GetWandViewPixels(const WandView *);
extern WandExport RectangleInfo
GetWandViewExtent(const WandView *);
extern WandExport void
SetWandViewDescription(WandView *,const char *),
SetWandViewThreads(WandView *,const size_t);
extern WandExport WandView
*CloneWandView(const WandView *),
*DestroyWandView(WandView *),
*NewWandView(MagickWand *),
*NewWandViewExtent(MagickWand *,const ssize_t,const ssize_t,const size_t,
const size_t);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/MagickWand.h 0000644 00000006747 14751151177 0007702 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand Application Programming Interface declarations.
*/
#ifndef _MAGICK_WAND_H
#define _MAGICK_WAND_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if !defined(MAGICKWAND_CONFIG_H)
# define MAGICKWAND_CONFIG_H
# if !defined(vms) && !defined(macintosh)
# include "magick/magick-config.h"
# else
# include "magick-config.h"
# endif
#if defined(_magickcore_const) && !defined(const)
# define const _magickcore_const
#endif
#if defined(_magickcore_inline) && !defined(inline)
# define inline _magickcore_inline
#endif
#if !defined(magick_restrict)
# if !defined(_magickcore_restrict)
# define magick_restrict restrict
# else
# define magick_restrict _magickcore_restrict
# endif
#endif
# if defined(__cplusplus) || defined(c_plusplus)
# undef inline
# endif
#endif
#define MAGICKWAND_CHECK_VERSION(major,minor,micro) \
((MAGICKWAND_MAJOR_VERSION > (major)) || \
((MAGICKWAND_MAJOR_VERSION == (major)) && \
(MAGICKWAND_MINOR_VERSION > (minor))) || \
((MAGICKWAND_MAJOR_VERSION == (major)) && \
(MAGICKWAND_MINOR_VERSION == (minor)) && \
(MAGICKWAND_MICRO_VERSION >= (micro))))
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
#include <sys/types.h>
#include <time.h>
#if defined(WIN32) || defined(WIN64)
# define MAGICKWAND_WINDOWS_SUPPORT
#else
# define MAGICKWAND_POSIX_SUPPORT
#endif
typedef struct _MagickWand
MagickWand;
#include "wand/method-attribute.h"
#include "magick/MagickCore.h"
#include "wand/animate.h"
#include "wand/compare.h"
#include "wand/composite.h"
#include "wand/conjure.h"
#include "wand/convert.h"
#include "wand/deprecate.h"
#include "wand/display.h"
#include "wand/drawing-wand.h"
#include "wand/identify.h"
#include "wand/import.h"
#include "wand/magick-property.h"
#include "wand/magick-image.h"
#include "wand/mogrify.h"
#include "wand/montage.h"
#include "wand/pixel-iterator.h"
#include "wand/pixel-wand.h"
#include "wand/stream.h"
#include "wand/wand-view.h"
extern WandExport char
*MagickGetException(const MagickWand *,ExceptionType *);
extern WandExport ExceptionType
MagickGetExceptionType(const MagickWand *);
extern WandExport MagickBooleanType
IsMagickWand(const MagickWand *),
IsMagickWandInstantiated(void),
MagickClearException(MagickWand *),
MagickSetIteratorIndex(MagickWand *,const ssize_t);
extern WandExport MagickWand
*CloneMagickWand(const MagickWand *),
*DestroyMagickWand(MagickWand *),
*NewMagickWand(void),
*NewMagickWandFromImage(const Image *);
extern WandExport ssize_t
MagickGetIteratorIndex(MagickWand *);
extern WandExport void
ClearMagickWand(MagickWand *),
MagickWandGenesis(void),
MagickWandTerminus(void),
*MagickRelinquishMemory(void *),
MagickResetIterator(MagickWand *),
MagickSetFirstIterator(MagickWand *),
MagickSetLastIterator(MagickWand *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/magick-wand.h 0000644 00000001450 14751151177 0010041 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand API (deprecated, use magick-wand.h instead).
*/
#ifndef MAGICKWAND_MAGICK_WAND_DEPRECATED_H
#define MAGICKWAND_MAGICK_WAND_DEPRECATED_H
#include "wand/MagickWand.h"
#endif
wand/compare.h 0000644 00000001707 14751151177 0007312 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand compare command-line method.
*/
#ifndef MAGICKWAND_COMPARE_H
#define MAGICKWAND_COMPARE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
CompareImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/stream.h 0000644 00000001704 14751151177 0007154 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand montage command-line method.
*/
#ifndef MAGICKWAND_STREAM_H
#define MAGICKWAND_STREAM_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
StreamImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/method-attribute.h 0000644 00000007047 14751151177 0011150 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand method attribute.
*/
#ifndef MAGICKWAND_METHOD_ATTRIBUTE_H
#define MAGICKWAND_METHOD_ATTRIBUTE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if defined(__BORLANDC__) && defined(_DLL)
# define _MAGICKDLL_
# define _MAGICKLIB_
# define MAGICKCORE_MODULES_SUPPORT
# undef MAGICKCORE_BUILD_MODULES
#endif
#if defined(MAGICKWAND_WINDOWS_SUPPORT) && !defined(__CYGWIN__)
# define WandPrivate
# if defined(_MT) && defined(_DLL) && !defined(_MAGICKDLL_) && !defined(_LIB)
# define _MAGICKDLL_
# endif
# if defined(_MAGICKDLL_)
# if defined(_VISUALC_)
# pragma warning( disable: 4273 ) /* Disable the dll linkage warnings */
# endif
# if !defined(_MAGICKLIB_)
# if defined(__clang__) || defined(__GNUC__)
# define WandExport __attribute__ ((dllimport))
# else
# define WandExport __declspec(dllimport)
# endif
# else
# if defined(__clang__) || defined(__GNUC__)
# define WandExport __attribute__ ((dllexport))
# else
# define WandExport __declspec(dllexport)
# endif
# endif
# else
# define WandExport
# endif
# if defined(_VISUALC_)
# pragma warning(disable : 4018)
# pragma warning(disable : 4068)
# pragma warning(disable : 4244)
# pragma warning(disable : 4142)
# pragma warning(disable : 4800)
# pragma warning(disable : 4786)
# pragma warning(disable : 4996)
# endif
#else
# if defined(__clang__) || (__GNUC__ >= 4)
# define WandExport __attribute__ ((visibility ("default")))
# define WandPrivate __attribute__ ((visibility ("hidden")))
# else
# define WandExport
# define WandPrivate
# endif
#endif
#define WandSignature 0xabacadabUL
#if !defined(MaxTextExtent)
# define MaxTextExtent 4096
#endif
#if defined(MAGICKCORE_HAVE___ATTRIBUTE__)
# define wand_aligned(x) __attribute__((aligned(x)))
# define wand_attribute __attribute__
# define wand_unused(x) wand_unused_ ## x __attribute__((unused))
# define wand_unreferenced(x)
#elif defined(MAGICKWAND_WINDOWS_SUPPORT) && !defined(__CYGWIN__)
# define wand_aligned(x) __declspec(align(x))
# define wand_attribute(x) /* nothing */
# define wand_unused(x) x
# define wand_unreferenced(x) (x)
#else
# define wand_aligned(x) /* nothing */
# define wand_attribute(x) /* nothing */
# define wand_unused(x) x
# define wand_unreferenced(x) /* nothing */
#endif
#if !defined(__clang__) && (defined(__GNUC__) && (__GNUC__) > 4)
# define wand_alloc_size(x) __attribute__((__alloc_size__(x)))
# define wand_alloc_sizes(x,y) __attribute__((__alloc_size__(x,y)))
#else
# define wand_alloc_size(x) /* nothing */
# define wand_alloc_sizes(x,y) /* nothing */
#endif
#if !defined(__clang__) && (defined(__GNUC__) && (__GNUC__) > 4)
# define wand_cold_spot __attribute__((__cold__))
# define wand_hot_spot __attribute__((__hot__))
#else
# define wand_cold_spot
# define wand_hot_spot
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/identify.h 0000644 00000001713 14751151177 0007474 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand identify command-line method.
*/
#ifndef MAGICKWAND_IDENTIFY_H
#define MAGICKWAND_IDENTIFY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
IdentifyImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/pixel-iterator.h 0000644 00000004040 14751151177 0010625 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Pixel Iterator Methods.
*/
#ifndef MAGICKWAND_PIXEL_ITERATOR_H
#define MAGICKWAND_PIXEL_ITERATOR_H
#include "wand/magick-wand.h"
#include "wand/pixel-wand.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _PixelIterator
PixelIterator;
extern WandExport char
*PixelGetIteratorException(const PixelIterator *,ExceptionType *);
extern WandExport ExceptionType
PixelGetIteratorExceptionType(const PixelIterator *);
extern WandExport MagickBooleanType
IsPixelIterator(const PixelIterator *),
PixelClearIteratorException(PixelIterator *),
PixelSetIteratorRow(PixelIterator *,const ssize_t),
PixelSyncIterator(PixelIterator *);
extern WandExport PixelIterator
*ClonePixelIterator(const PixelIterator *),
*DestroyPixelIterator(PixelIterator *),
*NewPixelIterator(MagickWand *),
*NewPixelRegionIterator(MagickWand *,const ssize_t,const ssize_t,const size_t,
const size_t);
extern WandExport PixelWand
**PixelGetCurrentIteratorRow(PixelIterator *,size_t *),
**PixelGetNextIteratorRow(PixelIterator *,size_t *),
**PixelGetPreviousIteratorRow(PixelIterator *,size_t *);
extern WandExport ssize_t
PixelGetIteratorRow(PixelIterator *);
extern WandExport void
ClearPixelIterator(PixelIterator *),
PixelResetIterator(PixelIterator *),
PixelSetFirstIteratorRow(PixelIterator *),
PixelSetLastIteratorRow(PixelIterator *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/animate.h 0000644 00000001710 14751151177 0007274 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand animate command-line methods.
*/
#ifndef MAGICKWAND_ANIMATE_H
#define MAGICKWAND_ANIMATE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
AnimateImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/import.h 0000644 00000001703 14751151177 0007172 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand import command-line method.
*/
#ifndef MAGICKWAND_IMPORT_H
#define MAGICKWAND_IMPORT_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
ImportImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/display.h 0000644 00000001707 14751151177 0007331 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand display command-line method.
*/
#ifndef MAGICKWAND_DISPLAY_H
#define MAGICKWAND_DISPLAY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
DisplayImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/deprecate.h 0000644 00000017257 14751151177 0007627 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickCore deprecated methods.
*/
#ifndef MAGICKWAND_DEPRECATE_H
#define MAGICKWAND_DEPRECATE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#if !defined(MAGICKCORE_EXCLUDE_DEPRECATED)
#include "wand/drawing-wand.h"
#include "wand/magick-wand.h"
#include "wand/pixel-iterator.h"
#include "wand/pixel-wand.h"
typedef struct _DrawingWand
*DrawContext;
typedef struct _PixelView
PixelView;
extern WandExport DrawingWand
*DrawAllocateWand(const DrawInfo *,Image *);
typedef MagickBooleanType
(*DuplexTransferPixelViewMethod)(const PixelView *,const PixelView *,
PixelView *,void *),
(*GetPixelViewMethod)(const PixelView *,void *),
(*SetPixelViewMethod)(PixelView *,void *),
(*TransferPixelViewMethod)(const PixelView *,PixelView *,void *),
(*UpdatePixelViewMethod)(PixelView *,void *);
extern WandExport char
*GetPixelViewException(const PixelView *,ExceptionType *)
magick_attribute((deprecated));
extern WandExport double
DrawGetFillAlpha(const DrawingWand *) magick_attribute((deprecated)),
DrawGetStrokeAlpha(const DrawingWand *) magick_attribute((deprecated));
extern WandExport DrawInfo
*DrawPeekGraphicWand(const DrawingWand *) magick_attribute((deprecated));
extern WandExport char
*MagickDescribeImage(MagickWand *) magick_attribute((deprecated)),
*MagickGetImageAttribute(MagickWand *,const char *)
magick_attribute((deprecated)),
*PixelIteratorGetException(const PixelIterator *,ExceptionType *)
magick_attribute((deprecated));
extern WandExport ssize_t
MagickGetImageIndex(MagickWand *) magick_attribute((deprecated));
extern WandExport MagickBooleanType
DuplexTransferPixelViewIterator(PixelView *,PixelView *,PixelView *,
DuplexTransferPixelViewMethod,void *) magick_attribute((deprecated)),
GetPixelViewIterator(PixelView *,GetPixelViewMethod,void *)
magick_attribute((deprecated)),
IsPixelView(const PixelView *) magick_attribute((deprecated)),
MagickClipPathImage(MagickWand *,const char *,const MagickBooleanType)
magick_attribute((deprecated)),
MagickColorFloodfillImage(MagickWand *,const PixelWand *,const double,
const PixelWand *,const ssize_t,const ssize_t)
magick_attribute((deprecated)),
MagickGetImageChannelExtrema(MagickWand *,const ChannelType,size_t *,
size_t *) magick_attribute((deprecated)),
MagickGetImageExtrema(MagickWand *,size_t *,size_t *)
magick_attribute((deprecated)),
MagickGetImageMatte(MagickWand *) magick_attribute((deprecated)),
MagickGetImagePixels(MagickWand *,const ssize_t,const ssize_t,const size_t,
const size_t,const char *,const StorageType,void *)
magick_attribute((deprecated)),
MagickMapImage(MagickWand *,const MagickWand *,const MagickBooleanType)
magick_attribute((deprecated)),
MagickMatteFloodfillImage(MagickWand *,const double,const double,
const PixelWand *,const ssize_t,const ssize_t)
magick_attribute((deprecated)),
MagickMedianFilterImage(MagickWand *,const double)
magick_attribute((deprecated)),
MagickModeImage(MagickWand *,const double) magick_attribute((deprecated)),
MagickReduceNoiseImage(MagickWand *,const double)
magick_attribute((deprecated)),
MagickRemapImage(MagickWand *,const MagickWand *,const DitherMethod),
MagickOpaqueImage(MagickWand *,const PixelWand *,const PixelWand *,
const double) magick_attribute((deprecated)),
MagickPaintFloodfillImage(MagickWand *,const ChannelType,const PixelWand *,
const double,const PixelWand *,const ssize_t,const ssize_t)
magick_attribute((deprecated)),
MagickPaintOpaqueImage(MagickWand *,const PixelWand *,const PixelWand *,
const double) magick_attribute((deprecated)),
MagickPaintOpaqueImageChannel(MagickWand *,const ChannelType,
const PixelWand *,const PixelWand *,const double)
magick_attribute((deprecated)),
MagickPaintTransparentImage(MagickWand *,const PixelWand *,const double,
const double) magick_attribute((deprecated)),
MagickRadialBlurImage(MagickWand *,const double)
magick_attribute((deprecated)),
MagickRadialBlurImageChannel(MagickWand *,const ChannelType,const double)
magick_attribute((deprecated)),
MagickRecolorImage(MagickWand *,const size_t,const double *)
magick_attribute((deprecated)),
MagickSetImageAttribute(MagickWand *,const char *,const char *)
magick_attribute((deprecated)),
MagickSetImageIndex(MagickWand *,const ssize_t)
magick_attribute((deprecated)),
MagickSetImageOption(MagickWand *,const char *,const char *,const char *)
magick_attribute((deprecated)),
MagickSetImagePixels(MagickWand *,const ssize_t,const ssize_t,const size_t,
const size_t,const char *,const StorageType,const void *)
magick_attribute((deprecated)),
MagickTransparentImage(MagickWand *,const PixelWand *,const double,
const double) magick_attribute((deprecated)),
SetPixelViewIterator(PixelView *,SetPixelViewMethod,void *)
magick_attribute((deprecated)),
TransferPixelViewIterator(PixelView *,PixelView *,TransferPixelViewMethod,
void *) magick_attribute((deprecated)),
UpdatePixelViewIterator(PixelView *,UpdatePixelViewMethod,void *)
magick_attribute((deprecated));
extern WandExport MagickWand
*GetPixelViewWand(const PixelView *) magick_attribute((deprecated)),
*MagickAverageImages(MagickWand *) magick_attribute((deprecated)),
*MagickFlattenImages(MagickWand *) magick_attribute((deprecated)),
*MagickMaximumImages(MagickWand *) magick_attribute((deprecated)),
*MagickMinimumImages(MagickWand *) magick_attribute((deprecated)),
*MagickMosaicImages(MagickWand *) magick_attribute((deprecated)),
*MagickRegionOfInterestImage(MagickWand *,const size_t,const size_t,
const ssize_t,const ssize_t) magick_attribute((deprecated));
extern WandExport MagickSizeType
MagickGetImageSize(MagickWand *) magick_attribute((deprecated));
extern WandExport PixelView
*ClonePixelView(const PixelView *) magick_attribute((deprecated)),
*DestroyPixelView(PixelView *) magick_attribute((deprecated)),
*NewPixelView(MagickWand *) magick_attribute((deprecated)),
*NewPixelViewRegion(MagickWand *,const ssize_t,const ssize_t,const size_t,
const size_t) magick_attribute((deprecated));
extern WandExport PixelWand
**GetPixelViewPixels(const PixelView *) magick_attribute((deprecated)),
**PixelGetNextRow(PixelIterator *) magick_attribute((deprecated));
extern WandExport size_t
GetPixelViewHeight(const PixelView *) magick_attribute((deprecated)),
GetPixelViewWidth(const PixelView *) magick_attribute((deprecated));
extern WandExport ssize_t
GetPixelViewX(const PixelView *) magick_attribute((deprecated)),
GetPixelViewY(const PixelView *) magick_attribute((deprecated));
extern WandExport unsigned char
*MagickWriteImageBlob(MagickWand *,size_t *) magick_attribute((deprecated));
extern WandExport void
DrawPopGraphicContext(DrawingWand *) magick_attribute((deprecated)),
DrawPushGraphicContext(DrawingWand *) magick_attribute((deprecated)),
DrawSetFillAlpha(DrawingWand *,const double) magick_attribute((deprecated)),
DrawSetStrokeAlpha(DrawingWand *,const double) magick_attribute((deprecated));
#endif
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/composite.h 0000644 00000001717 14751151177 0007667 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand composite command-line method.
*/
#ifndef MAGICKWAND_COMPOSITE_H
#define MAGICKWAND_COMPOSITE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
CompositeImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/magick_wand.h 0000644 00000001450 14751151177 0010123 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand API (deprecated, use magick-wand.h instead).
*/
#ifndef MAGICKWAND_MAGICK_WAND_DEPRECATED_H
#define MAGICKWAND_MAGICK_WAND_DEPRECATED_H
#include "wand/MagickWand.h"
#endif
wand/magick-image.h 0000644 00000054036 14751151177 0010202 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand image Methods.
*/
#ifndef MAGICKWAND_MAGICK_IMAGE_H
#define MAGICKWAND_MAGICK_IMAGE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport ChannelFeatures
*MagickGetImageChannelFeatures(MagickWand *,const size_t);
extern WandExport ChannelStatistics
*MagickGetImageChannelStatistics(MagickWand *);
extern WandExport char
*MagickGetImageFilename(MagickWand *),
*MagickGetImageFormat(MagickWand *),
*MagickGetImageSignature(MagickWand *),
*MagickIdentifyImage(MagickWand *);
extern WandExport ColorspaceType
MagickGetImageColorspace(MagickWand *);
extern WandExport CompositeOperator
MagickGetImageCompose(MagickWand *);
extern WandExport CompressionType
MagickGetImageCompression(MagickWand *);
extern WandExport DisposeType
MagickGetImageDispose(MagickWand *);
extern WandExport double
*MagickGetImageChannelDistortions(MagickWand *,const MagickWand *,
const MetricType),
MagickGetImageFuzz(MagickWand *),
MagickGetImageGamma(MagickWand *),
MagickGetImageTotalInkDensity(MagickWand *);
extern WandExport EndianType
MagickGetImageEndian(MagickWand *);
extern WandExport GravityType
MagickGetImageGravity(MagickWand *);
extern WandExport Image
*MagickDestroyImage(Image *),
*GetImageFromMagickWand(const MagickWand *);
extern WandExport ImageType
MagickGetImageType(MagickWand *);
extern WandExport InterlaceType
MagickGetImageInterlaceScheme(MagickWand *);
extern WandExport InterpolatePixelMethod
MagickGetImageInterpolateMethod(MagickWand *);
extern WandExport MagickBooleanType
MagickAdaptiveBlurImage(MagickWand *,const double,const double),
MagickAdaptiveBlurImageChannel(MagickWand *,const ChannelType,const double,
const double),
MagickAdaptiveResizeImage(MagickWand *,const size_t,const size_t),
MagickAdaptiveSharpenImage(MagickWand *,const double,const double),
MagickAdaptiveSharpenImageChannel(MagickWand *,const ChannelType,const double,
const double),
MagickAdaptiveThresholdImage(MagickWand *,const size_t,const size_t,
const ssize_t),
MagickAddImage(MagickWand *,const MagickWand *),
MagickAddNoiseImage(MagickWand *,const NoiseType),
MagickAddNoiseImageChannel(MagickWand *,const ChannelType,const NoiseType),
MagickAffineTransformImage(MagickWand *,const DrawingWand *),
MagickAnnotateImage(MagickWand *,const DrawingWand *,const double,
const double,const double,const char *),
MagickAnimateImages(MagickWand *,const char *),
MagickAutoGammaImage(MagickWand *),
MagickAutoGammaImageChannel(MagickWand *,const ChannelType),
MagickAutoLevelImage(MagickWand *),
MagickAutoLevelImageChannel(MagickWand *,const ChannelType),
MagickAutoOrientImage(MagickWand *),
MagickBlackThresholdImage(MagickWand *,const PixelWand *),
MagickBlueShiftImage(MagickWand *,const double),
MagickBlurImage(MagickWand *,const double,const double),
MagickBlurImageChannel(MagickWand *,const ChannelType,const double,
const double),
MagickBorderImage(MagickWand *,const PixelWand *,const size_t,const size_t),
MagickBrightnessContrastImage(MagickWand *,const double,const double),
MagickBrightnessContrastImageChannel(MagickWand *,const ChannelType,
const double,const double),
MagickCharcoalImage(MagickWand *,const double,const double),
MagickChopImage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t),
MagickClampImage(MagickWand *),
MagickClampImageChannel(MagickWand *,const ChannelType),
MagickClipImage(MagickWand *),
MagickClipImagePath(MagickWand *,const char *,const MagickBooleanType),
MagickClutImage(MagickWand *,const MagickWand *),
MagickClutImageChannel(MagickWand *,const ChannelType,const MagickWand *),
MagickColorDecisionListImage(MagickWand *,const char *),
MagickColorizeImage(MagickWand *,const PixelWand *,const PixelWand *),
MagickColorMatrixImage(MagickWand *,const KernelInfo *),
MagickCommentImage(MagickWand *,const char *),
MagickCompositeImage(MagickWand *,const MagickWand *,const CompositeOperator,
const ssize_t,const ssize_t),
MagickCompositeImageChannel(MagickWand *,const ChannelType,const MagickWand *,
const CompositeOperator,const ssize_t,const ssize_t),
MagickCompositeImageGravity(MagickWand *,const MagickWand *,
const CompositeOperator,const GravityType),
MagickCompositeLayers(MagickWand *,const MagickWand *,const CompositeOperator,
const ssize_t,const ssize_t),
MagickConstituteImage(MagickWand *,const size_t,const size_t,const char *,
const StorageType,const void *),
MagickContrastImage(MagickWand *,const MagickBooleanType),
MagickContrastStretchImage(MagickWand *,const double,const double),
MagickContrastStretchImageChannel(MagickWand *,const ChannelType,const double,
const double),
MagickConvolveImage(MagickWand *,const size_t,const double *),
MagickConvolveImageChannel(MagickWand *,const ChannelType,const size_t,
const double *),
MagickCropImage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t),
MagickCycleColormapImage(MagickWand *,const ssize_t),
MagickDecipherImage(MagickWand *,const char *),
MagickDeskewImage(MagickWand *,const double),
MagickDespeckleImage(MagickWand *),
MagickDisplayImage(MagickWand *,const char *),
MagickDisplayImages(MagickWand *,const char *),
MagickDistortImage(MagickWand *,const DistortImageMethod,const size_t,
const double *,const MagickBooleanType),
MagickDrawImage(MagickWand *,const DrawingWand *),
MagickEdgeImage(MagickWand *,const double),
MagickEmbossImage(MagickWand *,const double,const double),
MagickEncipherImage(MagickWand *,const char *),
MagickEnhanceImage(MagickWand *),
MagickEqualizeImage(MagickWand *),
MagickEqualizeImageChannel(MagickWand *,const ChannelType),
MagickEvaluateImage(MagickWand *,const MagickEvaluateOperator,const double),
MagickEvaluateImageChannel(MagickWand *,const ChannelType,
const MagickEvaluateOperator,const double),
MagickExportImagePixels(MagickWand *,const ssize_t,const ssize_t,
const size_t,const size_t,const char *,const StorageType,void *),
MagickExtentImage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t),
MagickFilterImage(MagickWand *,const KernelInfo *),
MagickFilterImageChannel(MagickWand *,const ChannelType,const KernelInfo *),
MagickFlipImage(MagickWand *),
MagickFloodfillPaintImage(MagickWand *,const ChannelType,const PixelWand *,
const double,const PixelWand *,const ssize_t,const ssize_t,
const MagickBooleanType),
MagickFlopImage(MagickWand *),
MagickForwardFourierTransformImage(MagickWand *,const MagickBooleanType),
MagickFrameImage(MagickWand *,const PixelWand *,const size_t,const size_t,
const ssize_t,const ssize_t),
MagickFunctionImage(MagickWand *,const MagickFunction,const size_t,
const double *),
MagickFunctionImageChannel(MagickWand *,const ChannelType,
const MagickFunction,const size_t,const double *),
MagickGammaImage(MagickWand *,const double),
MagickGammaImageChannel(MagickWand *,const ChannelType,const double),
MagickGaussianBlurImage(MagickWand *,const double,const double),
MagickGaussianBlurImageChannel(MagickWand *,const ChannelType,const double,
const double),
MagickGetImageAlphaChannel(MagickWand *),
MagickGetImageBackgroundColor(MagickWand *,PixelWand *),
MagickGetImageBluePrimary(MagickWand *,double *,double *),
MagickGetImageBorderColor(MagickWand *,PixelWand *),
MagickGetImageChannelDistortion(MagickWand *,const MagickWand *,
const ChannelType,const MetricType,double *),
MagickGetImageChannelKurtosis(MagickWand *,const ChannelType,double *,
double *),
MagickGetImageChannelMean(MagickWand *,const ChannelType,double *,double *),
MagickGetImageChannelRange(MagickWand *,const ChannelType,double *,double *),
MagickGetImageColormapColor(MagickWand *,const size_t,PixelWand *),
MagickGetImageDistortion(MagickWand *,const MagickWand *,const MetricType,
double *),
MagickGetImageGreenPrimary(MagickWand *,double *,double *),
MagickGetImageMatteColor(MagickWand *,PixelWand *),
MagickGetImageLength(MagickWand *,MagickSizeType *),
MagickGetImagePage(MagickWand *,size_t *,size_t *,ssize_t *,
ssize_t *),
MagickGetImagePixelColor(MagickWand *,const ssize_t,const ssize_t,
PixelWand *),
MagickGetImageRange(MagickWand *,double *,double *),
MagickGetImageRedPrimary(MagickWand *,double *,double *),
MagickGetImageResolution(MagickWand *,double *,double *),
MagickGetImageWhitePoint(MagickWand *,double *,double *),
MagickHaldClutImage(MagickWand *,const MagickWand *),
MagickHaldClutImageChannel(MagickWand *,const ChannelType,const MagickWand *),
MagickHasNextImage(MagickWand *),
MagickHasPreviousImage(MagickWand *),
MagickImplodeImage(MagickWand *,const double),
MagickImportImagePixels(MagickWand *,const ssize_t,const ssize_t,const size_t,
const size_t,const char *,const StorageType,const void *),
MagickInverseFourierTransformImage(MagickWand *,MagickWand *,
const MagickBooleanType),
MagickLabelImage(MagickWand *,const char *),
MagickLevelImage(MagickWand *,const double,const double,const double),
MagickLevelImageChannel(MagickWand *,const ChannelType,const double,
const double,const double),
MagickLevelImageColors(MagickWand *,const PixelWand *,const PixelWand *,
const MagickBooleanType),
MagickLevelImageColorsChannel(MagickWand *,const ChannelType,
const PixelWand *,const PixelWand *,const MagickBooleanType),
MagickLevelizeImage(MagickWand *,const double,const double,const double),
MagickLevelizeImageChannel(MagickWand *,const ChannelType,const double,
const double,const double),
MagickLinearStretchImage(MagickWand *,const double,const double),
MagickLiquidRescaleImage(MagickWand *,const size_t,const size_t,const double,
const double),
MagickLocalContrastImage(MagickWand *,const double,const double),
MagickMagnifyImage(MagickWand *),
MagickMedianFilterImage(MagickWand *,const double),
MagickMinifyImage(MagickWand *),
MagickModeImage(MagickWand *,const double),
MagickModulateImage(MagickWand *,const double,const double,const double),
MagickMorphologyImage(MagickWand *,const MorphologyMethod,const ssize_t,
const KernelInfo *),
MagickMorphologyImageChannel(MagickWand *,const ChannelType,
const MorphologyMethod,const ssize_t,const KernelInfo *),
MagickMotionBlurImage(MagickWand *,const double,const double,const double),
MagickMotionBlurImageChannel(MagickWand *,const ChannelType,const double,
const double,const double),
MagickNegateImage(MagickWand *,const MagickBooleanType),
MagickNegateImageChannel(MagickWand *,const ChannelType,
const MagickBooleanType),
MagickNewImage(MagickWand *,const size_t,const size_t,const PixelWand *),
MagickNextImage(MagickWand *),
MagickNormalizeImage(MagickWand *),
MagickNormalizeImageChannel(MagickWand *,const ChannelType),
MagickOilPaintImage(MagickWand *,const double),
MagickOpaquePaintImage(MagickWand *,const PixelWand *,const PixelWand *,
const double,const MagickBooleanType),
MagickOpaquePaintImageChannel(MagickWand *,const ChannelType,
const PixelWand *,const PixelWand *,const double,const MagickBooleanType),
MagickOrderedPosterizeImage(MagickWand *,const char *),
MagickOrderedPosterizeImageChannel(MagickWand *,const ChannelType,
const char *),
MagickOptimizeImageTransparency(MagickWand *),
MagickTransparentPaintImage(MagickWand *,const PixelWand *,
const double,const double,const MagickBooleanType invert),
MagickPingImage(MagickWand *,const char *),
MagickPingImageBlob(MagickWand *,const void *,const size_t),
MagickPingImageFile(MagickWand *,FILE *),
MagickPolaroidImage(MagickWand *,const DrawingWand *,const double),
MagickPosterizeImage(MagickWand *,const size_t,const MagickBooleanType),
MagickPreviousImage(MagickWand *),
MagickQuantizeImage(MagickWand *,const size_t,const ColorspaceType,
const size_t,const MagickBooleanType,const MagickBooleanType),
MagickQuantizeImages(MagickWand *,const size_t,const ColorspaceType,
const size_t,const MagickBooleanType,const MagickBooleanType),
MagickRaiseImage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t,const MagickBooleanType),
MagickRandomThresholdImage(MagickWand *,const double,const double),
MagickRandomThresholdImageChannel(MagickWand *,const ChannelType,const double,
const double),
MagickReadImage(MagickWand *,const char *),
MagickReadImageBlob(MagickWand *,const void *,const size_t),
MagickReadImageFile(MagickWand *,FILE *),
MagickReduceNoiseImage(MagickWand *,const double),
MagickRemapImage(MagickWand *,const MagickWand *,const DitherMethod),
MagickRemoveImage(MagickWand *),
MagickResampleImage(MagickWand *,const double,const double,const FilterTypes,
const double),
MagickResetImagePage(MagickWand *,const char *),
MagickResizeImage(MagickWand *,const size_t,const size_t,const FilterTypes,
const double),
MagickRollImage(MagickWand *,const ssize_t,const ssize_t),
MagickRotateImage(MagickWand *,const PixelWand *,const double),
MagickRotationalBlurImage(MagickWand *,const double),
MagickRotationalBlurImageChannel(MagickWand *,const ChannelType,
const double),
MagickSampleImage(MagickWand *,const size_t,const size_t),
MagickScaleImage(MagickWand *,const size_t,const size_t),
MagickSegmentImage(MagickWand *,const ColorspaceType,const MagickBooleanType,
const double,const double),
MagickSelectiveBlurImage(MagickWand *,const double,const double,const double),
MagickSelectiveBlurImageChannel(MagickWand *,const ChannelType,const double,
const double,const double),
MagickSeparateImageChannel(MagickWand *,const ChannelType),
MagickSepiaToneImage(MagickWand *,const double),
MagickSetImage(MagickWand *,const MagickWand *),
MagickSetImageAlphaChannel(MagickWand *,const AlphaChannelType),
MagickSetImageBackgroundColor(MagickWand *,const PixelWand *),
MagickSetImageBias(MagickWand *,const double),
MagickSetImageBluePrimary(MagickWand *,const double,const double),
MagickSetImageBorderColor(MagickWand *,const PixelWand *),
MagickSetImageChannelDepth(MagickWand *,const ChannelType,const size_t),
MagickSetImageClipMask(MagickWand *,const MagickWand *),
MagickSetImageColor(MagickWand *,const PixelWand *),
MagickSetImageColormapColor(MagickWand *,const size_t,
const PixelWand *),
MagickSetImageColorspace(MagickWand *,const ColorspaceType),
MagickSetImageCompose(MagickWand *,const CompositeOperator),
MagickSetImageCompression(MagickWand *,const CompressionType),
MagickSetImageDelay(MagickWand *,const size_t),
MagickSetImageDepth(MagickWand *,const size_t),
MagickSetImageDispose(MagickWand *,const DisposeType),
MagickSetImageCompressionQuality(MagickWand *,const size_t),
MagickSetImageEndian(MagickWand *,const EndianType),
MagickSetImageExtent(MagickWand *,const size_t,const size_t),
MagickSetImageFilename(MagickWand *,const char *),
MagickSetImageFormat(MagickWand *,const char *),
MagickSetImageFuzz(MagickWand *,const double),
MagickSetImageGamma(MagickWand *,const double),
MagickSetImageGravity(MagickWand *,const GravityType),
MagickSetImageGreenPrimary(MagickWand *,const double,const double),
MagickSetImageInterlaceScheme(MagickWand *,const InterlaceType),
MagickSetImageInterpolateMethod(MagickWand *,const InterpolatePixelMethod),
MagickSetImageIterations(MagickWand *,const size_t),
MagickSetImageMatte(MagickWand *,const MagickBooleanType),
MagickSetImageMatteColor(MagickWand *,const PixelWand *),
MagickSetImageOpacity(MagickWand *,const double),
MagickSetImageOrientation(MagickWand *,const OrientationType),
MagickSetImagePage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t),
MagickSetImageRedPrimary(MagickWand *,const double,const double),
MagickSetImageRenderingIntent(MagickWand *,const RenderingIntent),
MagickSetImageResolution(MagickWand *,const double,const double),
MagickSetImageScene(MagickWand *,const size_t),
MagickSetImagePixelColor(MagickWand *,const ssize_t,const ssize_t,
const PixelWand *),
MagickSetImageTicksPerSecond(MagickWand *,const ssize_t),
MagickSetImageType(MagickWand *,const ImageType),
MagickSetImageUnits(MagickWand *,const ResolutionType),
MagickSetImageWhitePoint(MagickWand *,const double,const double),
MagickShadeImage(MagickWand *,const MagickBooleanType,const double,
const double),
MagickShadowImage(MagickWand *,const double,const double,const ssize_t,
const ssize_t),
MagickSharpenImage(MagickWand *,const double,const double),
MagickSharpenImageChannel(MagickWand *,const ChannelType,const double,
const double),
MagickShaveImage(MagickWand *,const size_t,const size_t),
MagickShearImage(MagickWand *,const PixelWand *,const double,const double),
MagickSigmoidalContrastImage(MagickWand *,const MagickBooleanType,
const double,const double),
MagickSigmoidalContrastImageChannel(MagickWand *,const ChannelType,
const MagickBooleanType,const double,const double),
MagickSketchImage(MagickWand *,const double,const double,const double),
MagickSolarizeImage(MagickWand *,const double),
MagickSolarizeImageChannel(MagickWand *,const ChannelType,const double),
MagickSparseColorImage(MagickWand *,const ChannelType,const SparseColorMethod,
const size_t,const double *),
MagickSpliceImage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t),
MagickSpreadImage(MagickWand *,const double),
MagickStatisticImage(MagickWand *,const StatisticType,const size_t,
const size_t),
MagickStatisticImageChannel(MagickWand *,const ChannelType,
const StatisticType,const size_t,const size_t),
MagickStripImage(MagickWand *),
MagickSwirlImage(MagickWand *,const double),
MagickTintImage(MagickWand *,const PixelWand *,const PixelWand *),
MagickTransformImageColorspace(MagickWand *,const ColorspaceType),
MagickTransposeImage(MagickWand *),
MagickTransverseImage(MagickWand *),
MagickThresholdImage(MagickWand *,const double),
MagickThresholdImageChannel(MagickWand *,const ChannelType,const double),
MagickThumbnailImage(MagickWand *,const size_t,const size_t),
MagickTrimImage(MagickWand *,const double),
MagickUniqueImageColors(MagickWand *),
MagickUnsharpMaskImage(MagickWand *,const double,const double,const double,
const double),
MagickUnsharpMaskImageChannel(MagickWand *,const ChannelType,const double,
const double,const double,const double),
MagickVignetteImage(MagickWand *,const double,const double,const ssize_t,
const ssize_t),
MagickWaveImage(MagickWand *,const double,const double),
MagickWhiteThresholdImage(MagickWand *,const PixelWand *),
MagickWriteImage(MagickWand *,const char *),
MagickWriteImageFile(MagickWand *,FILE *),
MagickWriteImages(MagickWand *,const char *,const MagickBooleanType),
MagickWriteImagesFile(MagickWand *,FILE *);
extern WandExport MagickProgressMonitor
MagickSetImageProgressMonitor(MagickWand *,const MagickProgressMonitor,
void *);
extern WandExport MagickWand
*MagickAppendImages(MagickWand *,const MagickBooleanType),
*MagickCoalesceImages(MagickWand *),
*MagickCombineImages(MagickWand *,const ChannelType),
*MagickCompareImageChannels(MagickWand *,const MagickWand *,const ChannelType,
const MetricType,double *),
*MagickCompareImages(MagickWand *,const MagickWand *,const MetricType,
double *),
*MagickCompareImageLayers(MagickWand *,const ImageLayerMethod),
*MagickDeconstructImages(MagickWand *),
*MagickEvaluateImages(MagickWand *,const MagickEvaluateOperator),
*MagickFxImage(MagickWand *,const char *),
*MagickFxImageChannel(MagickWand *,const ChannelType,const char *),
*MagickGetImage(MagickWand *),
*MagickGetImageClipMask(MagickWand *),
*MagickGetImageRegion(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t),
*MagickMergeImageLayers(MagickWand *,const ImageLayerMethod),
*MagickMorphImages(MagickWand *,const size_t),
*MagickMontageImage(MagickWand *,const DrawingWand *,const char *,
const char *,const MontageMode,const char *),
*MagickOptimizeImageLayers(MagickWand *),
*MagickPreviewImages(MagickWand *wand,const PreviewType),
*MagickSimilarityImage(MagickWand *,const MagickWand *,RectangleInfo *,
double *),
*MagickSmushImages(MagickWand *,const MagickBooleanType,const ssize_t),
*MagickSteganoImage(MagickWand *,const MagickWand *,const ssize_t),
*MagickStereoImage(MagickWand *,const MagickWand *),
*MagickTextureImage(MagickWand *,const MagickWand *),
*MagickTransformImage(MagickWand *,const char *,const char *);
extern WandExport OrientationType
MagickGetImageOrientation(MagickWand *);
extern WandExport PixelWand
**MagickGetImageHistogram(MagickWand *,size_t *);
extern WandExport RenderingIntent
MagickGetImageRenderingIntent(MagickWand *);
extern WandExport ResolutionType
MagickGetImageUnits(MagickWand *);
extern WandExport size_t
MagickGetImageColors(MagickWand *),
MagickGetImageCompressionQuality(MagickWand *),
MagickGetImageDelay(MagickWand *),
MagickGetImageChannelDepth(MagickWand *,const ChannelType),
MagickGetImageDepth(MagickWand *),
MagickGetImageHeight(MagickWand *),
MagickGetImageIterations(MagickWand *),
MagickGetImageScene(MagickWand *),
MagickGetImageTicksPerSecond(MagickWand *),
MagickGetImageWidth(MagickWand *),
MagickGetNumberImages(MagickWand *);
extern WandExport unsigned char
*MagickGetImageBlob(MagickWand *,size_t *),
*MagickGetImagesBlob(MagickWand *,size_t *);
extern WandExport VirtualPixelMethod
MagickGetImageVirtualPixelMethod(MagickWand *),
MagickSetImageVirtualPixelMethod(MagickWand *,const VirtualPixelMethod);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/drawing-wand.h 0000644 00000023305 14751151177 0010244 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand drawing wand methods.
*/
#ifndef MAGICKWAND_DRAWING_WAND_H
#define MAGICKWAND_DRAWING_WAND_H
#include "wand/pixel-wand.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _DrawingWand
DrawingWand;
extern WandExport AlignType
DrawGetTextAlignment(const DrawingWand *);
extern WandExport char
*DrawGetClipPath(const DrawingWand *),
*DrawGetDensity(const DrawingWand *),
*DrawGetException(const DrawingWand *,ExceptionType *),
*DrawGetFont(const DrawingWand *),
*DrawGetFontFamily(const DrawingWand *),
*DrawGetTextEncoding(const DrawingWand *),
*DrawGetVectorGraphics(DrawingWand *);
extern WandExport ClipPathUnits
DrawGetClipUnits(const DrawingWand *) magick_attribute((__pure__));
extern WandExport DecorationType
DrawGetTextDecoration(const DrawingWand *) magick_attribute((__pure__));
extern WandExport DirectionType
DrawGetTextDirection(const DrawingWand *);
extern WandExport double
DrawGetFillOpacity(const DrawingWand *) magick_attribute((__pure__)),
DrawGetFontSize(const DrawingWand *) magick_attribute((__pure__)),
DrawGetOpacity(const DrawingWand *) magick_attribute((__pure__)),
*DrawGetStrokeDashArray(const DrawingWand *,size_t *),
DrawGetStrokeDashOffset(const DrawingWand *) magick_attribute((__pure__)),
DrawGetStrokeOpacity(const DrawingWand *) magick_attribute((__pure__)),
DrawGetStrokeWidth(const DrawingWand *) magick_attribute((__pure__)),
DrawGetTextKerning(DrawingWand *) magick_attribute((__pure__)),
DrawGetTextInterlineSpacing(DrawingWand *) magick_attribute((__pure__)),
DrawGetTextInterwordSpacing(DrawingWand *) magick_attribute((__pure__));
extern WandExport DrawInfo
*PeekDrawingWand(const DrawingWand *);
extern WandExport DrawingWand
*AcquireDrawingWand(const DrawInfo *,Image *),
*CloneDrawingWand(const DrawingWand *),
*DestroyDrawingWand(DrawingWand *),
*NewDrawingWand(void);
extern WandExport ExceptionType
DrawGetExceptionType(const DrawingWand *);
extern WandExport FillRule
DrawGetClipRule(const DrawingWand *) magick_attribute((__pure__)),
DrawGetFillRule(const DrawingWand *) magick_attribute((__pure__));
extern WandExport GravityType
DrawGetGravity(const DrawingWand *) magick_attribute((__pure__));
extern WandExport LineCap
DrawGetStrokeLineCap(const DrawingWand *) magick_attribute((__pure__));
extern WandExport LineJoin
DrawGetStrokeLineJoin(const DrawingWand *) magick_attribute((__pure__));
extern WandExport MagickBooleanType
DrawClearException(DrawingWand *),
DrawComposite(DrawingWand *,const CompositeOperator,const double,const double,
const double,const double,MagickWand *),
DrawGetFontResolution(const DrawingWand *,double *,double *),
DrawGetStrokeAntialias(const DrawingWand *) magick_attribute((__pure__)),
DrawGetTextAntialias(const DrawingWand *) magick_attribute((__pure__)),
DrawPopPattern(DrawingWand *),
DrawPushPattern(DrawingWand *,const char *,const double,const double,
const double,const double),
DrawRender(DrawingWand *),
DrawSetClipPath(DrawingWand *,const char *),
DrawSetDensity(DrawingWand *,const char *),
DrawSetFillPatternURL(DrawingWand *,const char *),
DrawSetFont(DrawingWand *,const char *),
DrawSetFontFamily(DrawingWand *,const char *),
DrawSetFontResolution(DrawingWand *,const double,const double),
DrawSetStrokeDashArray(DrawingWand *,const size_t,const double *),
DrawSetStrokePatternURL(DrawingWand *,const char *),
DrawSetVectorGraphics(DrawingWand *,const char *),
IsDrawingWand(const DrawingWand *),
PopDrawingWand(DrawingWand *),
PushDrawingWand(DrawingWand *);
extern WandExport StretchType
DrawGetFontStretch(const DrawingWand *);
extern WandExport StyleType
DrawGetFontStyle(const DrawingWand *);
extern WandExport size_t
DrawGetFontWeight(const DrawingWand *) magick_attribute((__pure__)),
DrawGetStrokeMiterLimit(const DrawingWand *) magick_attribute((__pure__));
extern WandExport void
ClearDrawingWand(DrawingWand *),
DrawAffine(DrawingWand *,const AffineMatrix *),
DrawAnnotation(DrawingWand *,const double,const double,const unsigned char *),
DrawArc(DrawingWand *,const double,const double,const double,const double,
const double,const double),
DrawBezier(DrawingWand *,const size_t,const PointInfo *),
DrawGetBorderColor(const DrawingWand *,PixelWand *),
DrawCircle(DrawingWand *,const double,const double,const double,const double),
DrawColor(DrawingWand *,const double,const double,const PaintMethod),
DrawComment(DrawingWand *,const char *),
DrawEllipse(DrawingWand *,const double,const double,const double,const double,
const double,const double),
DrawGetFillColor(const DrawingWand *,PixelWand *),
DrawGetStrokeColor(const DrawingWand *,PixelWand *),
DrawSetTextKerning(DrawingWand *,const double),
DrawSetTextInterlineSpacing(DrawingWand *,const double),
DrawSetTextInterwordSpacing(DrawingWand *,const double),
DrawGetTextUnderColor(const DrawingWand *,PixelWand *),
DrawLine(DrawingWand *,const double, const double,const double,const double),
DrawMatte(DrawingWand *,const double,const double,const PaintMethod),
DrawPathClose(DrawingWand *),
DrawPathCurveToAbsolute(DrawingWand *,const double,const double,const double,
const double,const double,const double),
DrawPathCurveToRelative(DrawingWand *,const double,const double,const double,
const double,const double, const double),
DrawPathCurveToQuadraticBezierAbsolute(DrawingWand *,const double,
const double,const double,const double),
DrawPathCurveToQuadraticBezierRelative(DrawingWand *,const double,
const double,const double,const double),
DrawPathCurveToQuadraticBezierSmoothAbsolute(DrawingWand *,const double,
const double),
DrawPathCurveToQuadraticBezierSmoothRelative(DrawingWand *,const double,
const double),
DrawPathCurveToSmoothAbsolute(DrawingWand *,const double,const double,
const double,const double),
DrawPathCurveToSmoothRelative(DrawingWand *,const double,const double,
const double,const double),
DrawPathEllipticArcAbsolute(DrawingWand *,const double,const double,
const double,const MagickBooleanType,const MagickBooleanType,const double,
const double),
DrawPathEllipticArcRelative(DrawingWand *,const double,const double,
const double,const MagickBooleanType,const MagickBooleanType,const double,
const double),
DrawPathFinish(DrawingWand *),
DrawPathLineToAbsolute(DrawingWand *,const double,const double),
DrawPathLineToRelative(DrawingWand *,const double,const double),
DrawPathLineToHorizontalAbsolute(DrawingWand *,const double),
DrawPathLineToHorizontalRelative(DrawingWand *,const double),
DrawPathLineToVerticalAbsolute(DrawingWand *,const double),
DrawPathLineToVerticalRelative(DrawingWand *,const double),
DrawPathMoveToAbsolute(DrawingWand *,const double,const double),
DrawPathMoveToRelative(DrawingWand *,const double,const double),
DrawPathStart(DrawingWand *),
DrawPoint(DrawingWand *,const double,const double),
DrawPolygon(DrawingWand *,const size_t,const PointInfo *),
DrawPolyline(DrawingWand *,const size_t,const PointInfo *),
DrawPopClipPath(DrawingWand *),
DrawPopDefs(DrawingWand *),
DrawPushClipPath(DrawingWand *,const char *),
DrawPushDefs(DrawingWand *),
DrawRectangle(DrawingWand *,const double,const double,const double,
const double),
DrawResetVectorGraphics(DrawingWand *),
DrawRotate(DrawingWand *,const double),
DrawRoundRectangle(DrawingWand *,double,double,double,double,double,double),
DrawScale(DrawingWand *,const double,const double),
DrawSetBorderColor(DrawingWand *,const PixelWand *),
DrawSetClipRule(DrawingWand *,const FillRule),
DrawSetClipUnits(DrawingWand *,const ClipPathUnits),
DrawSetFillColor(DrawingWand *,const PixelWand *),
DrawSetFillOpacity(DrawingWand *,const double),
DrawSetFillRule(DrawingWand *,const FillRule),
DrawSetFontSize(DrawingWand *,const double),
DrawSetFontStretch(DrawingWand *,const StretchType),
DrawSetFontStyle(DrawingWand *,const StyleType),
DrawSetFontWeight(DrawingWand *,const size_t),
DrawSetGravity(DrawingWand *,const GravityType),
DrawSetOpacity(DrawingWand *,const double),
DrawSetStrokeAntialias(DrawingWand *,const MagickBooleanType),
DrawSetStrokeColor(DrawingWand *,const PixelWand *),
DrawSetStrokeDashOffset(DrawingWand *,const double dashoffset),
DrawSetStrokeLineCap(DrawingWand *,const LineCap),
DrawSetStrokeLineJoin(DrawingWand *,const LineJoin),
DrawSetStrokeMiterLimit(DrawingWand *,const size_t),
DrawSetStrokeOpacity(DrawingWand *, const double),
DrawSetStrokeWidth(DrawingWand *,const double),
DrawSetTextAlignment(DrawingWand *,const AlignType),
DrawSetTextAntialias(DrawingWand *,const MagickBooleanType),
DrawSetTextDecoration(DrawingWand *,const DecorationType),
DrawSetTextDirection(DrawingWand *,const DirectionType),
DrawSetTextEncoding(DrawingWand *,const char *),
DrawSetTextUnderColor(DrawingWand *,const PixelWand *),
DrawSetViewbox(DrawingWand *,ssize_t,ssize_t,ssize_t,ssize_t),
DrawSkewX(DrawingWand *,const double),
DrawSkewY(DrawingWand *,const double),
DrawTranslate(DrawingWand *,const double,const double);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/mogrify.h 0000644 00000002735 14751151177 0007342 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand mogrify command-line method.
*/
#ifndef MAGICKWAND_MOGRIFY_H
#define MAGICKWAND_MOGRIFY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef MagickBooleanType
(*MagickCommand)(ImageInfo *,int,char **,char **,ExceptionInfo *);
extern WandExport MagickBooleanType
MagickCommandGenesis(ImageInfo *,MagickCommand,int,char **,char **,
ExceptionInfo *),
MogrifyImage(ImageInfo *,const int,const char **,Image **,ExceptionInfo *),
MogrifyImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *),
MogrifyImageInfo(ImageInfo *,const int,const char **,ExceptionInfo *),
MogrifyImageList(ImageInfo *,const int,const char **,Image **,
ExceptionInfo *),
MogrifyImages(ImageInfo *,const MagickBooleanType,const int,const char **,
Image **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/montage.h 0000644 00000001707 14751151177 0007316 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand montage command-line method.
*/
#ifndef MAGICKWAND_MONTAGE_H
#define MAGICKWAND_MONTAGE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
MontageImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/conjure.h 0000644 00000001707 14751151177 0007331 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand conjure command-line method.
*/
#ifndef MAGICKWAND_CONJURE_H
#define MAGICKWAND_CONJURE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
ConjureImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/magick-property.h 0000644 00000012601 14751151177 0010774 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand property, options, and profile methods.
*/
#ifndef MAGICKWAND_MAGICK_PROPERTY_H
#define MAGICKWAND_MAGICK_PROPERTY_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport char
*MagickGetFilename(const MagickWand *),
*MagickGetFormat(MagickWand *),
*MagickGetFont(MagickWand *),
*MagickGetHomeURL(void),
*MagickGetImageArtifact(MagickWand *,const char *),
**MagickGetImageArtifacts(MagickWand *,const char *,size_t *),
**MagickGetImageProfiles(MagickWand *,const char *,size_t *),
*MagickGetImageProperty(MagickWand *,const char *),
**MagickGetImageProperties(MagickWand *,const char *,size_t *),
*MagickGetOption(MagickWand *,const char *),
**MagickGetOptions(MagickWand *,const char *,size_t *),
*MagickQueryConfigureOption(const char *),
**MagickQueryConfigureOptions(const char *,size_t *),
**MagickQueryFonts(const char *,size_t *),
**MagickQueryFormats(const char *,size_t *);
extern WandExport ColorspaceType
MagickGetColorspace(MagickWand *);
extern WandExport CompressionType
MagickGetCompression(MagickWand *);
extern WandExport const char
*MagickGetCopyright(void),
*MagickGetPackageName(void),
*MagickGetQuantumDepth(size_t *),
*MagickGetQuantumRange(size_t *),
*MagickGetReleaseDate(void),
*MagickGetVersion(size_t *);
extern WandExport double
MagickGetPointsize(MagickWand *),
*MagickGetSamplingFactors(MagickWand *,size_t *),
*MagickQueryFontMetrics(MagickWand *,const DrawingWand *,const char *),
*MagickQueryMultilineFontMetrics(MagickWand *,const DrawingWand *,
const char *);
extern WandExport GravityType
MagickGetGravity(MagickWand *);
extern WandExport ImageType
MagickGetType(MagickWand *);
extern WandExport InterlaceType
MagickGetInterlaceScheme(MagickWand *);
extern WandExport InterpolatePixelMethod
MagickGetInterpolateMethod(MagickWand *);
extern WandExport OrientationType
MagickGetOrientation(MagickWand *);
extern WandExport MagickBooleanType
MagickDeleteImageArtifact(MagickWand *,const char *),
MagickDeleteImageProperty(MagickWand *,const char *),
MagickDeleteOption(MagickWand *,const char *),
MagickGetAntialias(const MagickWand *),
MagickGetPage(const MagickWand *,size_t *,size_t *,ssize_t *,ssize_t *),
MagickGetResolution(const MagickWand *,double *,double *),
MagickGetSize(const MagickWand *,size_t *,size_t *),
MagickGetSizeOffset(const MagickWand *,ssize_t *),
MagickProfileImage(MagickWand *,const char *,const void *,const size_t),
MagickSetAntialias(MagickWand *,const MagickBooleanType),
MagickSetBackgroundColor(MagickWand *,const PixelWand *),
MagickSetColorspace(MagickWand *,const ColorspaceType),
MagickSetCompression(MagickWand *,const CompressionType),
MagickSetCompressionQuality(MagickWand *,const size_t),
MagickSetDepth(MagickWand *,const size_t),
MagickSetExtract(MagickWand *,const char *),
MagickSetFilename(MagickWand *,const char *),
MagickSetFormat(MagickWand *,const char *),
MagickSetFont(MagickWand *,const char *),
MagickSetGravity(MagickWand *,const GravityType),
MagickSetImageArtifact(MagickWand *,const char *,const char *),
MagickSetImageProfile(MagickWand *,const char *,const void *,const size_t),
MagickSetImageProperty(MagickWand *,const char *,const char *),
MagickSetInterlaceScheme(MagickWand *,const InterlaceType),
MagickSetInterpolateMethod(MagickWand *,const InterpolatePixelMethod),
MagickSetOption(MagickWand *,const char *,const char *),
MagickSetOrientation(MagickWand *,const OrientationType),
MagickSetPage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t),
MagickSetPassphrase(MagickWand *,const char *),
MagickSetPointsize(MagickWand *,const double),
MagickSetResolution(MagickWand *,const double,const double),
MagickSetResourceLimit(const ResourceType type,const MagickSizeType limit),
MagickSetSamplingFactors(MagickWand *,const size_t,const double *),
MagickSetSecurityPolicy(MagickWand *,const char *),
MagickSetSize(MagickWand *,const size_t,const size_t),
MagickSetSizeOffset(MagickWand *,const size_t,const size_t,const ssize_t),
MagickSetType(MagickWand *,const ImageType);
extern WandExport MagickProgressMonitor
MagickSetProgressMonitor(MagickWand *,const MagickProgressMonitor,void *);
extern WandExport MagickSizeType
MagickGetResource(const ResourceType),
MagickGetResourceLimit(const ResourceType);
extern WandExport PixelWand
*MagickGetBackgroundColor(MagickWand *);
extern WandExport OrientationType
MagickGetOrientationType(MagickWand *);
extern WandExport size_t
MagickGetCompressionQuality(MagickWand *);
extern WandExport unsigned char
*MagickGetImageProfile(MagickWand *,const char *,size_t *),
*MagickRemoveImageProfile(MagickWand *,const char *,size_t *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/convert.h 0000644 00000001707 14751151177 0007344 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand convert command-line method.
*/
#ifndef MAGICKWAND_CONVERT_H
#define MAGICKWAND_CONVERT_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
extern WandExport MagickBooleanType
ConvertImageCommand(ImageInfo *,int,char **,char **,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif
wand/pixel-wand.h 0000644 00000010772 14751151177 0007736 0 ustar 00 /*
Copyright 1999 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License. You may
obtain a copy of the License at
https://imagemagick.org/script/license.php
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
MagickWand pixel wand methods.
*/
#ifndef MAGICKWAND_PIXEL_WAND_H
#define MAGICKWAND_PIXEL_WAND_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _PixelWand
PixelWand;
extern WandExport char
*PixelGetColorAsNormalizedString(const PixelWand *),
*PixelGetColorAsString(const PixelWand *),
*PixelGetException(const PixelWand *,ExceptionType *);
extern WandExport double
PixelGetAlpha(const PixelWand *) magick_attribute((__pure__)),
PixelGetBlack(const PixelWand *) magick_attribute((__pure__)),
PixelGetBlue(const PixelWand *) magick_attribute((__pure__)),
PixelGetCyan(const PixelWand *) magick_attribute((__pure__)),
PixelGetFuzz(const PixelWand *) magick_attribute((__pure__)),
PixelGetGreen(const PixelWand *) magick_attribute((__pure__)),
PixelGetMagenta(const PixelWand *) magick_attribute((__pure__)),
PixelGetOpacity(const PixelWand *) magick_attribute((__pure__)),
PixelGetRed(const PixelWand *) magick_attribute((__pure__)),
PixelGetYellow(const PixelWand *) magick_attribute((__pure__));
extern WandExport ExceptionType
PixelGetExceptionType(const PixelWand *);
extern WandExport IndexPacket
PixelGetIndex(const PixelWand *);
extern WandExport MagickBooleanType
IsPixelWand(const PixelWand *),
IsPixelWandSimilar(PixelWand *,PixelWand *,const double),
PixelClearException(PixelWand *),
PixelSetColor(PixelWand *,const char *);
extern WandExport PixelWand
*ClonePixelWand(const PixelWand *),
**ClonePixelWands(const PixelWand **,const size_t),
*DestroyPixelWand(PixelWand *),
**DestroyPixelWands(PixelWand **,const size_t),
*NewPixelWand(void),
**NewPixelWands(const size_t);
extern WandExport Quantum
PixelGetAlphaQuantum(const PixelWand *) magick_attribute((__pure__)),
PixelGetBlackQuantum(const PixelWand *) magick_attribute((__pure__)),
PixelGetBlueQuantum(const PixelWand *) magick_attribute((__pure__)),
PixelGetCyanQuantum(const PixelWand *) magick_attribute((__pure__)),
PixelGetGreenQuantum(const PixelWand *) magick_attribute((__pure__)),
PixelGetMagentaQuantum(const PixelWand *) magick_attribute((__pure__)),
PixelGetOpacityQuantum(const PixelWand *) magick_attribute((__pure__)),
PixelGetRedQuantum(const PixelWand *) magick_attribute((__pure__)),
PixelGetYellowQuantum(const PixelWand *) magick_attribute((__pure__));
extern WandExport size_t
PixelGetColorCount(const PixelWand *) magick_attribute((__pure__));
extern WandExport void
ClearPixelWand(PixelWand *),
PixelGetHSL(const PixelWand *,double *,double *,double *),
PixelGetMagickColor(const PixelWand *,MagickPixelPacket *),
PixelGetQuantumColor(const PixelWand *,PixelPacket *),
PixelSetAlpha(PixelWand *,const double),
PixelSetAlphaQuantum(PixelWand *,const Quantum),
PixelSetBlack(PixelWand *,const double),
PixelSetBlackQuantum(PixelWand *,const Quantum),
PixelSetBlue(PixelWand *,const double),
PixelSetBlueQuantum(PixelWand *,const Quantum),
PixelSetColorFromWand(PixelWand *,const PixelWand *),
PixelSetColorCount(PixelWand *,const size_t),
PixelSetCyan(PixelWand *,const double),
PixelSetCyanQuantum(PixelWand *,const Quantum),
PixelSetFuzz(PixelWand *,const double),
PixelSetGreen(PixelWand *,const double),
PixelSetGreenQuantum(PixelWand *,const Quantum),
PixelSetHSL(PixelWand *,const double,const double,const double),
PixelSetIndex(PixelWand *,const IndexPacket),
PixelSetMagenta(PixelWand *,const double),
PixelSetMagentaQuantum(PixelWand *,const Quantum),
PixelSetMagickColor(PixelWand *,const MagickPixelPacket *),
PixelSetOpacity(PixelWand *,const double),
PixelSetOpacityQuantum(PixelWand *,const Quantum),
PixelSetQuantumColor(PixelWand *,const PixelPacket *),
PixelSetRed(PixelWand *,const double),
PixelSetRedQuantum(PixelWand *,const Quantum),
PixelSetYellow(PixelWand *,const double),
PixelSetYellowQuantum(PixelWand *,const Quantum);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif