<?php

//==============================================================================
// Constants

// Quantum color constants

define( 'MW_MaxRGB',						65535 ) ;
define( 'MW_OpaqueOpacity',					0 ) ;
define( 'MW_TransparentOpacity',			65535 ) ;

// AlignType constants

define( 'MW_UndefinedAlign',				Imagick::ALIGN_UNDEFINED ) ;
define( 'MW_LeftAlign',						Imagick::ALIGN_LEFT ) ;
define( 'MW_CenterAlign',					Imagick::ALIGN_CENTER ) ;
define( 'MW_RightAlign',					Imagick::ALIGN_RIGHT ) ;

// AlphaChannel constants

// ? define( 'MW_UndefinedAlphaChannel',	Imagick:: ) ;
// ? define( 'MW_ActiveateAlphaChannel',	Imagick:: ) ;
// ? define( 'MW_DeactiveateAlphaChannel',	Imagick:: ) ;
// ? define( 'MW_ResetAlphaChannel',		Imagick:: ) ;
// ? define( 'MW_SetAlphaChannel',			Imagick:: ) ;

// ChannelType constants

define( 'MW_UndefinedChannel',				Imagick::CHANNEL_UNDEFINED ) ;
define( 'MW_RedChannel',					Imagick::CHANNEL_RED ) ;
define( 'MW_CyanChannel',					Imagick::CHANNEL_CYAN ) ;
//define( 'MW_GrayChannel',					Imagick::CHANNEL_GRAY ) ;
define( 'MW_GreenChannel',					Imagick::CHANNEL_GREEN ) ;
define( 'MW_MagentaChannel',				Imagick::CHANNEL_MAGENTA ) ;
define( 'MW_BlueChannel',					Imagick::CHANNEL_BLUE ) ;
define( 'MW_YellowChannel',					Imagick::CHANNEL_YELLOW ) ;
define( 'MW_AlphaChannel',					Imagick::CHANNEL_ALPHA ) ;
define( 'MW_OpacityChannel',				Imagick::CHANNEL_OPACITY ) ;
//define( 'MW_MatteChannel',				Imagick::CHANNEL_MATTE ) ;
define( 'MW_BlackChannel',					Imagick::CHANNEL_BLACK ) ;
define( 'MW_IndexChannel',					Imagick::CHANNEL_INDEX ) ;
define( 'MW_AllChannel',					Imagick::CHANNEL_ALL ) ;

// ClipPathUnits constants

define( 'MW_UndefinedPathUnits',			Imagick::PATHUNITS_UNDEFINED ) ;
define( 'MW_UserSpace',						Imagick::PATHUNITS_USERSPACE ) ;
define( 'MW_UserSpaceonUse',				Imagick::PATHUNITS_USERSPACEONUSE ) ;
define( 'MW_ObjectBoundingBox',				Imagick::PATHUNITS_OBJECTBOUNDINGBOX ) ;

// ColorspaceType constants

define( 'MW_UndefinedColorSpace',			Imagick::COLORSPACE_UNDEFINED ) ;
define( 'MW_RGBColorSpace',					Imagick::COLORSPACE_RGB ) ;
define( 'MW_GRAYColorSpace',				Imagick::COLORSPACE_GRAY ) ;
define( 'MW_TransparentColorSpace',			Imagick::COLORSPACE_TRANSPARENT ) ;
define( 'MW_OHTAColorSpace',				Imagick::COLORSPACE_OHTA ) ;
define( 'MW_LABColorSpace',					Imagick::COLORSPACE_LAB ) ;
define( 'MW_XYZColorSpace',					Imagick::COLORSPACE_XYZ ) ;
define( 'MW_YCbCrColorSpace',				Imagick::COLORSPACE_YCBCR ) ;
define( 'MW_YCCColorSpace',					Imagick::COLORSPACE_YCC ) ;
define( 'MW_YIQColorSpace',					Imagick::COLORSPACE_YIQ ) ;
define( 'MW_YPbPrColorSpace',				Imagick::COLORSPACE_YPBPR ) ;
define( 'MW_YUVColorSpace',					Imagick::COLORSPACE_YUV ) ;
define( 'MW_CMYKColorSpace',				Imagick::COLORSPACE_CMYK ) ;
define( 'MW_sRGBColorSpace',				Imagick::COLORSPACE_SRGB ) ;
define( 'MW_HSBColorSpace',					Imagick::COLORSPACE_HSB ) ;
define( 'MW_HSLColorSpace',					Imagick::COLORSPACE_HSL ) ;
define( 'MW_HWBColorSpace',					Imagick::COLORSPACE_HWB ) ;
//define( 'MW_Rec601LumaColorSpace',		Imagick::COLORSPACE_REC601LUMA ) ;
//define( 'MW_Rec709LumaColorSpace',		Imagick::COLORSPACE_REC709LUMA ) ;
//define( 'MW_LOGColorSpace',				Imagick::COLORSPACE_LOG ) ;

// CompositeOperator constants

define( 'MW_UndefinedCompositeOp',			Imagick::COMPOSITE_UNDEFINED ) ;
define( 'MW_NoCompositeOp',					Imagick::COMPOSITE_NO ) ;
define( 'MW_AddCompositeOp',				Imagick::COMPOSITE_ADD ) ;
define( 'MW_AtopCompositeOp',				Imagick::COMPOSITE_ATOP ) ;
define( 'MW_BlendCompositeOp',				Imagick::COMPOSITE_BLEND ) ;
define( 'MW_BumpmapCompositeOp',			Imagick::COMPOSITE_BUMPMAP ) ;
define( 'MW_ClearCompositeOp',				Imagick::COMPOSITE_CLEAR ) ;
define( 'MW_ColorBurnCompositeOp',			Imagick::COMPOSITE_COLORBURN ) ;
define( 'MW_ColorDodgeCompositeOp',			Imagick::COMPOSITE_COLORDODGE ) ;
define( 'MW_ColorizeCompositeOp',			Imagick::COMPOSITE_COLORIZE ) ;
define( 'MW_CopyBlackCompositeOp',			Imagick::COMPOSITE_COPYBLACK ) ;
define( 'MW_CopyBlueCompositeOp',			Imagick::COMPOSITE_COPYBLUE ) ;
define( 'MW_CopyCompositeOp',				Imagick::COMPOSITE_COPY ) ;
define( 'MW_CopyCyanCompositeOp',			Imagick::COMPOSITE_COPYCYAN ) ;
define( 'MW_CopyGreenCompositeOp',			Imagick::COMPOSITE_COPYGREEN ) ;
define( 'MW_CopyMagentaCompositeOp',		Imagick::COMPOSITE_COPYMAGENTA ) ;
define( 'MW_CopyOpacityCompositeOp',		Imagick::COMPOSITE_COPYOPACITY ) ;
define( 'MW_CopyRedCompositeOp',			Imagick::COMPOSITE_COPYRED ) ;
define( 'MW_CopyYellowCompositeOp',			Imagick::COMPOSITE_COPYYELLOW ) ;
define( 'MW_DarkenCompositeOp',				Imagick::COMPOSITE_DARKEN ) ;
define( 'MW_DstAtopCompositeOp',			Imagick::COMPOSITE_DSTATOP ) ;
define( 'MW_DstCompositeOp',				Imagick::COMPOSITE_DST ) ;
define( 'MW_DstInCompositeOp',				Imagick::COMPOSITE_DSTIN ) ;
define( 'MW_DstOutCompositeOp',				Imagick::COMPOSITE_DSTOUT ) ;
define( 'MW_DstOverCompositeOp',			Imagick::COMPOSITE_DSTOVER ) ;
define( 'MW_DifferenceCompositeOp',			Imagick::COMPOSITE_DIFFERENCE ) ;
define( 'MW_DisplaceCompositeOp',			Imagick::COMPOSITE_DISPLACE ) ;
define( 'MW_DissolveCompositeOp',			Imagick::COMPOSITE_DISSOLVE ) ;
define( 'MW_ExclusionCompositeOp',			Imagick::COMPOSITE_EXCLUSION ) ;
define( 'MW_HardLightCompositeOp',			Imagick::COMPOSITE_HARDLIGHT ) ;
define( 'MW_HueCompositeOp',				Imagick::COMPOSITE_HUE ) ;
define( 'MW_InCompositeOp',					Imagick::COMPOSITE_IN ) ;
define( 'MW_LightenCompositeOp',			Imagick::COMPOSITE_LIGHTEN ) ;
define( 'MW_LuminizeCompositeOp',			Imagick::COMPOSITE_LUMINIZE ) ;
define( 'MW_MinusCompositeOp',				Imagick::COMPOSITE_MINUS ) ;
define( 'MW_ModulateCompositeOp',			Imagick::COMPOSITE_MODULATE ) ;
define( 'MW_MultiplyCompositeOp',			Imagick::COMPOSITE_MULTIPLY ) ;
define( 'MW_OutCompositeOp',				Imagick::COMPOSITE_OUT ) ;
define( 'MW_OverCompositeOp',				Imagick::COMPOSITE_OVER ) ;
define( 'MW_OverlayCompositeOp',			Imagick::COMPOSITE_OVERLAY ) ;
define( 'MW_PlusCompositeOp',				Imagick::COMPOSITE_PLUS ) ;
define( 'MW_ReplaceCompositeOp',			Imagick::COMPOSITE_REPLACE ) ;
define( 'MW_SaturateCompositeOp',			Imagick::COMPOSITE_SATURATE ) ;
define( 'MW_ScreenCompositeOp',				Imagick::COMPOSITE_SCREEN ) ;
define( 'MW_SoftLightCompositeOp',			Imagick::COMPOSITE_SOFTLIGHT ) ;
define( 'MW_SrcAtopCompositeOp',			Imagick::COMPOSITE_SRCATOP ) ;
define( 'MW_SrcCompositeOp',				Imagick::COMPOSITE_SRC ) ;
define( 'MW_SrcInCompositeOp',				Imagick::COMPOSITE_SRCIN ) ;
define( 'MW_SrcOutCompositeOp',				Imagick::COMPOSITE_SRCOUT ) ;
define( 'MW_SrcOverCompositeOp',			Imagick::COMPOSITE_SRCOVER ) ;
define( 'MW_SubtractCompositeOp',			Imagick::COMPOSITE_SUBTRACT ) ;
define( 'MW_ThresholdCompositeOp',			Imagick::COMPOSITE_THRESHOLD ) ;
define( 'MW_XorCompositeOp',				Imagick::COMPOSITE_XOR ) ;

// CompressionType constants

define( 'MW_UndefinedCompression',			Imagick::COMPRESSION_UNDEFINED ) ;
define( 'MW_NoCompression',					Imagick::COMPRESSION_NO ) ;
define( 'MW_BZipCompression',				Imagick::COMPRESSION_BZIP ) ;
define( 'MW_FaxCompression',				Imagick::COMPRESSION_FAX ) ;
define( 'MW_Group4Compression',				Imagick::COMPRESSION_GROUP4 ) ;
define( 'MW_JPEGCompression',				Imagick::COMPRESSION_JPEG ) ;
//define( 'MW_JPEG2000Compression',			Imagick::COMPRESSION_JPEG2000 ) ;
define( 'MW_LosslessJPEGCompression',		Imagick::COMPRESSION_LOSSLESSJPEG ) ;
define( 'MW_LZWCompression',				Imagick::COMPRESSION_LZW ) ;
define( 'MW_RLECompression',				Imagick::COMPRESSION_RLE ) ;
define( 'MW_ZipCompression',				Imagick::COMPRESSION_ZIP ) ;

// DecorationType constants

//define( 'MW_UndefinedDecoration',			Imagick::DECORATION_UNDEFINED ) ;
define( 'MW_NoDecoration',					Imagick::DECORATION_NO ) ;
define( 'MW_underlineDecoration',			Imagick::DECORATION_UNDERLINE ) ;
define( 'MW_OverlineDecoration',			Imagick::DECORATION_OVERLINE ) ;
define( 'MW_LineThroughDecoration',			Imagick::DECORATION_LINETROUGH ) ;

// DisposeType constants

define( 'MW_UnrecognizedDispose',			Imagick::DISPOSE_UNRECOGNIZED ) ;
define( 'MW_UndefinedDispose',				Imagick::DISPOSE_UNDEFINED ) ;
define( 'MW_NoneDispose',					Imagick::DISPOSE_NONE ) ;
define( 'MW_BackgroundDispose',				Imagick::DISPOSE_BACKGROUND ) ;
define( 'MW_PreviousDispose',				Imagick::DISPOSE_PREVIOUS ) ;

// ExceptionType constants

/*
define( 'MW_UndefinedException',			Imagick:: ) ;
define( 'MW_WarningException',				Imagick:: ) ;
define( 'MW_ResourceLimitWarning',			Imagick:: ) ;
define( 'MW_TypeWarning',					Imagick:: ) ;
define( 'MW_OptionWarning',					Imagick:: ) ;
define( 'MW_DelegateWarning',				Imagick:: ) ;
define( 'MW_MissingDelegateWarning',		Imagick:: ) ;
define( 'MW_CorruptImageWarning',			Imagick:: ) ;
define( 'MW_FileOpenWarning',				Imagick:: ) ;
define( 'MW_BlobWarning',					Imagick:: ) ;
define( 'MW_StreamWarning',					Imagick:: ) ;
define( 'MW_CacheWarning',					Imagick:: ) ;
define( 'MW_CoderWarning',					Imagick:: ) ;
define( 'MW_ModuleWarning',					Imagick:: ) ;
define( 'MW_DrawWarning',					Imagick:: ) ;
define( 'MW_ImageWarning',					Imagick:: ) ;
define( 'MW_WandWarning',					Imagick:: ) ;
define( 'MW_MonitorWarning',				Imagick:: ) ;
define( 'MW_RegistryWarning',				Imagick:: ) ;
define( 'MW_ConfigureWarning',				Imagick:: ) ;
define( 'MW_ErrorException',				Imagick:: ) ;
define( 'MW_ResourceLimitError',			Imagick:: ) ;
define( 'MW_TypeError',						Imagick:: ) ;
define( 'MW_OptionError',					Imagick:: ) ;
define( 'MW_DelegateError',					Imagick:: ) ;
define( 'MW_MissingDelegateError',			Imagick:: ) ;
define( 'MW_CorruptImageError',				Imagick:: ) ;
define( 'MW_FileOpenError',					Imagick:: ) ;
define( 'MW_BlobError',						Imagick:: ) ;
define( 'MW_StreamError',					Imagick:: ) ;
define( 'MW_CacheError',					Imagick:: ) ;
define( 'MW_CoderError',					Imagick:: ) ;
define( 'MW_ModuleError',					Imagick:: ) ;
define( 'MW_DrawError',						Imagick:: ) ;
define( 'MW_ImageError',					Imagick:: ) ;
define( 'MW_WandError',						Imagick:: ) ;
define( 'MW_MonitorError',					Imagick:: ) ;
define( 'MW_RegistryError',					Imagick:: ) ;
define( 'MW_ConfigureError',				Imagick:: ) ;
define( 'MW_FatalErrorException',			Imagick:: ) ;
define( 'MW_ResourceLimitFatalError',		Imagick:: ) ;
define( 'MW_TypeFatalError',				Imagick:: ) ;
define( 'MW_OptionFatalError',				Imagick:: ) ;
define( 'MW_DelegateFatalError',			Imagick:: ) ;
define( 'MW_MissingDelegateFatalError',		Imagick:: ) ;
define( 'MW_CorruptImageFatalError',		Imagick:: ) ;
define( 'MW_FileOpenFatalError',			Imagick:: ) ;
define( 'MW_BlobFatalError',				Imagick:: ) ;
define( 'MW_StreamFatalError',				Imagick:: ) ;
define( 'MW_CacheFatalError',				Imagick:: ) ;
define( 'MW_CoderFatalError',				Imagick:: ) ;
define( 'MW_ModuleFatalError',				Imagick:: ) ;
define( 'MW_DrawFatalError',				Imagick:: ) ;
define( 'MW_ImageFatalError',				Imagick:: ) ;
define( 'MW_WandFatalError',				Imagick:: ) ;
define( 'MW_MonitorFatalError',				Imagick:: ) ;
define( 'MW_RegistryFatalError',			Imagick:: ) ;
define( 'MW_ConfigureFatalError',			Imagick:: ) ;
*/

// FillRule constants

define( 'MW_UndefinedRule',					Imagick::FILLRULE_UNDEFINED ) ;
define( 'MW_EvenOddRule',					Imagick::FILLRULE_EVENODD ) ;
define( 'MW_NonZeroRule',					Imagick::FILLRULE_NONZERO ) ;

// FilterTypes constants

define( 'MW_UndefinedFilter',				Imagick::FILTER_UNDEFINED ) ;
define( 'MW_PointFilter',					Imagick::FILTER_POINT ) ;
define( 'MW_BoxFilter',						Imagick::FILTER_BOX ) ;
define( 'MW_TriangleFilter',				Imagick::FILTER_TRIANGLE ) ;
define( 'MW_HermiteFilter',					Imagick::FILTER_HERMITE ) ;
define( 'MW_HanningFilter',					Imagick::FILTER_HANNING ) ;
define( 'MW_HammingFilter',					Imagick::FILTER_HAMMING ) ;
define( 'MW_BlackmanFilter',				Imagick::FILTER_BLACKMAN ) ;
define( 'MW_GaussianFilter',				Imagick::FILTER_GAUSSIAN ) ;
define( 'MW_QuadraticFilter',				Imagick::FILTER_QUADRATIC ) ;
define( 'MW_CubicFilter',					Imagick::FILTER_CUBIC ) ;
define( 'MW_CatromFilter',					Imagick::FILTER_CATROM ) ;
define( 'MW_MitchellFilter',				Imagick::FILTER_MITCHELL ) ;
define( 'MW_LanczosFilter',					Imagick::FILTER_LANCZOS ) ;
define( 'MW_BesselFilter',					Imagick::FILTER_BESSEL ) ;
define( 'MW_SincFilter',					Imagick::FILTER_SINC ) ;

// GravityType constants

//define( 'MW_UndefinedGravity',			Imagick::GRAVITY_UNDEFINED ) ;
//define( 'MW_ForgetGravity',				Imagick::GRAVITY_FORGET ) ;
define( 'MW_NorthWestGravity',				Imagick::GRAVITY_NORTHWEST ) ;
define( 'MW_NorthGravity',					Imagick::GRAVITY_NORTH ) ;
define( 'MW_NorthEastGravity',				Imagick::GRAVITY_NORTHEAST ) ;
define( 'MW_WestGravity',					Imagick::GRAVITY_WEST ) ;
define( 'MW_CenterGravity',					Imagick::GRAVITY_CENTER ) ;
define( 'MW_EastGravity',					Imagick::GRAVITY_EAST ) ;
define( 'MW_SouthWestGravity',				Imagick::GRAVITY_SOUTHWEST ) ;
define( 'MW_SouthGravity',					Imagick::GRAVITY_SOUTH ) ;
define( 'MW_SouthEastGravity',				Imagick::GRAVITY_SOUTHEAST ) ;
//define( 'MW_StaticGravity',				Imagick::GRAVITY_STATIC ) ;

// ImageType constants

define( 'MW_UndefinedType',					Imagick::IMGTYPE_UNDEFINED ) ;
define( 'MW_BilevelType',					Imagick::IMGTYPE_BILEVEL ) ;
define( 'MW_GrayscaleType',					Imagick::IMGTYPE_GRAYSCALE ) ;
define( 'MW_GrayscaleMatteType',			Imagick::IMGTYPE_GRAYSCALEMATTE ) ;
define( 'MW_PaletteType',					Imagick::IMGTYPE_PALETTE ) ;
define( 'MW_PaletteMatteType',				Imagick::IMGTYPE_PALETTEMATTE ) ;
define( 'MW_TrueColorType',					Imagick::IMGTYPE_TRUECOLOR ) ;
define( 'MW_TrueColorMatteType',			Imagick::IMGTYPE_TRUECOLORMATTE ) ;
define( 'MW_ColorSeparationType',			Imagick::IMGTYPE_COLORSEPARATION ) ;
define( 'MW_ColorSeparationMatteType',		Imagick::IMGTYPE_COLORSEPARATIONMATTE ) ;
define( 'MW_OptimizeType',					Imagick::IMGTYPE_OPTIMIZE ) ;

// InterlaceType constants

define( 'MW_UndefinedInterlace',			Imagick::INTERLACE_UNDEFINED ) ;
define( 'MW_NoInterlace',					Imagick::INTERLACE_NO ) ;
define( 'MW_LineInterlace',					Imagick::INTERLACE_LINE ) ;
define( 'MW_PlaneInterlace',				Imagick::INTERLACE_PLANE ) ;
define( 'MW_PartitionInterlace',			Imagick::INTERLACE_PARTITION ) ;
//define( 'MW_JPEGInterlace',				Imagick::INTERLACE_JPEG ) ;
//define( 'MW_GIFInterlace',				Imagick::INTERLACE_GIF ) ;
//define( 'MW_PNGInterlace',				Imagick::INTERLACE_PNG ) ;

// LineCap constants

define( 'MW_UndefinedCap',					Imagick::LINECAP_UNDEFINED ) ;
define( 'MW_ButtCap',						Imagick::LINECAP_BUTT ) ;
define( 'MW_RoundCap',						Imagick::LINECAP_ROUND ) ;
define( 'MW_SquareCap',						Imagick::LINECAP_SQUARE ) ;

// LineJoin constants

define( 'MW_UndefinedJoin',					Imagick::LINEJOIN_UNDEFINED ) ;
define( 'MW_MiterJoin',						Imagick::LINEJOIN_MITER ) ;
define( 'MW_RoundJoin',						Imagick::LINEJOIN_ROUND ) ;
define( 'MW_BevelJoin',						Imagick::LINEJOIN_BEVEL ) ;

// MagickEvaluateOperator constants

define( 'MW_UndefinedEvaluateOperator',		Imagick::EVALUATE_UNDEFINED ) ;
define( 'MW_AddEvaluateOperator',			Imagick::EVALUATE_ADD ) ;
define( 'MW_AndEvaluateOperator',			Imagick::EVALUATE_AND ) ;
define( 'MW_DivideEvaluateOperator',		Imagick::EVALUATE_DIVIDE ) ;
define( 'MW_LeftShiftEvaluateOperator',		Imagick::EVALUATE_LEFTSHIFT ) ;
define( 'MW_MaxEvaluateOperator',			Imagick::EVALUATE_MAX ) ;
define( 'MW_MinEvaluateOperator',			Imagick::EVALUATE_MIN ) ;
define( 'MW_MultiplyEvaluateOperator',		Imagick::EVALUATE_MULTIPLY ) ;
define( 'MW_OrEvaluateOperator',			Imagick::EVALUATE_OR ) ;
define( 'MW_RightShiftEvaluateOperator',	Imagick::EVALUATE_RIGHTSHIFT ) ;
define( 'MW_SetEvaluateOperator',			Imagick::EVALUATE_SET ) ;
define( 'MW_SubtractEvaluateOperator',		Imagick::EVALUATE_SUBTRACT ) ;
define( 'MW_XorEvaluateOperator',			Imagick::EVALUATE_XOR ) ;

// MetricType constants

define( 'MW_UndefinedMetric',				Imagick::METRIC_UNDEFINED ) ;
define( 'MW_MeanAbsoluteErrorMetric',		Imagick::METRIC_MEANABSOLUTEERROR ) ;
define( 'MW_MeanSquaredErrorMetric',		Imagick::METRIC_MEANSQUAREERROR ) ;
define( 'MW_PeakAbsoluteErrorMetric',		Imagick::METRIC_PEAKABSOLUTEERROR ) ;
define( 'MW_PeakSignalToNoiseRatioMetric',	Imagick::METRIC_PEAKSIGNALTONOISERATIO ) ;
define( 'MW_RootMeanSquaredErrorMetric',	Imagick::METRIC_ROOTMEANSQUAREDERROR ) ;

// MontageMode constants

// define( 'MW_UndefinedMode',				Imagick::MONTAGEMODE_UNDEFINED ) ;
define( 'MW_FrameMode',						Imagick::MONTAGEMODE_FRAME ) ;
define( 'MW_UnframeMode',					Imagick::MONTAGEMODE_UNFRAME ) ;
define( 'MW_ConcatenateMode',				Imagick::MONTAGEMODE_CONCATENATE ) ;

// NoiseType constants

//define( 'MW_UndefinedNoise',				Imagick::NOISE_UNDEFINED ) ;
define( 'MW_UniformNoise',					Imagick::NOISE_UNIFORM ) ;
define( 'MW_GaussianNoise',					Imagick::NOISE_GAUSSIAN ) ;
define( 'MW_MultiplicativeGaussianNoise',	Imagick::NOISE_MULTIPLICATIVEGAUSSIAN ) ;
define( 'MW_ImpulseNoise',					Imagick::NOISE_IMPULSE ) ;
define( 'MW_LaplacianNoise',				Imagick::NOISE_LAPLACIAN ) ;
define( 'MW_PoissonNoise',					Imagick::NOISE_POISSON ) ;

// PaintMethod constants

//define( 'MW_UndefinedMethod',				Imagick::PAINT_UNDEFINED ) ;
define( 'MW_PointMethod',					Imagick::PAINT_POINT ) ;
define( 'MW_ReplaceMethod',					Imagick::PAINT_REPLACE ) ;
define( 'MW_FloodfillMethod',				Imagick::PAINT_FLOODFILL ) ;
define( 'MW_FillToBorderMethod',			Imagick::PAINT_FILLTOBORDER ) ;
define( 'MW_ResetMethod',					Imagick::PAINT_RESET ) ;

// PreviewType constants

define( 'MW_UndefinedPreview',				Imagick::PREVIEW_UNDEFINED ) ;
define( 'MW_RotatePreview',					Imagick::PREVIEW_ROTATE ) ;
define( 'MW_ShearPreview',					Imagick::PREVIEW_SHEAR ) ;
define( 'MW_RollPreview',					Imagick::PREVIEW_ROLL ) ;
define( 'MW_HuePreview',					Imagick::PREVIEW_HUE ) ;
define( 'MW_SaturationPreview',				Imagick::PREVIEW_SATURATION ) ;
define( 'MW_BrightnessPreview',				Imagick::PREVIEW_BRIGHTNESS ) ;
define( 'MW_GammaPreview',					Imagick::PREVIEW_GAMMA ) ;
define( 'MW_SpiffPreview',					Imagick::PREVIEW_SPIFF ) ;
define( 'MW_DullPreview',					Imagick::PREVIEW_DULL ) ;
define( 'MW_GrayscalePreview',				Imagick::PREVIEW_GRAYSCALE ) ;
define( 'MW_QuantizePreview',				Imagick::PREVIEW_QUANTIZE ) ;
define( 'MW_DespecklePreview',				Imagick::PREVIEW_DESPECKLE ) ;
define( 'MW_ReduceNoisePreview',			Imagick::PREVIEW_REDUCENOISE ) ;
define( 'MW_AddNoisePreview',				Imagick::PREVIEW_ADDNOISE ) ;
define( 'MW_SharpenPreview',				Imagick::PREVIEW_SHARPEN ) ;
define( 'MW_BlurPreview',					Imagick::PREVIEW_BLUR ) ;
define( 'MW_ThresholdPreview',				Imagick::PREVIEW_THRESHOLD ) ;
define( 'MW_EdgeDetectPreview',				Imagick::PREVIEW_EDGEDETECT ) ;
define( 'MW_SpreadPreview',					Imagick::PREVIEW_SPREAD ) ;
define( 'MW_SolarizePreview',				Imagick::PREVIEW_SOLARIZE ) ;
define( 'MW_ShadePreview',					Imagick::PREVIEW_SHADE ) ;
define( 'MW_RaisePreview',					Imagick::PREVIEW_RAISE ) ;
define( 'MW_SegmentPreview',				Imagick::PREVIEW_SEGMENT ) ;
define( 'MW_SwirlPreview',					Imagick::PREVIEW_SWIRL ) ;
define( 'MW_ImplodePreview',				Imagick::PREVIEW_IMPLODE ) ;
define( 'MW_WavePreview',					Imagick::PREVIEW_WAVE ) ;
define( 'MW_OilPaintPreview',				Imagick::PREVIEW_OILPAINT ) ;
define( 'MW_CharcoalDrawingPreview',		Imagick::PREVIEW_CHARCOALDRAWING ) ;
define( 'MW_JPEGPreview',					Imagick::PREVIEW_JPEG ) ;

// RenderingIntent constants

define( 'MW_UndefinedIntent',				Imagick::RENDERINGINTENT_UNDEFINED ) ;
define( 'MW_SaturationIntent',				Imagick::RENDERINGINTENT_SATURATION ) ;
define( 'MW_PerceptualIntent',				Imagick::RENDERINGINTENT_PERCEPTUAL ) ;
define( 'MW_AbsoluteIntent',				Imagick::RENDERINGINTENT_ABSOLUTE ) ;
define( 'MW_RelativeIntent',				Imagick::RENDERINGINTENT_RELATIVE ) ;

// ResolutionType constants

define( 'MW_UndefinedResolution',			Imagick::RESOLUTION_UNDEFINED ) ;
define( 'MW_PixelsPerInchResolution',		Imagick::RESOLUTION_PIXELSPERINCH ) ;
define( 'MW_PixelsPerCentimeterResolution',	Imagick::RESOLUTION_PIXELSPERCENTIMETER ) ;

// ResourceType constants

define( 'MW_UndefinedResource',				Imagick::RESOURCETYPE_UNDEFINED ) ;
define( 'MW_AreaResource',					Imagick::RESOURCETYPE_AREA ) ;
define( 'MW_DiskResource',					Imagick::RESOURCETYPE_DISK ) ;
define( 'MW_FileResource',					Imagick::RESOURCETYPE_FILE ) ;
define( 'MW_MapResource',					Imagick::RESOURCETYPE_MAP ) ;
define( 'MW_MemoryResource',				Imagick::RESOURCETYPE_MEMORY ) ;

// StorageType constants

//define( 'MW_UndefinedPixel',				Imagick::PIXEL_UNDEFINED ) ;
define( 'MW_CharPixel',						Imagick::PIXEL_CHAR ) ;
define( 'MW_ShortPixel',					Imagick::PIXEL_SHORT ) ;
define( 'MW_IntegerPixel',					Imagick::PIXEL_INTEGER ) ;
define( 'MW_LongPixel',						Imagick::PIXEL_LONG ) ;
define( 'MW_FloatPixel',					Imagick::PIXEL_FLOAT ) ;
define( 'MW_DoublePixel',					Imagick::PIXEL_DOUBLE ) ;

// StretchType constants

//define( 'MW_UndefinedStretch',			Imagick::STRETCH_UNDEFINED ) ;
define( 'MW_NormalStretch',					Imagick::STRETCH_NORMAL ) ;
define( 'MW_UltraCondensedStretch',			Imagick::STRETCH_ULTRACONDENSED ) ;
//define( 'MW_ExtraCondensedStretch',		Imagick::STRETCH_EXTRACONDENSED ) ;
define( 'MW_CondensedStretch',				Imagick::STRETCH_CONDENSED ) ;
define( 'MW_SemiCondensedStretch',			Imagick::STRETCH_SEMICONDENSED ) ;
define( 'MW_SemiExpandedStretch',			Imagick::STRETCH_SEMIEXPANDED ) ;
define( 'MW_ExpandedStretch',				Imagick::STRETCH_EXPANDED ) ;
define( 'MW_ExtraExpandedStretch',			Imagick::STRETCH_EXTRAEXPANDED ) ;
define( 'MW_UltraExpandedStretch',			Imagick::STRETCH_ULTRAEXPANDED ) ;
define( 'MW_AnyStretch',					Imagick::STRETCH_ANY ) ;

// StyleType constants

//define( 'MW_UndefinedStyle',				Imagick::STYLE_UNDEFINED ) ;
define( 'MW_NormalStyle',					Imagick::STYLE_NORMAL ) ;
define( 'MW_ItalicStyle',					Imagick::STYLE_ITALIC ) ;
define( 'MW_ObliqueStyle',					Imagick::STYLE_OBLIQUE ) ;
define( 'MW_AnyStyle',						Imagick::STYLE_ANY ) ;

// VirtualPixelMethod constants

define( 'MW_UndefinedVirtualPixelMethod',	Imagick::VIRTUALPIXELMETHOD_UNDEFINED ) ;
//define( 'MW_BackgroundVirtualPixelMethod',	Imagick::VIRTUALPIXELMETHOD_BACKGROUND ) ;
define( 'MW_ConstantVirtualPixelMethod',	Imagick::VIRTUALPIXELMETHOD_CONSTANT ) ;
define( 'MW_EdgeVirtualPixelMethod',		Imagick::VIRTUALPIXELMETHOD_EDGE ) ;
define( 'MW_MirrorVirtualPixelMethod',		Imagick::VIRTUALPIXELMETHOD_MIRROR ) ;
define( 'MW_TileVirtualPixelMethod',		Imagick::VIRTUALPIXELMETHOD_TILE ) ;
//define( 'MW_TransparentVirtualPixelMethod',	Imagick::VIRTUALPIXELMETHOD_TRANSPARENT ) ;


//==============================================================================
// Functions

function ClearDrawingWand( &$ImagickDraw ) {
    return $ImagickDraw->clear() ;
}

function ClearMagickWand( &$Imagick ) {
    return $Imagick->clear() ;
}

function ClearPixelIterator( &$ImagickPixelIterator ) {
    return $ImagickPixelIterator->clear() ;
}

function ClearPixelWand( &$ImagickPixel ) {
    return $ImagickPixel->clear() ;
}

function CloneDrawingWand( &$ImagickDraw ) {
    return $ImagickDraw->clone() ;
}

function CloneMagickWand( &$Imagick ) {
    return $Imagick->clone() ;
}

function DestroyDrawingWand( &$ImagickDraw ) {
    return $ImagickDraw->destroy() ;
}

function DestroyMagickWand( &$Imagick ) {
    return $Imagick->destroy() ;
}

function DestroyPixelIterator( &$ImagickPixelIterator ) {
    return $ImagickPixelIterator->destroy() ;
}

function DestroyPixelWand( &$ImagickPixel ) {
    return $ImagickPixel->destroy() ;
}

function DestroyPixelWandArray( $array ) {
	for ( $n= 0; $n < count( $array ) ; $n++ ) {
		$array[ $n ]->destroy() ;
	}
	
    return true ;
}

function DestroyPixelWands( $array ) {
    return DestroyPixelWandArray( $array ) ;
}

function DrawAffine( &$ImagickDraw, $sx, $sy, $rx, $ry, $tx, $ty ) {
    return $ImagickDraw->affine( array( array( $sx, $sy ), array( $rx, $ry ), array( $tx, $ty ) ) ) ;
}

function DrawAnnotation( &$ImagickDraw, $x, $y, $text ) {
    return $ImagickDraw->annotation( $x, $y, $text ) ;
}

function DrawArc( &$ImagickDraw, $sx, $sy, $ex, $ey, $sd, $ed ) {
    return $ImagickDraw->arc( $sx, $sy, $ex, $ey, $sd, $ed ) ;
}

function DrawBezier( &$ImagickDraw, $coordinates ) {
    return $ImagickDraw->bezier( $coordinates ) ;
}

function DrawCircle( &$ImagickDraw, $ox, $oy, $px, $py ) {
    return $ImagickDraw->circle( $ox, $oy, $px, $py ) ;
}

function DrawColor( &$ImagickDraw, $x, $y, $paintMethod ) {
    return $ImagickDraw->color( $x ,$y ,$paintMethod ) ;
}

function DrawComment( &$ImagickDraw, $comment ) {
    return $ImagickDraw->comment( $comment ) ;
}

function DrawComposite( &$ImagickDraw, $compose, $x, $y, $width, $height, $compositeWand ) {
    return $ImagickDraw->composite( $compose, $x, $y, $width, $height, $compositeWand ) ;
}

function DrawEllipse( &$ImagickDraw, $ox, $oy, $rx, $ry, $start, $end ) {
    return $ImagickDraw->ellipse( $ox, $oy, $rx, $ry, $start, $end ) ;
}

function DrawGetClipPath( &$ImagickDraw ) {
    return $ImagickDraw->getClipPath() ;
}

function DrawGetClipRule( &$ImagickDraw ) {
    return $ImagickDraw->getClipRule() ;
}

function DrawGetClipUnits( &$ImagickDraw ) {
    return $ImagickDraw->getClipUnits() ;
}

/*
function DrawGetException( &$ImagickDraw ) {
    return $ImagickDraw->getException() ;
}

function DrawGetExceptionString( &$ImagickDraw ) {
    return $ImagickDraw->getExceptionString() ;
}

function DrawGetExceptionType( &$ImagickDraw ) {
    return $ImagickDraw->getExceptionType() ;
}
*/

function DrawGetFillAlpha( &$ImagickDraw ) {
    return $ImagickDraw->getFillAlpha() ;
}

function DrawGetFillColor( &$ImagickDraw ) {
    return $ImagickDraw->getFillColor() ;
}

function DrawGetFillOpacity( &$ImagickDraw ) {
    return $ImagickDraw->getFillOpacity() ;
}

function DrawGetFillRule( &$ImagickDraw ) {
    return $ImagickDraw->getFillRule() ;
}

function DrawGetFont( &$ImagickDraw ) {
    return $ImagickDraw->getFont() ;
}

function DrawGetFontFamily( &$ImagickDraw ) {
    return $ImagickDraw->getFontFamily() ;
}

function DrawGetFontSize( &$ImagickDraw ) {
    return $ImagickDraw->getFontSize() ;
}

function DrawGetFontStretch( &$ImagickDraw ) {
    return $ImagickDraw->getFontStretch() ;
}

function DrawGetFontStyle( &$ImagickDraw ) {
    return $ImagickDraw->getFontStyle() ;
}

function DrawGetFontWeight( &$ImagickDraw ) {
    return $ImagickDraw->getFontWeight() ;
}

function DrawGetGravity( &$ImagickDraw ) {
    return $ImagickDraw->getGravity() ;
}

/*
function DrawGetStrokeAlpha( &$ImagickDraw ) {
    return $ImagickDraw->getStrokeAlpha() ;
}
*/

function DrawGetStrokeAntialias( &$ImagickDraw ) {
    return $ImagickDraw->getStrokeAntialias() ;
}

function DrawGetStrokeColor( &$ImagickDraw, $ImagickPixel ) {
    return $ImagickDraw->getStrokeColor( $ImagickPixel ) ;
}

function DrawGetStrokeDashArray( &$ImagickDraw ) {
    return $ImagickDraw->getStrokeDashArray() ;
}

function DrawGetStrokeDashOffset( &$ImagickDraw ) {
    return $ImagickDraw->getStrokeDashOffset() ;
}

function DrawGetStrokeLineCap( &$ImagickDraw ) {
    return $ImagickDraw->getStrokeLineCap() ;
}

function DrawGetStrokeLineJoin( &$ImagickDraw ) {
    return $ImagickDraw->getStrokeLineJoin() ;
}

function DrawGetStrokeMiterLimit( &$ImagickDraw ) {
    return $ImagickDraw->getStrokeMiterLimit() ;
}

function DrawGetStrokeOpacity( &$ImagickDraw ) {
    return $ImagickDraw->getStrokeOpacity() ;
}

function DrawGetStrokeWidth( &$ImagickDraw ) {
    return $ImagickDraw->getStrokeWidth() ;
}

function DrawGetTextAlignment( &$ImagickDraw ) {
    return $ImagickDraw->getTextAlignment() ;
}

function DrawGetTextAntialias( &$ImagickDraw ) {
    return $ImagickDraw->getTextAntialias() ;
}

function DrawGetTextDecoration( &$ImagickDraw ) {
    return $ImagickDraw->getTextDecoration() ;
}

function DrawGetTextEncoding( &$ImagickDraw ) {
    return $ImagickDraw->getTextEncoding() ;
}

function DrawGetTextUnderColor( &$ImagickDraw ) {
    return $ImagickDraw->getTextUnderColor() ;
}

function DrawGetVectorGraphics( &$ImagickDraw ) {
    return $ImagickDraw->getVectorGraphics() ;
}

function DrawLine( &$ImagickDraw, $sx, $sy, $ex, $ey ) {
    return $ImagickDraw->line( $sx, $sy, $ex, $ey ) ;
}

function DrawMatte( &$ImagickDraw, $x, $y, $paintMethod ) {
    return $ImagickDraw->matte( $x, $y, $paintMethod ) ;
}

function DrawPathClose( &$ImagickDraw ) {
    return $ImagickDraw->pathClose() ;
}

function DrawPathCurveToAbsolute( &$ImagickDraw, $x1, $y1, $x2, $y2, $x, $y ) {
    return $ImagickDraw->pathCurveToAbsolute( $x1, $y1, $x2, $y2, $x, $y ) ;
}

function DrawPathCurveToQuadraticBezierAbsolute( &$ImagickDraw, $x1, $y1, $x, $y ) {
    return $ImagickDraw->pathCurveToQuadraticBezierAbsolute( $x1, $y1, $x, $y ) ;
}

function DrawPathCurveToQuadraticBezierRelative( &$ImagickDraw, $x1, $y1, $x, $y ) {
    return $ImagickDraw->pathCurveToQuadraticBezierRelative( $x1, $y1, $x, $y) ;
}

function DrawPathCurveToQuadraticBezierSmoothAbsolute( &$ImagickDraw, $x, $y ) {
    return $ImagickDraw->pathCurveToQuadraticBezierSmoothAbsolute( $x, $y) ;
}

function DrawPathCurveToQuadraticBezierSmoothRelative( &$ImagickDraw, $x, $y ) {
    return $ImagickDraw->pathCurveToQuadraticBezierSmoothRelative( $x, $y) ;
}

function DrawPathCurveToRelative( &$ImagickDraw, $x1, $y1, $x2, $y2, $x, $y ) {
    return $ImagickDraw->pathCurveToRelative( $x1, $y1, $x2, $y2, $x, $y) ;
}

function DrawPathCurveToSmoothAbsolute( &$ImagickDraw, $x2, $y2, $x, $y ) {
    return $ImagickDraw->pathCurveToSmoothAbsolute( $x2, $y2, $x, $y ) ;
}

function DrawPathCurveToSmoothRelative( &$ImagickDraw, $x2, $y2, $x, $y ) {
    return $ImagickDraw->pathCurveToSmoothRelative( $x2, $y2, $x, $y ) ;
}

function DrawPathEllipticArcAbsolute( &$ImagickDraw, $rx, $ry, $x_axis_rotation, $large_arc_flag, $sweep_flag, $x, $y ) {
    return $ImagickDraw->pathEllipticArcAbsolute( $rx, $ry, $x_axis_rotation, $large_arc_flag, $sweep_flag, $x, $y ) ;
}

function DrawPathEllipticArcRelative( &$ImagickDraw, $rx, $ry, $x_axis_rotation, $large_arc_flag, $sweep_flag, $x, $y ) {
    return $ImagickDraw->pathEllipticArcRelative( $rx, $ry, $x_axis_rotation, $large_arc_flag, $sweep_flag, $x, $y ) ;
}

function DrawPathFinish( &$ImagickDraw ) {
    return $ImagickDraw->pathFinish() ;
}

function DrawPathLineToAbsolute( &$ImagickDraw, $x, $y ) {
    return $ImagickDraw->pathLineToAbsolute( $x, $y ) ;
}

function DrawPathLineToHorizontalAbsolute( &$ImagickDraw, $x ) {
    return $ImagickDraw->pathLineToHorizontalAbsolute( $x ) ;
}

function DrawPathLineToHorizontalRelative( &$ImagickDraw, $x ) {
    return $ImagickDraw->pathLineToHorizontalRelative( $x ) ;
}

function DrawPathLineToRelative( &$ImagickDraw, $x, $y ) {
    return $ImagickDraw->pathLineToRelative( $x, $y ) ;
}

function DrawPathLineToVerticalAbsolute( &$ImagickDraw, $y ) {
    return $ImagickDraw->pathLineToVerticalAbsolute( $y ) ;
}

function DrawPathLineToVerticalRelative( &$ImagickDraw, $y ) {
    return $ImagickDraw->pathLineToVerticalRelative( $y ) ;
}

function DrawPathMoveToAbsolute( &$ImagickDraw, $x, $y ) {
    return $ImagickDraw->pathMoveToAbsolute( $x, $y ) ;
}

function DrawPathMoveToRelative( &$ImagickDraw, $x, $y ) {
    return $ImagickDraw->pathMoveToRelative( $x, $y ) ;
}

function DrawPathStart( &$ImagickDraw ) {
    return $ImagickDraw->pathStart() ;
}

function DrawPoint( &$ImagickDraw, $x, $y ) {
    return $ImagickDraw->point( $x, $y ) ;
}

function DrawPolygon( &$ImagickDraw, $coordinates ) {
    return $ImagickDraw->polygon( $coordinates ) ;
}

function DrawPolyline( &$ImagickDraw, $coordinates ) {
    return $ImagickDraw->polyline( $coordinates ) ;
}

function DrawPopClipPath( &$ImagickDraw ) {
    return $ImagickDraw->popClipPath() ;
}

function DrawPopDefs( &$ImagickDraw ) {
    return $ImagickDraw->popDefs() ;
}

function DrawPopPattern( &$ImagickDraw ) {
    return $ImagickDraw->popPattern() ;
}

function DrawPushClipPath( &$ImagickDraw, $clip_mask_id ) {
    return $ImagickDraw->pushClipPath( $clip_mask_id ) ;
}

function DrawPushDefs( &$ImagickDraw ) {
    return $ImagickDraw->pushDefs() ;
}

function DrawPushPattern( &$ImagickDraw ) {
    return $ImagickDraw->pushPattern() ;
}

function DrawRectangle( &$ImagickDraw, $x1, $y1, $x2, $y2 ) {
    return $ImagickDraw->rectangle( $x1, $y1, $x2, $y2 ) ;
}

function DrawRender( &$ImagickDraw ) {
    return $ImagickDraw->render() ;
}

function DrawRotate( &$ImagickDraw, $degrees ) {
    return $ImagickDraw->rotate( $degrees ) ;
}

function DrawRoundRectangle( &$ImagickDraw, $x1, $y1, $x2, $y2, $rx, $ry ) {
    return $ImagickDraw->roundRectangle( $x1, $y1, $x2, $y2, $rx, $ry ) ;
}

function DrawScale( &$ImagickDraw, $x, $y ) {
    return $ImagickDraw->scale( $x, $y ) ;
}

function DrawSetClipPath( &$ImagickDraw, $clip_mask ) {
    return $ImagickDraw->setClipPath( $clip_mask ) ;
}

function DrawSetClipRule( &$ImagickDraw, $fill_rule ) {
    return $ImagickDraw->setClipRule( $fill_rule ) ;
}

function DrawSetClipUnits( &$ImagickDraw, $clip_units ) {
    return $ImagickDraw->setClipUnits( $clip_units ) ;
}

function DrawSetFillAlpha( &$ImagickDraw, $opacity ) {
    return $ImagickDraw->setFillAlpha( $opacity ) ;
}

function DrawSetFillColor( &$ImagickDraw, &$ImagickPixel ) {
    return $ImagickDraw->setFillColor( $ImagickPixel ) ;
}

function DrawSetFillOpacity( &$ImagickDraw, $fillOpacity ) {
    return $ImagickDraw->setFillOpacity( $fillOpacity ) ;
}

function DrawSetFillPatternURL( &$ImagickDraw, $fill_url ) {
    return $ImagickDraw->setFillPatternURL( $fill_url ) ;
}

function DrawSetFillRule( &$ImagickDraw, $fill_rule ) {
    return $ImagickDraw->setFillRule( $fill_rule ) ;
}

function DrawSetFont( &$ImagickDraw, $font_name ) {
    return $ImagickDraw->setFont( $font_name ) ;
}

function DrawSetFontFamily( &$ImagickDraw, $font_family ) {
    return $ImagickDraw->setFontFamily( $font_family ) ;
}

function DrawSetFontSize( &$ImagickDraw, $pointsize ) {
    return $ImagickDraw->setFontSize( $pointsize ) ;
}

function DrawSetFontStretch( &$ImagickDraw, $fontStretch ) {
    return $ImagickDraw->setFontStretch( $fontStretch ) ;
}

function DrawSetFontStyle( &$ImagickDraw, $style ) {
    return $ImagickDraw->setFontStyle( $style ) ;
}

function DrawSetFontWeight( &$ImagickDraw, $font_weight ) {
    return $ImagickDraw->setFontWeight( $font_weight ) ;
}

function DrawSetGravity( &$ImagickDraw, $gravity ) {
    return $ImagickDraw->setGravity( $gravity ) ;
}

function DrawSetStrokeAlpha( &$ImagickDraw, $opacity ) {
    return $ImagickDraw->setStrokeAlpha( $opacity ) ;
}

function DrawSetStrokeAntialias( &$ImagickDraw, $stroke_antialias ) {
    return $ImagickDraw->setStrokeAntialias( $stroke_antialias ) ;
}

function DrawSetStrokeColor( &$ImagickDraw, &$ImagickPixel ) {
    return $ImagickDraw->setStrokeColor( $ImagickPixel ) ;
}

function DrawSetStrokeDashArray( &$ImagickDraw, $dashArray ) {
    return $ImagickDraw->setStrokeDashArray( $dashArray ) ;
}

function DrawSetStrokeDashOffset( &$ImagickDraw, $dash_offset ) {
    return $ImagickDraw->setStrokeDashOffset( $dash_offset ) ;
}

function DrawSetStrokeLineCap( &$ImagickDraw, $linecap ) {
    return $ImagickDraw->setStrokeLineCap( $linecap ) ;
}

function DrawSetStrokeLineJoin( &$ImagickDraw, $linejoin ) {
    return $ImagickDraw->setStrokeLineJoin( $linejoin ) ;
}

function DrawSetStrokeMiterLimit( &$ImagickDraw, $miterlimit ) {
    return $ImagickDraw->setStrokeMiterLimit( $miterlimit ) ;
}

function DrawSetStrokeOpacity( &$ImagickDraw, $stroke_opacity ) {
    return $ImagickDraw->setStrokeOpacity( $stroke_opacity ) ;
}

function DrawSetStrokePatternURL( &$ImagickDraw, $stroke_url ) {
    return $ImagickDraw->setStrokePatternURL( $stroke_url ) ;
}

function DrawSetStrokeWidth( &$ImagickDraw, $stroke_width ) {
    return $ImagickDraw->setStrokeWidth( $stroke_width ) ;
}

function DrawSetTextAlignment( &$ImagickDraw, $alignment ) {
    return $ImagickDraw->setTextAlignment( $alignment ) ;
}

function DrawSetTextAntialias( &$ImagickDraw, $antiAlias ) {
    return $ImagickDraw->setTextAntialias( $antiAlias ) ;
}

function DrawSetTextDecoration( &$ImagickDraw, $decoration ) {
    return $ImagickDraw->setTextDecoration( $decoration ) ;
}

function DrawSetTextEncoding( &$ImagickDraw, $encoding ) {
    return $ImagickDraw->setTextEncoding( $encoding ) ;
}

function DrawSetTextUnderColor( &$ImagickDraw, &$ImagickPixel ) {
    return $ImagickDraw->setTextUnderColor( $ImagickPixel ) ;
}

function DrawSetVectorGraphics( &$ImagickDraw, $xml ) {
    return $ImagickDraw->setVectorGraphics( $xml ) ;
}

function DrawSetViewbox( &$ImagickDraw, $x1, $y1, $x2, $y2 ) {
    return $ImagickDraw->setViewbox( $x1, $y1, $x2, $y2 ) ;
}

function DrawSkewX( &$ImagickDraw, $degrees ) {
    return $ImagickDraw->skewX( $degrees ) ;
}

function DrawSkewY( &$ImagickDraw, $degrees ) {
    return $ImagickDraw->skewY( $degrees ) ;
}

function DrawTranslate( &$ImagickDraw, $x, $y ) {
    return $ImagickDraw->translate( $x, $y ) ;
}

function IsDrawingWand( &$ImagickDraw ) {
    return IsImagickObject( $ImagickDraw, 'ImagickDraw' ) ;
}

function IsMagickWand( &$Imagick ) {
    return IsImagickObject( $Imagick, 'Imagick' ) ;
}

function IsPixelIterator( &$ImagickPixelIterator ) {
    return IsImagickObject( $ImagickPixelIterator, 'ImagickPixelIterator' ) ;
}

function IsPixelWand( &$ImagickPixel ) {
    return IsImagickObject( $ImagickPixel, 'ImagickPixel' ) ;
}

function IsImagickObject( &$object, $name ) {
	if ( ! is_object( $object ) ) return false ;
	if ( get_class( $object ) != $name ) return false ;
    return true ;
}

// �����ޤ�

function MagickAdaptiveThresholdImage( &$Imagick, $width, $height, $offset  ) {
    return $Imagick->adaptiveThresholdImage( $width, $height, $offset ) ;
}

function MagickAddImage( &$Imagick, &$source ) {
    return $Imagick->addImage( $source ) ;
}

function MagickAddNoiseImage( &$Imagick, $noise_type ) {
    return $Imagick->addNoiseImage( $noise_type ) ;
}

function MagickAffineTransformImage( &$Imagick, &$ImagickDraw ) {
    return $Imagick->affineTransformImage( $ImagickDraw ) ;
}

function MagickAnnotateImage( &$Imagick, &$ImagickDraw, $x, $y, $angle , $text ) {
    return $Imagick->annotateImage( $ImagickDraw, $x, $y, $angle , $text ) ;
}

function MagickAppendImages( &$Imagick, $stack ) {
    return $Imagick->appendImages( $stack ) ;
}

function MagickAverageImages( &$Imagick ) {
    return $Imagick->averageImages() ;
}

function MagickBlackThresholdImage( &$Imagick, $threshold ) {
    return $Imagick->blackThresholdImage( $threshold ) ;
}

function MagickBlurImage( &$Imagick, $radius, $sigma, $channel = null ) {
	if ( is_null( $channel ) ) {
	    return $Imagick->blurImage( $radius, $sigma ) ;
	}
	
    return $Imagick->blurImage( $radius, $sigma, $channel ) ;
}

function MagickBorderImage( &$Imagick, $bordercolor, $width, $height  ) {
    return $Imagick->borderImage( $bordercolor, $width, $height ) ;
}

function MagickCharcoalImage( &$Imagick, $radius, $sigma ) {
    return $Imagick->charcoalImage( $radius, $sigma ) ;
}

function MagickChopImage( &$Imagick, $width, $height ,$x, $y ) {
    return $Imagick->chopImage( $width, $height ,$x, $y ) ;
}

function MagickClipImage( &$Imagick ) {
    return $Imagick->clipImage() ;
}

function MagickClipPathImage( &$Imagick, $pathname, $inside ) {
    return $Imagick->clipPathImage( $pathname, $inside ) ;
}

function MagickCoalesceImages( &$Imagick ) {
    return $Imagick->coalesceImages() ;
}

function MagickColorizeImage( &$Imagick, $colorize, $opacity ) {
    return $Imagick->colorizeImage( $colorize, $opacity ) ;
}

function MagickCombineImages( &$Imagick, $channelType ) {
    return $Imagick->combineImages( $channelType ) ;
}

function MagickCommentImage( &$Imagick, $comment ) {
    return $Imagick->commentImage( $comment ) ;
}

function MagickCompareImages( &$Imagick ) {
    return $Imagick->compareImages() ;
}

function MagickCompositeImage( &$Imagick, &$object, $composite, $cols, $rows ) {
    return $Imagick->compositeImage( $object, $composite, $cols, $rows ) ;
}

/*
function MagickConstituteImage( &$Imagick ) {
    return $Imagick->constituteImage() ;
}
*/

function MagickContrastImage( &$Imagick, $sharpen ) {
    return $Imagick->contrastImage( $sharpen ) ;
}

function MagickConvolveImage( &$Imagick, $kernel, $channel = null ) {
	if ( is_null( $channel ) ) {
	    return $Imagick->convolveImage( $kernel ) ;
	}
	
    return $Imagick->convolveImage( $kernel, $channel ) ;
}

function MagickCropImage( &$Imagick, $width, $height, $x, $y ) {
    return $Imagick->cropImage( $width, $height, $x, $y ) ;
}

function MagickCycleColormapImage( &$Imagick, $displace ) {
    return $Imagick->cycleColormapImage( $displace ) ;
}

function MagickDeconstructImages( &$Imagick ) {
    return $Imagick->deconstructImages() ;
}

function MagickDescribeImage( &$Imagick ) {
    return $Imagick->describeImage() ;
}

function MagickDespeckleImage( &$Imagick ) {
    return $Imagick->despeckleImage() ;
}

function MagickDrawImage( &$Imagick, &$ImagickDraw ) {
    return $Imagick->drawImage( $ImagickDraw ) ;
}

function MagickEchoImageBlob( &$Imagick ) {
    echo $Imagick ;
}

/*
function MagickEchoImagesBlob( &$Imagick ) {
    return $Imagick->echoImagesBlob() ;
}
*/

function MagickEdgeImage( &$Imagick, $radius ) {
    return $Imagick->edgeImage( $radius ) ;
}

function MagickEmbossImage( &$Imagick, $radius, $sigma ) {
    return $Imagick->embossImage( $radius, $sigma ) ;
}

function MagickEnhanceImage( &$Imagick ) {
    return $Imagick->enhanceImage() ;
}

function MagickEqualizeImage( &$Imagick ) {
    return $Imagick->equalizeImage() ;
}

function MagickEvaluateImage( &$Imagick, $op, $constant, $channel = null ) {
	if ( is_null( $channel ) ) {
	    return $Imagick->evaluateImage( $op, $constant ) ;
	}
	
    return $Imagick->evaluateImage( $op, $constant, $channel ) ;
}

function MagickFlattenImages( &$Imagick ) {
    return $Imagick->flattenImages() ;
}

function MagickFlipImage( &$Imagick ) {
    return $Imagick->flipImage() ;
}

/*
function MagickFloodfillPaintImage( &$Imagick ) {
    return $Imagick->floodfillPaintImage() ;
}
*/

function MagickFlopImage( &$Imagick ) {
    return $Imagick->flopImage() ;
}

function MagickFrameImage( &$Imagick, $matte_color, $width, $height, $inner_bevel, $outer_bevel ) {
    return $Imagick->frameImage( $matte_color, $width, $height, $inner_bevel, $outer_bevel ) ;
}

function MagickFxImage( &$Imagick, $expression, $channel = null ) {
	if ( is_null( $channel ) ) {
	    return $Imagick->fxImage( $expression ) ;
	}
	
    return $Imagick->fxImage( $expression, $channel ) ;
}

function MagickGammaImage( &$Imagick, $gamma, $channel = null ) {
	if ( is_null( $channel ) ) {
	    return $Imagick->gammaImage( $gamma ) ;
	}
	
    return $Imagick->gammaImage( $gamma, $channel ) ;
}

function MagickGaussianBlurImage( &$Imagick, $radius, $sigma, $channel = null ) {
	if ( is_null( $channel ) ) {
	    return $Imagick->gaussianBlurImage( $radius, $sigma ) ;
	}
	
    return $Imagick->gaussianBlurImage( $radius, $sigma, $channel ) ;
}

/*
function MagickGetCharHeight( &$Imagick ) {
    return $Imagick->getCharHeight() ;
}

function MagickGetCharWidth( &$Imagick ) {
    return $Imagick->getCharWidth() ;
}
*/

function MagickGetCopyright( &$Imagick ) {
    return $Imagick->getCopyright() ;
}

/*
function MagickGetException( &$Imagick ) {
    return $Imagick->getException() ;
}

function MagickGetExceptionString( &$Imagick ) {
    return $Imagick->getExceptionString() ;
}

function MagickGetExceptionType( &$Imagick ) {
    return $Imagick->getExceptionType() ;
}
*/

function MagickGetFilename( &$Imagick ) {
    return $Imagick->getFilename() ;
}

function MagickGetFormat( &$Imagick ) {
    return $Imagick->getFormat() ;
}

function MagickGetHomeURL( &$Imagick ) {
    return $Imagick->getHomeURL() ;
}

function MagickGetImage( &$Imagick ) {
    return $Imagick->getImage() ;
}

/*
function MagickGetImageClipMask( &$Imagick ) {
    return $Imagick->getImageClipMask() ;
}
*/

function MagickGetImageBackgroundColor( &$Imagick ) {
    return $Imagick->getImageBackgroundColor() ;
}

function MagickGetImageBlob( &$Imagick ) {
    return $Imagick->getImageBlob() ;
}

function MagickGetImageBluePrimary( &$Imagick, $x, $y ) {
    return $Imagick->getImageBluePrimary( $x, $y ) ;
}

function MagickGetImageBorderColor( &$Imagick ) {
    return $Imagick->getImageBorderColor() ;
}

function MagickGetImageChannelMean( &$Imagick, $channel ) {
    return $Imagick->getImageChannelMean( $channel ) ;
}

function MagickGetImageColormapColor( &$Imagick, $index ) {
    return $Imagick->getImageColormapColor( $index ) ;
}

function MagickGetImageColors( &$Imagick ) {
    return $Imagick->getImageColors() ;
}

function MagickGetImageColorspace( &$Imagick ) {
    return $Imagick->getImageColorspace() ;
}

function MagickGetImageCompose( &$Imagick ) {
    return $Imagick->getImageCompose() ;
}

function MagickGetImageCompression( &$Imagick ) {
    return $Imagick->getCompression() ;
}

function MagickGetImageCompressionQuality( &$Imagick ) {
    return $Imagick->getCompressionQuality() ;
}

function MagickGetImageDelay( &$Imagick ) {
    return $Imagick->getImageDelay() ;
}

function MagickGetImageDepth( &$Imagick ) {
    return $Imagick->getImageDepth() ;
}

function MagickGetImageDispose( &$Imagick ) {
    return $Imagick->getImageDispose() ;
}

function MagickGetImageExtrema( &$Imagick ) {
    return $Imagick->getImageExtrema() ;
}

function MagickGetImageFilename( &$Imagick ) {
    return $Imagick->getImageFilename() ;
}

function MagickGetImageFormat( &$Imagick ) {
    return $Imagick->getImageFormat() ;
}

function MagickGetImageGamma( &$Imagick ) {
    return $Imagick->getImageGamma() ;
}

function MagickGetImageGreenPrimary( &$Imagick ) {
    return $Imagick->getImageGreenPrimary() ;
}

function MagickGetImageHeight( &$Imagick ) {
    return $Imagick->getImageHeight() ;
}

function MagickGetImageHistogram( &$Imagick ) {
    return $Imagick->getImageHistogram() ;
}

function MagickGetImageIndex( &$Imagick ) {
    return $Imagick->getImageIndex() ;
}

function MagickGetImageInterlaceScheme( &$Imagick ) {
    return $Imagick->getImageInterlaceScheme() ;
}

function MagickGetImageIterations( &$Imagick ) {
    return $Imagick->getImageIterations() ;
}

function MagickGetImageMatteColor( &$Imagick ) {
    return $Imagick->getImageMatteColor() ;
}

function MagickGetImageMimeType( &$Imagick ) {
    return image_type_to_mime_type( $Imagick->getImageType() ) ;
}

function MagickGetImagePixelColor( &$Imagick, $x, $y ) {
    return $Imagick->getImagePixelColor( $x, $y ) ;
}

/*
function MagickGetImagePixels( &$Imagick ) {
    return $Imagick->getImagePixels() ;
}
*/

function MagickGetImageProfile( &$Imagick ) {
    return $Imagick->getImageProfile() ;
}

function MagickGetImageProperty( &$Imagick, $name ) {
    return $Imagick->getImageProperty( $name ) ;
}

function MagickGetImageRedPrimary( &$Imagick ) {
    return $Imagick->getImageRedPrimary() ;
}

function MagickGetImageRenderingIntent( &$Imagick ) {
    return $Imagick->getImageRenderingIntent() ;
}

function MagickGetImageResolution( &$Imagick ) {
    return $Imagick->getImageResolution() ;
}

function MagickGetImageScene( &$Imagick ) {
    return $Imagick->getImageScene() ;
}

function MagickGetImageSignature( &$Imagick ) {
    return $Imagick->getImageSignature() ;
}

function MagickGetImageSize( &$Imagick ) {
    return $Imagick->getImageSize() ;
}

function MagickGetImageType( &$Imagick ) {
    return $Imagick->getImageType() ;
}

function MagickGetImageUnits( &$Imagick ) {
    return $Imagick->getImageUnits() ;
}

function MagickGetImageVirtualPixelMethod( &$Imagick ) {
    return $Imagick->getImageVirtualPixelMethod() ;
}

function MagickGetImageWhitePoint( &$Imagick ) {
    return $Imagick->getImageWhitePoint() ;
}

function MagickGetImageWidth( &$Imagick ) {
    return $Imagick->ImageWidth() ;
}

function MagickGetImagesBlob( &$Imagick ) {
    return $Imagick->ImagesBlob() ;
}

function MagickGetInterlaceScheme( &$Imagick ) {
    return $Imagick->getInterlaceScheme() ;
}

/*
function MagickGetMaxTextAdvance( &$Imagick ) {
    return $Imagick->getMaxTextAdvance() ;
}

function MagickGetMimeType( &$Imagick ) {
    return $Imagick->getMimeType() ;
}
*/

function MagickGetNumberImages( &$Imagick ) {
    return $Imagick->getNumberImages() ;
}

function MagickGetPackageName( &$Imagick ) {
    return $Imagick->getPackageName() ;
}

function MagickGetQuantumDepth( &$Imagick ) {
    return $Imagick->getQuantumDepth() ;
}

function MagickGetReleaseDate( &$Imagick ) {
    return $Imagick->getReleaseDate() ;
}

function MagickGetResourceLimit( &$Imagick, $type ) {
    return $Imagick->getResourceLimit( $type ) ;
}

function MagickGetSamplingFactors( &$Imagick ) {
    return $Imagick->getSamplingFactors() ;
}

function MagickGetSize( &$Imagick ) {
    return $Imagick->getSize() ;
}

/*
function MagickGetStringHeight( &$Imagick ) {
    return $Imagick->getStringHeight() ;
}

function MagickGetStringWidth( &$Imagick ) {
    return $Imagick->getStringWidth() ;
}

function MagickGetTextAscent( &$Imagick ) {
    return $Imagick->getTextAscent() ;
}

function MagickGetTextDescent( &$Imagick ) {
    return $Imagick->getTextDescent() ;
}
*/

function MagickGetVersion( &$Imagick ) {
    return $Imagick->getVersion() ;
}

/*
function MagickGetVersionNumber( &$Imagick ) {
    return $Imagick->getVersionNumber() ;
}

function MagickGetVersionString( &$Imagick ) {
    return $Imagick->getVersionString() ;
}

function MagickGetWandSize( &$Imagick ) {
    return $Imagick->getWandSize() ;
}
*/

function MagickHasNextImage( &$Imagick ) {
    return $Imagick->hasNextImage() ;
}

function MagickHasPreviousImage( &$Imagick ) {
    return $Imagick->hasPreviousImage() ;
}

function MagickImplodeImage( &$Imagick, $radius ) {
    return $Imagick->implodeImage( $radius ) ;
}

function MagickLabelImage( &$Imagick, $label ) {
    return $Imagick->labelImage( $label ) ;
}

function MagickLevelImage( &$Imagick, $blackPoint, $gamma, $whitePoint, $channel = null ) {
	if ( is_null( $channel ) ) {
	    return $Imagick->levelImage( $blackPoint, $gamma, $whitePoint ) ;
	}
	
    return $Imagick->levelImage( $blackPoint, $gamma, $whitePoint, $channel ) ;
}

function MagickMagnifyImage( &$Imagick ) {
    return $Imagick->magnifyImage() ;
}

function MagickMapImage( &$Imagick, $map, $dither ) {
    return $Imagick->mapImage( $map, $dither ) ;
}

function MagickMedianFilterImage( &$Imagick, $radius ) {
    return $Imagick->medianFilterImage( $radius ) ;
}

function MagickMinifyImage( &$Imagick ) {
    return $Imagick->minifyImage() ;
}

function MagickModulateImage( &$Imagick, $brightness, $saturation, $hue ) {
    return $Imagick->modulateImage( $brightness, $saturation, $hue ) ;
}

function MagickMontageImage( &$Imagick, &$ImagickDraw, $tile_geometry, $thumbnail_geometry, $mode, $frame ) {
    return $Imagick->montageImage( $ImagickDraw, $tile_geometry, $thumbnail_geometry, $mode, $frame ) ;
}

function MagickMorphImages( &$Imagick, $number_frames ) {
    return $Imagick->morphImages( $number_frames ) ;
}

function MagickMosaicImages( &$Imagick ) {
    return $Imagick->mosaicImages() ;
}

function MagickMotionBlurImage( &$Imagick, $radius, $sigma, $angle ) {
    return $Imagick->motionBlurImage( $radius, $sigma, $angle ) ;
}

function MagickNegateImage( &$Imagick, $gray, $channel = null ) {
	if ( is_null( $channel ) ) {
	    return $Imagick->negateImage( $gray ) ;
	}
	
    return $Imagick->negateImage( $gray, $channel ) ;
}

function MagickNewImage( &$Imagick, $cols, $rows, $background ) {
	if ( IsPixelWand( $background ) ) {
	    return $Imagick->newImage( $cols, $rows, $background ) ;
	}
	
    return $Imagick->newImage( $cols, $rows, new ImagickPixel( $background ) ) ;
}

function MagickNextImage( &$Imagick ) {
    return $Imagick->nextImage() ;
}

function MagickNormalizeImage( &$Imagick, $channel = null ) {
	if ( is_null( $channel ) ) {
	    return $Imagick->normalizeImage() ;
	}
	
    return $Imagick->normalizeImage( $channel ) ;
}

function MagickOilPaintImage( &$Imagick, $radius ) {
    return $Imagick->oilPaintImage( $radius ) ;
}

/*
function MagickOpaquePaintImage( &$Imagick ) {
    return $Imagick->opaquePaintImage() ;
}
*/

function MagickOrderedPosterizeImage( &$Imagick, $threshold_map, $channel = null ) {
	if ( is_null( $channel ) ) {
	    return $Imagick->orderedPosterizeImage( $threshold_map ) ;
	}
	
    return $Imagick->orderedPosterizeImage( $threshold_map, $channel ) ;
}

function MagickPingImage( &$Imagick, $filename ) {
    return $Imagick->pingImage( $filename ) ;
}

function MagickPosterizeImage( &$Imagick, $levels, $dither ) {
    return $Imagick->posterizeImage( $levels, $dither ) ;
}

function MagickPreviewImages( &$Imagick, $preview ) {
    return $Imagick->previewImages( $preview ) ;
}

function MagickPreviousImage( &$Imagick ) {
    return $Imagick->previousImage() ;
}

function MagickProfileImage( &$Imagick, $name, $profile ) {
    return $Imagick->profileImage( $name, $profile ) ;
}

function MagickQuantizeImage( &$Imagick, $numberColors, $colorspace, $treedepth, $dither, $measureError ) {
    return $Imagick->quantizeImage( $numberColors, $colorspace, $treedepth, $dither, $measureError ) ;
}

function MagickQuantizeImages( &$Imagick, $numberColors, $colorspace, $treedepth, $dither, $measureError ) {
    return $Imagick->quantizeImages( $numberColors, $colorspace, $treedepth, $dither, $measureError ) ;
}

/*
function MagickQueryConfigureOption( &$Imagick ) {
    return $Imagick->queryConfigureOption() ;
}

function MagickQueryConfigureOptions( &$Imagick ) {
    return $Imagick->queryConfigureOptions() ;
}
*/

function MagickQueryFontMetrics( &$Imagick, &$ImagickDraw, $text, $multiline = null ) {
	if ( is_null( $multiline ) ) {
	    return $Imagick->queryFontMetrics( $ImagickDraw, $text ) ;
	}
	
    return $Imagick->queryFontMetrics( $ImagickDraw, $text, $multiline ) ;
}

function MagickQueryFonts( &$Imagick, $pattern = null ) {
	if ( is_null( $pattern ) ) {
	    return $Imagick->queryFonts() ;
	}
	
    return $Imagick->queryFonts( $pattern ) ;
}

function MagickQueryFormats( &$Imagick, $pattern = null  ) {
	if ( is_null( $pattern ) ) {
	    return $Imagick->queryFormats() ;
	}
	
    return $Imagick->queryFormats( $pattern ) ;
}

function MagickRadialBlurImage( &$Imagick, $angle, $channel = null ) {
	if ( is_null( $channel ) ) {
	    return $Imagick->radialBlurImage( $angle ) ;
	}
	
    return $Imagick->radialBlurImage( $angle, $channel ) ;
}

function MagickRaiseImage( &$Imagick, $width, $height, $x, $y, $raise ) {
    return $Imagick->raiseImage( $width, $height, $x, $y, $raise ) ;
}

function MagickReadImage( &$Imagick, $filename ) {
    return $Imagick->readImage( $filename ) ;
}

function MagickReadImageBlob( &$Imagick, $image, $filename = null ) {
	if ( is_null( $filename ) ) {
	    return $Imagick->readImageBlob( $image ) ;
	}
	
    return $Imagick->readImageBlob( $image, $filename ) ;
}

function MagickReadImageFile( &$Imagick, $filehandle, $fileName = null ) {
	if ( is_null( $filename ) ) {
	    return $Imagick->readImageFile( $filehandle ) ;
	}
	
    return $Imagick->readImageFile( $filehandle, $fileName ) ;
}

/*
function MagickReadImages( &$Imagick ) {
    return $Imagick->adaptiveThresholdImage() ;
}

function MagickRecolorImage( &$Imagick ) {
    return $Imagick->recolorImage() ;
}
*/

function MagickReduceNoiseImage( &$Imagick, $radius ) {
    return $Imagick->reduceNoiseImage( $radius ) ;
}

function MagickRemoveImage( &$Imagick ) {
    return $Imagick->removeImage() ;
}

function MagickRemoveImageProfile( &$Imagick, $name ) {
    return $Imagick->removeImageProfile( $name ) ;
}

/*
function MagickRemoveImageProfiles( &$Imagick ) {
    return $Imagick->removeImageProfiles() ;
}
*/

function MagickResampleImage( &$Imagick, $x_resolution, $y_resolution, $filter, $blur ) {
    return $Imagick->resampleImage( $x_resolution, $y_resolution, $filter, $blur ) ;
}

/*
function MagickResetIterator( &$Imagick ) {
    return $Imagick->resetIterator() ;
}
*/

function MagickResizeImage( &$Imagick, $columns, $rows, $filter, $blur ) {
    return $Imagick->resizeImage( $columns, $rows, $filter, $blur ) ;
}

function MagickRollImage( &$Imagick, $x, $y ) {
    return $Imagick->rollImage( $x, $y ) ;
}

function MagickRotateImage( &$Imagick, $background, $degrees ) {
    return $Imagick->rotateImage( $background, $degrees ) ;
}

function MagickSampleImage( &$Imagick, $columns, $rows ) {
    return $Imagick->sampleImage( $columns, $rows ) ;
}

function MagickScaleImage( &$Imagick, $cols, $rows ) {
    return $Imagick->scaleImage( $cols, $rows ) ;
}

function MagickSeparateImageChannel( &$Imagick, $channel ) {
    return $Imagick->separateImageChannel( $channel ) ;
}

function MagickSetCompressionQuality( &$Imagick, $quality ) {
    return $Imagick->setCompressionQuality( $quality ) ;
}

function MagickSetFilename( &$Imagick, $filename ) {
    return $Imagick->setFilename( $filename ) ;
}

function MagickSetFirstIterator( &$Imagick ) {
    return $Imagick->setFirstIterator() ;
}

function MagickSetFormat( &$Imagick, $format ) {
    return $Imagick->setFormat( $format ) ;
}

function MagickSetImage( &$Imagick, $replace ) {
    return $Imagick->setImage( $replace ) ;
}

/*
function MagickSetImageAlphaChannel( &$Imagick ) {
    return $Imagick->setImageAlphaChannel() ;
}
*/

function MagickSetImageBackgroundColor( &$Imagick, $background ) {
	if ( IsPixelWand( $background ) ) {
    	return $Imagick->setImageBackgroundColor( $background ) ;
	}
	
    return $Imagick->setImageBackgroundColor( new ImagickPixel( $background ) ) ;
}

function MagickSetImageBias( &$Imagick, $bias ) {
    return $Imagick->setImageBias( $bias ) ;
}

function MagickSetImageBluePrimary( &$Imagick, $x, $y ) {
    return $Imagick->setImageBluePrimary( $x, $y ) ;
}

function MagickSetImageBorderColor( &$Imagick, $border ) {
	if ( IsPixelWand( $border ) ) {
	    return $Imagick->setImageBorderColor( $border ) ;
	}
	
    return $Imagick->setImageBorderColor( new ImagickPixel( $border ) ) ;
}

/*
function MagickSetImageClipMask( &$Imagick ) {
    return $Imagick->setImageClipMask() ;
}
*/

function MagickSetImageColormapColor( &$Imagick, $index, &$ImagickPixel ) {
    return $Imagick->setImageColormapColor( $index, $ImagickPixel ) ;
}

function MagickSetImageColorspace( &$Imagick, $colorspace ) {
    return $Imagick->setImageColorspace( $colorspace ) ;
}

function MagickSetImageCompose( &$Imagick, $compose ) {
    return $Imagick->setImageCompose( $compose ) ;
}

function MagickSetImageCompression( &$Imagick, $compression ) {
    return $Imagick->setImageCompression( $compression ) ;
}

function MagickSetImageCompressionQuality( &$Imagick, $quality ) {
    return $Imagick->setCompressionQuality( $quality ) ;
}

function MagickSetImageDelay( &$Imagick, $delay ) {
    return $Imagick->setImageDelay( $delay ) ;
}

function MagickSetImageDepth( &$Imagick, $depth ) {
    return $Imagick->setImageDepth( $depth ) ;
}

function MagickSetImageDispose( &$Imagick, $dispose ) {
    return $Imagick->setImageDispose( $dispose ) ;
}

function MagickSetImageFilename( &$Imagick, $filename ) {
    return $Imagick->setImageFilename( $filename ) ;
}

function MagickSetImageFormat( &$Imagick, $format ) {
    return $Imagick->setImageFormat( $format ) ;
}

function MagickSetImageGamma( &$Imagick, $gamma ) {
    return $Imagick->setImageGamma( $gamma ) ;
}

function MagickSetImageGreenPrimary( &$Imagick, $x, $y ) {
    return $Imagick->setImageGreenPrimary( $x, $y ) ;
}

function MagickSetImageIndex( &$Imagick, $index ) {
    return $Imagick->setImageIndex( $index ) ;
}

function MagickSetImageInterlaceScheme( &$Imagick, $interlace_scheme ) {
    return $Imagick->setImageInterlaceScheme( $interlace_scheme ) ;
}

function MagickSetImageIterations( &$Imagick, $iterations ) {
    return $Imagick->setImageIterations( $iterations ) ;
}

function MagickSetImageMatteColor( &$Imagick, $matte ) {
    return $Imagick->setImageMatteColor( $matte ) ;
}

function MagickSetImageOpacity( &$Imagick, $opacity ) {
    return $Imagick->setImageOpacity( $opacity ) ;
}

/*
function MagickSetImageOption( &$Imagick ) {
    return $Imagick->setImageOption() ;
}

function MagickSetImagePixels( &$Imagick ) {
    return $Imagick->setImagePixels() ;
}
*/

function MagickSetImageProfile( &$Imagick, $name, $profile ) {
    return $Imagick->setImageProfile( $name, $profile ) ;
}

function MagickSetImageProperty( &$Imagick, $name, $value ) {
    return $Imagick->setImageProperty( $name, $value ) ;
}

function MagickSetImageRedPrimary( &$Imagick, $x, $y ) {
    return $Imagick->setImageRedPrimary( $x, $y ) ;
}

function MagickSetImageRenderingIntent( &$Imagick, $rendering_intent ) {
    return $Imagick->setImageRenderingIntent( $rendering_intent ) ;
}

function MagickSetImageResolution( &$Imagick, $x_resolution, $y_resolution ) {
    return $Imagick->setImageResolution( $x_resolution, $y_resolution ) ;
}

function MagickSetImageScene( &$Imagick, $scene ) {
    return $Imagick->setImageScene( $scene ) ;
}

function MagickSetImageType( &$Imagick, $image_type ) {
    return $Imagick->setImageType( $image_type ) ;
}

function MagickSetImageUnits( &$Imagick, $units ) {
    return $Imagick->setImageUnits( $units ) ;
}

function MagickSetImageVirtualPixelMethod( &$Imagick, $method ) {
    return $Imagick->setImageVirtualPixelMethod( $method ) ;
}

function MagickSetImageWhitePoint( &$Imagick, $x, $y ) {
    return $Imagick->setImageWhitePoint( $x, $y ) ;
}

function MagickSetInterlaceScheme( &$Imagick, $interlace_scheme ) {
    return $Imagick->setInterlaceScheme( $interlace_scheme ) ;
}

function MagickSetLastIterator( &$Imagick ) {
    return $Imagick->setLastIterator() ;
}

/*
function MagickSetPassphrase( &$Imagick ) {
    return $Imagick->setPassphrase() ;
}
*/

function MagickSetResolution( &$Imagick, $x_resolution, $y_resolution ) {
    return $Imagick->setResolution( $x_resolution, $y_resolution ) ;
}

function MagickSetResourceLimit( &$Imagick, $type, $limit ) {
    return $Imagick->setResourceLimit( $type, $limit ) ;
}

function MagickSetSamplingFactors( &$Imagick, $factors ) {
    return $Imagick->setSamplingFactors( $factors ) ;
}

function MagickSetSize( &$Imagick, $columns, $rows ) {
    return $Imagick->setSize( $columns, $rows ) ;
}

/*
function MagickSetWandSize( &$Imagick ) {
    return $Imagick->setWandSize() ;
}
*/

function MagickShadowImage( &$Imagick, $opacity, $sigma, $x, $y ) {
    return $Imagick->shadowImage( $opacity, $sigma, $x, $y ) ;
}

function MagickSharpenImage( &$Imagick, $radius, $sigma, $channel = null ) {
	if ( is_null( $channel ) ) {
	    return $Imagick->sharpenImage( $radius, $sigma ) ;
	}
	
    return $Imagick->sharpenImage( $radius, $sigma, $channel ) ;
}

function MagickShaveImage( &$Imagick, $columns, $rows ) {
    return $Imagick->shaveImage( $columns, $rows ) ;
}

function MagickShearImage( &$Imagick, $background, $x_shear, $y_shear ) {
	if ( IsPixelWand( $background ) ) {
	    return $Imagick->shearImage( $background, $x_shear, $y_shear ) ;
	}
	
    return $Imagick->shearImage( new ImagePixel( $background ), $x_shear, $y_shear ) ;
}

function MagickSolarizeImage( &$Imagick, $threshold ) {
    return $Imagick->solarizeImage( $threshold ) ;
}

function MagickSpliceImage( &$Imagick, $width, $height, $x, $y ) {
    return $Imagick->spliceImage( $width, $height, $x, $y ) ;
}

function MagickSpreadImage( &$Imagick, $radius ) {
    return $Imagick->spreadImage( $radius ) ;
}

function MagickSteganoImage( &$Imagick, &$watermark_wand, $offset ) {
    return $Imagick->steganoImage( $watermark_wand, $offset ) ;
}

function MagickStereoImage( &$Imagick, &$offset_wand ) {
    return $Imagick->stereoImage( $offset_wand ) ;
}

function MagickStripImage( &$Imagick ) {
    return $Imagick->stripImage() ;
}

function MagickSwirlImage( &$Imagick, $degrees ) {
    return $Imagick->swirlImage( $degrees ) ;
}

function MagickTextureImage( &$Imagick, &$texture_wand ) {
    return $Imagick->textureImage( $texture_wand ) ;
}

function MagickThresholdImage( &$Imagick, $threshold, $channel = null ) {
	if ( is_null( $channel ) ) {
	    return $Imagick->thresholdImage( $threshold ) ;
	}
	
    return $Imagick->thresholdImage( $threshold, $channel ) ;
}

function MagickTintImage( &$Imagick, $tint, $opacity ) {
	if ( IsPixelWand( $tint ) ) {
	    return $Imagick->tintImage( $tint, $opacity ) ;
	}
	
    return $Imagick->tintImage( new ImagickPixel( $tint ), $opacity ) ;
}

function MagickTransformImage( &$Imagick, $crop, $geometry ) {
    return $Imagick->transformImage( $crop, $geometry ) ;
}

/*
function MagickTransparentPaintImage( &$Imagick ) {
    return $Imagick->transparentPaintImage() ;
}
*/

function MagickTrimImage( &$Imagick, $fuzz ) {
    return $Imagick->trimImage( $fuzz ) ;
}

function MagickUnsharpMaskImage( &$Imagick, $radius, $sigma, $amount, $threshold, $channel = null ) {
	if ( is_null( $channel ) ) {
	    return $Imagick->unsharpMaskImage( $radius, $sigma, $amount, $threshold ) ;
	}
	
    return $Imagick->unsharpMaskImage( $radius, $sigma, $amount, $threshold, $channel ) ;
}

function MagickWaveImage( &$Imagick, $amplitude, $length ) {
    return $Imagick->waveImage( $amplitude, $length ) ;
}

function MagickWhiteThresholdImage( &$Imagick, $threshold ) {
	if ( IsPixelWand( $threshold ) ) {
	    return $Imagick->whiteThresholdImage( $threshold ) ;
	}
	
    return $Imagick->whiteThresholdImage( new ImagePixel( $threshold ) ) ;
}

function MagickWriteImage( &$Imagick, $filename = null ) {
    return $Imagick->writeImage( $filename ) ;
}

/*
function MagickWriteImageFile( &$Imagick ) {
    return $Imagick->writeImage() ;
}
*/

function MagickWriteImages( &$Imagick, $filename = null, $adjoin = false ) {
    return $Imagick->writeImages( $filename, $adjoin ) ;
}

/*
function MagickWriteImagesFile( &$Imagick ) {
    return $Imagick->writeImagesFile() ;
}
*/

// ��������

function NewDrawingWand() {
    return new ImagickDraw() ;
}

function NewMagickWand() {
    return new Imagick() ;
}

function NewPixelIterator( &$Imagick ) {
    return new ImagickPixelIterator( $Imagick ) ;
}

function NewPixelRegionIterator( $Imagick, $x, $y, $columns, $rows ) {
    return ;
}

function NewPixelWand( $color = null ) {
	if ( is_null( $color ) ) {
		return new ImagickPixel() ;
	}
	
    return new ImagickPixel( $color ) ;
}

function NewPixelWandArray( $num ) {
	$array = array() ;
	
	for ( $n = 0 ; $n < $num ; $n++ ) {
	    $array[] = new ImagickPixel() ;
	}
	
    return $array ;
}

function NewPixelWands( $num ) {
    return NewPixelWandArray( $num ) ;
}

function PixelGetAlpha( &$ImagePixel ) {
    return $ImagePixel->getColorValue( Imagick::COLOR_ALPHA ) ;
}

function PixelGetAlphaQuantum( &$ImagePixel ) {
    return floor( $ImagePixel->getColorValue( Imagick::COLOR_ALPHA ) * MW_MaxRGB ) ;
}

function PixelGetBlack( &$ImagePixel ) {
    return $ImagePixel->getColorValue( Imagick::COLOR_BLACK ) ;
}

function PixelGetBlackQuantum( &$ImagePixel ) {
    return floor( $ImagePixel->getColorValue( Imagick::COLOR_BLACK ) * MW_MaxRGB ) ;
}

function PixelGetBlue( &$ImagePixel ) {
    return $ImagePixel->getColorValue( Imagick::COLOR_BLUE ) ;
}

function PixelGetBlueQuantum( &$ImagePixel ) {
    return floor( $ImagePixel->getColorValue( Imagick::COLOR_BLUE ) * MW_MaxRGB ) ;
}

function PixelGetColorAsString( &$ImagePixel ) {
    return $ImagePixel->getColorAsString() ;
}

function PixelGetColorCount( &$ImagePixel ) {
    return $ImagePixel->getColorCount() ;
}

function PixelGetCyan( &$ImagePixel ) {
    return $ImagePixel->getColorValue( Imagick::COLOR_CYAN ) ;
}

function PixelGetCyanQuantum( &$ImagePixel ) {
    return floor( $ImagePixel->getColorValue( Imagick::COLOR_CYAN ) * MW_MaxRGB ) ;
}

/*
function PixelGetException( &$ImagePixel ) {
    return $ImagePixel->getException() ;
}

function PixelGetExceptionString( &$ImagePixel ) {
    return $ImagePixel->getExceptionString() ;
}

function PixelGetExceptionType( &$ImagePixel ) {
    return $ImagePixel->getExceptionType() ;
}
*/

function PixelGetGreen( &$ImagePixel ) {
    return $ImagePixel->getColorValue( Imagick::COLOR_GREEN ) ;
}

function PixelGetGreenQuantum( &$ImagePixel ) {
    return floor( $ImagePixel->getColorValue( Imagick::COLOR_GREEN ) * MW_MaxRGB ) ;
}

/*
function PixelGetIndex( &$ImagePixel ) {
    return $ImagePixel->getIndex() ;
}

function PixelGetIteratorException( &$ImagePixelIterator ) {
    return $ImagePixelIterator->getIteratorException() ;
}

function PixelGetIteratorExceptionString( &$ImagePixelIterator ) {
    return $ImagePixelIterator->getIteratorExceptionString() ;
}

function PixelGetIteratorExceptionType( &$ImagePixelIterator ) {
    return $ImagePixelIterator->getIteratorExceptionType() ;
}
*/

function PixelGetMagenta( &$ImagePixel ) {
    return $ImagePixel->getColorValue( Imagick::COLOR_MAGENTA ) ;
}

function PixelGetMagentaQuantum( &$ImagePixel ) {
    return floor( $ImagePixel->getColorValue( Imagick::COLOR_MAGENTA ) * MW_MaxRGB ) ;
}

function PixelGetNextIteratorRow( &$ImagePixelIterator ) {
    return $ImagePixelIterator->getNext() ;
}

function PixelGetOpacity( &$ImagePixel ) {
    return $ImagePixel->getColorValue( Imagick::COLOR_OPACITY ) ;
}

function PixelGetOpacityQuantum( &$ImagePixel ) {
    return floor( $ImagePixel->getColorValue( Imagick::COLOR_OPACITY ) * MW_MaxRGB ) ;
}

function PixelGetQuantumColor( &$ImagePixel ) {
    return array(
		'r' => floor( $ImagePixel->getColorValue( Imagick::COLOR_RED ) * MW_MaxRGB ),
		'g' => floor( $ImagePixel->getColorValue( Imagick::COLOR_GREEN ) * MW_MaxRGB ),
		'b' => floor( $ImagePixel->getColorValue( Imagick::COLOR_BLUE ) * MW_MaxRGB ),
		'o' => floor( $ImagePixel->getColorValue( Imagick::COLOR_OPACITY ) * MW_MaxRGB )
    ) ;
}

function PixelGetRed( &$ImagePixel ) {
    return $ImagePixel->getColorValue( Imagick::COLOR_RED ) ;
}

function PixelGetRedQuantum( &$ImagePixel ) {
    return floor( $ImagePixel->getColorValue( Imagick::COLOR_RED ) * MW_MaxRGB ) ;
}

function PixelGetYellow( &$ImagePixel ) {
    return $ImagePixel->getColorValue( Imagick::COLOR_YELLOW ) ;
}

function PixelGetYellowQuantum( &$ImagePixel ) {
    return floor( $ImagePixel->getColorValue( Imagick::COLOR_YELLOW ) * MW_MaxRGB ) ;
}

function PixelResetIterator( &$ImagePixelIterator ) {
    return $ImagePixelIterator->resetIterator();
}

function PixelSetAlpha( &$ImagePixel, $alpha ) {
    $ImagePixel->setColorValue( Imagick::COLOR_ALPHA, $alpha ) ;
}

function PixelSetAlphaQuantum( &$ImagePixel, $alpha ) {
    $ImagePixel->setColorValue( Imagick::COLOR_ALPHA, floor( $alpha / MW_MaxRGB ) ) ;
}

function PixelSetBlack( &$ImagePixel, $black ) {
    $ImagePixel->setColorValue( Imagick::COLOR_BLACK, $black ) ;
}

function PixelSetBlackQuantum( &$ImagePixel, $black ) {
    $ImagePixel->setColorValue( Imagick::COLOR_BLACK, floor( $black / MW_MaxRGB ) ) ;
}

function PixelSetBlue( &$ImagePixel, $blue ) {
    $ImagePixel->setColorValue( Imagick::COLOR_BLUE, $blue ) ;
}

function PixelSetBlueQuantum( &$ImagePixel, $blue ) {
	$ImagePixel->setColorValue( Imagick::COLOR_BLUE, floor( $blue / MW_MaxRGB ) ) ;
}

function PixelSetColor( &$ImagickPixel, $color ) {
    return $ImagickPixel->setColor( $color ) ;
}

/*
function PixelSetColorCount( &$ImagePixel ) {
    return $ImagePixel->setColorCount() ;
}
*/

function PixelSetCyan( &$ImagePixel, $cyan ) {
    $ImagePixel->setColorValue( Imagick::COLOR_CYAN, $cyan ) ;
}

function PixelSetCyanQuantum( &$ImagePixel, $cyan ) {
	$ImagePixel->setColorValue( Imagick::COLOR_CYAN, floor( $cyan / MW_MaxRGB ) ) ;
}

function PixelSetGreen( &$ImagePixel, $green ) {
    $ImagePixel->setColorValue( Imagick::COLOR_GREEN, $green ) ;
}

function PixelSetGreenQuantum( &$ImagePixel, $green ) {
	$ImagePixel->setColorValue( Imagick::COLOR_GREEN, floor( $green / MW_MaxRGB ) ) ;
}

/*
function PixelSetIndex( &$ImagePixel ) {
    return $ImagePixel->setIndex() ;
}
*/

function PixelSetIteratorRow( &$ImagePixelIterator, $row ) {
    return $ImagePixelIterator->setIteratorRow( $row ) ;
}

function PixelSetMagenta( &$ImagePixel, $magenta ) {
    $ImagePixel->setColorValue( Imagick::COLOR_MAGENTA, $magenta ) ;
}

function PixelSetMagentaQuantum( &$ImagePixel, $magenta ) {
	$ImagePixel->setColorValue( Imagick::COLOR_MAGENTA, floor( $magenta / MW_MaxRGB ) ) ;
}

function PixelSetOpacity( &$ImagePixel, $opacity ) {
    $ImagePixel->setColorValue( Imagick::COLOR_OPACITY, $opacity ) ;
}

function PixelSetOpacityQuantum( &$ImagePixel, $opacity ) {
	$ImagePixel->setColorValue( Imagick::COLOR_OPACITY, floor( $opacity / MW_MaxRGB ) ) ;
}

function PixelSetQuantumColor( &$ImagePixel, $red, $green, $blue, $opacity = null ) {
	$ImagePixel->setColorValue( Imagick::COLOR_RED, floor( $red / MW_MaxRGB ) ) ;
	$ImagePixel->setColorValue( Imagick::COLOR_GREEN, floor( $green / MW_MaxRGB ) ) ;
	$ImagePixel->setColorValue( Imagick::COLOR_BLUE, floor( $blue / MW_MaxRGB ) ) ;
	
	if ( ! is_null( $opacity) ) {
		$ImagePixel->setColorValue( Imagick::COLOR_OPACITY, floor( $opacity / MW_MaxRGB ) ) ;
	}
}

function PixelSetRed( &$ImagePixel, $red ) {
    $ImagePixel->setColorValue( Imagick::COLOR_RED, $red ) ;
}

function PixelSetRedQuantum( &$ImagePixel, $red ) {
	$ImagePixel->setColorValue( Imagick::COLOR_RED, floor( $red / MW_MaxRGB ) ) ;
}

function PixelSetYellow( &$ImagePixel, $yellow ) {
    $ImagePixel->setColorValue( Imagick::COLOR_YELLOW, $yellow ) ;
}

function PixelSetYellowQuantum( &$ImagePixel, $yellow ) {
	$ImagePixel->setColorValue( Imagick::COLOR_YELLOW, floor( $yellow / MW_MaxRGB ) ) ;
}

function PixelSyncIterator( &$ImagePixelIterator ) {
    return $ImagePixelIterator->syncIterator()  ;
}

function PopDrawingWand( &$ImagickDraw ) {
    return $ImagickDraw->pop() ;
}

function PushDrawingWand( &$ImagickDraw ) {
    return $ImagickDraw->push() ;
}

/*
function WandGetException() {
    return ;
}

function WandGetExceptionString() {
    return ;
}

function WandGetExceptionType() {
    return ;
}

function WandHasException() {
    return ;
}
*/
?>