diff options
84 files changed, 4596 insertions, 0 deletions
diff --git a/dmagick/c/MagickCore.d b/dmagick/c/MagickCore.d new file mode 100644 index 0000000..b48bcc6 --- /dev/null +++ b/dmagick/c/MagickCore.d @@ -0,0 +1,86 @@ +module dmagick.c.MagickCore; + +public import dmagick.c.accelerate; +public import dmagick.c.animate; +public import dmagick.c.annotate; +public import dmagick.c.artifact; +public import dmagick.c.attribute; +public import dmagick.c.blob; +public import dmagick.c.cache; +public import dmagick.c.cacheView; +public import dmagick.c.cipher; +public import dmagick.c.client; +public import dmagick.c.coder; +public import dmagick.c.color; +public import dmagick.c.colormap; +public import dmagick.c.colorspace; +public import dmagick.c.compare; +public import dmagick.c.composite; +public import dmagick.c.compress; +public import dmagick.c.configure; +public import dmagick.c.constitute; +public import dmagick.c.decorate; +public import dmagick.c.deprecate; +public import dmagick.c.display; +public import dmagick.c.distort; +public import dmagick.c.draw; +public import dmagick.c.effect; +public import dmagick.c.enhance; +public import dmagick.c.exception; +public import dmagick.c.feature; +public import dmagick.c.fourier; +public import dmagick.c.fx; +public import dmagick.c.gem; +public import dmagick.c.geometry; +public import dmagick.c.hashmap; +public import dmagick.c.histogram; +public import dmagick.c.identify; +public import dmagick.c.image; +public import dmagick.c.imageView; +public import dmagick.c.layer; +public import dmagick.c.list; +public import dmagick.c.locale; +public import dmagick.c.log; +public import dmagick.c.magic; +public import dmagick.c.magick; +public import dmagick.c.magickDelegate; +public import dmagick.c.magickModule; +public import dmagick.c.magickString; +public import dmagick.c.magickType; +public import dmagick.c.magickVersion; +public import dmagick.c.matrix; +public import dmagick.c.memory; +public import dmagick.c.mime; +public import dmagick.c.monitor; +public import dmagick.c.montage; +public import dmagick.c.morphology; +public import dmagick.c.option; +public import dmagick.c.paint; +public import dmagick.c.pixel; +public import dmagick.c.policy; +public import dmagick.c.prepress; +public import dmagick.c.profile; +public import dmagick.c.property; +public import dmagick.c.quantize; +public import dmagick.c.quantum; +public import dmagick.c.random; +public import dmagick.c.registry; +public import dmagick.c.resample; +public import dmagick.c.resize; +public import dmagick.c.resource; +public import dmagick.c.segment; +public import dmagick.c.semaphore; +public import dmagick.c.sheer; +public import dmagick.c.signature; +public import dmagick.c.splayTree; +public import dmagick.c.statistic; +public import dmagick.c.stream; +public import dmagick.c.threshold; +public import dmagick.c.timer; +public import dmagick.c.token; +public import dmagick.c.transform; +public import dmagick.c.type; +public import dmagick.c.utility; +public import dmagick.c.xmlTree; +public import dmagick.c.xwindow; + diff --git a/dmagick/c/accelerate.d b/dmagick/c/accelerate.d new file mode 100644 index 0000000..ff5c9f0 --- /dev/null +++ b/dmagick/c/accelerate.d @@ -0,0 +1,8 @@ +module dmagick.c.accelerate; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; +import dmagick.c.morphology; + +extern(C) MagickBooleanType AccelerateConvolveImage(const Image*, const KernelInfo*, Image*, ExceptionInfo*); diff --git a/dmagick/c/animate.d b/dmagick/c/animate.d new file mode 100644 index 0000000..3915e55 --- /dev/null +++ b/dmagick/c/animate.d @@ -0,0 +1,6 @@ +module dmagick.c.animate; + +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) MagickBooleanType AnimateImages(const ImageInfo*, Image*); diff --git a/dmagick/c/annotate.d b/dmagick/c/annotate.d new file mode 100644 index 0000000..be4fc45 --- /dev/null +++ b/dmagick/c/annotate.d @@ -0,0 +1,16 @@ +module dmagick.c.annotate; + +import core.sys.posix.sys.types; + +import dmagick.c.draw; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + MagickBooleanType AnnotateImage(Image*, const DrawInfo*); + MagickBooleanType GetMultilineTypeMetrics(Image*, const DrawInfo*, TypeMetric*); + MagickBooleanType GetTypeMetrics(Image*, const DrawInfo*, TypeMetric*); + + ssize_t FormatMagickCaption(Image*, DrawInfo*, const MagickBooleanType, TypeMetric*, char**); +} diff --git a/dmagick/c/artifact.d b/dmagick/c/artifact.d new file mode 100644 index 0000000..0899c3d --- /dev/null +++ b/dmagick/c/artifact.d @@ -0,0 +1,20 @@ +module dmagick.c.artifact; + +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + char* GetNextImageArtifact(const Image*); + char* RemoveImageArtifact(Image*, const char*); + + const(char*) GetImageArtifact(const Image*, const char*); + + MagickBooleanType CloneImageArtifacts(Image*, const Image*); + MagickBooleanType DefineImageArtifact(Image*, const char*); + MagickBooleanType DeleteImageArtifact(Image*, const char*); + MagickBooleanType SetImageArtifact(Image*, const char*, const char*); + + void DestroyImageArtifacts(Image*); + void ResetImageArtifactIterator(const Image*); +} diff --git a/dmagick/c/attribute.d b/dmagick/c/attribute.d new file mode 100644 index 0000000..c827155 --- /dev/null +++ b/dmagick/c/attribute.d @@ -0,0 +1,23 @@ +module dmagick.c.attribute; + +import dmagick.c.image; +import dmagick.c.exception; +import dmagick.c.magickType; +import dmagick.c.geometry; + +extern(C) +{ + ImageType GetImageType(const Image*, ExceptionInfo*); + + MagickBooleanType IsGrayImage(const Image*, ExceptionInfo*); + MagickBooleanType IsMonochromeImage(const Image*, ExceptionInfo*); + MagickBooleanType IsOpaqueImage(const Image*, ExceptionInfo*); + MagickBooleanType SetImageChannelDepth(Image*, const ChannelType, const size_t); + MagickBooleanType SetImageDepth(Image*, const size_t); + + RectangleInfo GetImageBoundingBox(const Image*, ExceptionInfo* exception); + + size_t GetImageChannelDepth(const Image*, const ChannelType, ExceptionInfo*); + size_t GetImageDepth(const Image*, ExceptionInfo*); + size_t GetImageQuantumDepth(const Image*, const MagickBooleanType); +} diff --git a/dmagick/c/blob.d b/dmagick/c/blob.d new file mode 100644 index 0000000..95f3817 --- /dev/null +++ b/dmagick/c/blob.d @@ -0,0 +1,45 @@ +module dmagick.c.blob; + +import core.stdc.stdio; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; +import dmagick.c.stream; + +extern(C) +{ + enum MapMode + { + ReadMode, + WriteMode, + IOMode + } + + FILE* GetBlobFileHandle(const Image*); + + Image* BlobToImage(const ImageInfo*, const void*, const size_t, ExceptionInfo*); + Image* PingBlob(const ImageInfo*, const void*, const size_t, ExceptionInfo*); + + MagickBooleanType BlobToFile(char*, const void*, const size_t, ExceptionInfo*); + MagickBooleanType FileToImage(Image*, const char*); + MagickBooleanType GetBlobError(const Image*); + MagickBooleanType ImageToFile(Image*, char*, ExceptionInfo*); + MagickBooleanType InjectImageBlob(const ImageInfo*, Image*, Image*, const char*, ExceptionInfo*); + MagickBooleanType IsBlobExempt(const Image*); + MagickBooleanType IsBlobSeekable(const Image*); + MagickBooleanType IsBlobTemporary(const Image*); + + MagickSizeType GetBlobSize(const Image*); + + StreamHandler GetBlobStreamHandler(const Image*); + + ubyte* FileToBlob(const char*, const size_t, size_t*, ExceptionInfo*); + ubyte* GetBlobStreamData(const Image*); + ubyte* ImageToBlob(const ImageInfo*, Image*, size_t*, ExceptionInfo*); + ubyte* ImagesToBlob(const ImageInfo*, Image*, size_t*, ExceptionInfo*); + + void DestroyBlob(Image*); + void DuplicateBlob(Image*, const Image*); + void SetBlobExempt(Image*, const MagickBooleanType); +} diff --git a/dmagick/c/cache.d b/dmagick/c/cache.d new file mode 100644 index 0000000..d696e08 --- /dev/null +++ b/dmagick/c/cache.d @@ -0,0 +1,41 @@ +module dmagick.c.cache; + +import core.sys.posix.sys.types; + +import dmagick.c.image; +import dmagick.c.pixel; +import dmagick.c.exception; +import dmagick.c.magickType; +import dmagick.c.cacheView; + +extern(C) +{ + const(IndexPacket*) GetVirtualIndexQueue(const Image*); + + const(PixelPacket*) GetVirtualPixels(const Image*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*); + const(PixelPacket*) GetVirtualPixelQueue(const Image*); + + const(void*) AcquirePixelCachePixels(const Image*, MagickSizeType*, ExceptionInfo*); + + IndexPacket* GetAuthenticIndexQueue(const Image*); + + MagickBooleanType CacheComponentGenesis(); + MagickBooleanType GetOneVirtualMagickPixel(const Image*, const ssize_t, const ssize_t, MagickPixelPacket*, ExceptionInfo*); + MagickBooleanType GetOneVirtualPixel(const Image*, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*); + MagickBooleanType GetOneVirtualMethodPixel(const Image*, const VirtualPixelMethod, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*); + MagickBooleanType GetOneAuthenticPixel(Image*, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*); + MagickBooleanType PersistPixelCache(Image*, const char*, const MagickBooleanType, MagickOffsetType*, ExceptionInfo*); + MagickBooleanType SyncAuthenticPixels(Image*, ExceptionInfo*); + + MagickSizeType GetImageExtent(const Image*); + + PixelPacket* GetAuthenticPixels(Image*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*); + PixelPacket* GetAuthenticPixelQueue(const Image*); + PixelPacket* QueueAuthenticPixels(Image*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*); + + VirtualPixelMethod GetPixelCacheVirtualMethod(const Image*); + VirtualPixelMethod SetPixelCacheVirtualMethod(const Image*, const VirtualPixelMethod); + + void CacheComponentTerminus(); + void* GetPixelCachePixels(Image*, MagickSizeType*, ExceptionInfo*); +} diff --git a/dmagick/c/cacheView.d b/dmagick/c/cacheView.d new file mode 100644 index 0000000..7d85a46 --- /dev/null +++ b/dmagick/c/cacheView.d @@ -0,0 +1,66 @@ +module dmagick.c.cacheView; + +import core.sys.posix.sys.types; + +import dmagick.c.colorspace; +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; +import dmagick.c.pixel; + +extern(C) +{ + enum VirtualPixelMethod + { + UndefinedVirtualPixelMethod, + BackgroundVirtualPixelMethod, + ConstantVirtualPixelMethod, + DitherVirtualPixelMethod, + EdgeVirtualPixelMethod, + MirrorVirtualPixelMethod, + RandomVirtualPixelMethod, + TileVirtualPixelMethod, + TransparentVirtualPixelMethod, + MaskVirtualPixelMethod, + BlackVirtualPixelMethod, + GrayVirtualPixelMethod, + WhiteVirtualPixelMethod, + HorizontalTileVirtualPixelMethod, + VerticalTileVirtualPixelMethod, + HorizontalTileEdgeVirtualPixelMethod, + VerticalTileEdgeVirtualPixelMethod, + CheckerTileVirtualPixelMethod + } + + struct CacheView {} + + ClassType GetCacheViewStorageClass(const CacheView*); + + ColorspaceType GetCacheViewColorspace(const CacheView*); + + const(IndexPacket*) GetCacheViewVirtualIndexQueue(const CacheView*); + + const(PixelPacket*) GetCacheViewVirtualPixels(const CacheView*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*); + const(PixelPacket*) GetCacheViewVirtualPixelQueue(const CacheView*); + + ExceptionInfo* GetCacheViewException(const CacheView*); + + IndexPacket* GetCacheViewAuthenticIndexQueue(CacheView*); + + MagickBooleanType GetOneCacheViewVirtualPixel(const CacheView*, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*); + MagickBooleanType GetOneCacheViewVirtualMethodPixel(const CacheView*, const VirtualPixelMethod, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*); + MagickBooleanType GetOneCacheViewAuthenticPixel(const CacheView*, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*); + MagickBooleanType SetCacheViewStorageClass(CacheView*, const ClassType); + MagickBooleanType SetCacheViewVirtualPixelMethod(CacheView*, const VirtualPixelMethod); + MagickBooleanType SyncCacheViewAuthenticPixels(CacheView*, ExceptionInfo*); + + MagickSizeType GetCacheViewExtent(const CacheView*); + + PixelPacket* GetCacheViewAuthenticPixelQueue(CacheView*); + PixelPacket* GetCacheViewAuthenticPixels(CacheView*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*); + PixelPacket* QueueCacheViewAuthenticPixels(CacheView*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*); + + CacheView* AcquireCacheView(const Image*); + CacheView* CloneCacheView(const CacheView*); + CacheView* DestroyCacheView(CacheView*); +} diff --git a/dmagick/c/cipher.d b/dmagick/c/cipher.d new file mode 100644 index 0000000..be48b7a --- /dev/null +++ b/dmagick/c/cipher.d @@ -0,0 +1,14 @@ +module dmagick.c.cipher; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickString; +import dmagick.c.magickType; + +extern(C) +{ + MagickBooleanType DecipherImage(Image*, const char*, ExceptionInfo*); + MagickBooleanType EncipherImage(Image*, const char*, ExceptionInfo*); + MagickBooleanType PasskeyDecipherImage(Image*, const StringInfo*, ExceptionInfo*); + MagickBooleanType PasskeyEncipherImage(Image*, const StringInfo*, ExceptionInfo*); +} diff --git a/dmagick/c/client.d b/dmagick/c/client.d new file mode 100644 index 0000000..4404607 --- /dev/null +++ b/dmagick/c/client.d @@ -0,0 +1,9 @@ +module dmagick.c.client; + +extern(C) +{ + const(char*) GetClientPath(); + const(char*) GetClientName(); + const(char*) SetClientName(const char*); + const(char*) SetClientPath(const char*); +} diff --git a/dmagick/c/coder.d b/dmagick/c/coder.d new file mode 100644 index 0000000..52f5d32 --- /dev/null +++ b/dmagick/c/coder.d @@ -0,0 +1,37 @@ +module dmagick.c.coder; + +import core.stdc.stdio; + +import dmagick.c.exception; +import dmagick.c.magickType; + +extern(C) +{ + struct CoderInfo + { + char* + path, + magick, + name; + + MagickBooleanType + exempt, + stealth; + + CoderInfo* + previous, + next; + + size_t + signature; + } + + char** GetCoderList(const char*, size_t*, ExceptionInfo*); + + const(CoderInfo*) GetCoderInfo(const char*, ExceptionInfo*); + const(CoderInfo**) GetCoderInfoList(const char*, size_t*, ExceptionInfo*); + + MagickBooleanType CoderComponentGenesis(); + MagickBooleanType ListCoderInfo(FILE*, ExceptionInfo*); +} + void CoderComponentTerminus(); diff --git a/dmagick/c/color.d b/dmagick/c/color.d new file mode 100644 index 0000000..be66bef --- /dev/null +++ b/dmagick/c/color.d @@ -0,0 +1,79 @@ +module dmagick.c.color; + +import core.stdc.stdio; +import core.sys.posix.sys.types; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; +import dmagick.c.pixel; + +extern(C) +{ + enum ComplianceType + { + UndefinedCompliance, + NoCompliance = 0x0000, + SVGCompliance = 0x0001, + X11Compliance = 0x0002, + XPMCompliance = 0x0004, + AllCompliance = 0x7fffffff + } + + struct ColorInfo + { + char* + path, + name; + + ComplianceType + compliance; + + MagickPixelPacket + color; + + MagickBooleanType + exempt, + stealth; + + ColorInfo* + previous, + next; + + size_t + signature; + } + + struct ErrorInfo + { + double + mean_error_per_pixel, + normalized_mean_error, + normalized_maximum_error; + } + + char** GetColorList(const char*, size_t*, ExceptionInfo*); + + const(ColorInfo*) GetColorInfo(const char*, ExceptionInfo*); + const(ColorInfo**) GetColorInfoList(const char*, size_t*, ExceptionInfo*); + + MagickBooleanType ColorComponentGenesis(); + MagickBooleanType IsColorSimilar(const Image*, const PixelPacket*, const PixelPacket*); + MagickBooleanType IsGrayImage(const Image*, ExceptionInfo*); + MagickBooleanType IsImageSimilar(const Image*, const Image*, ssize_t* x,ssize_t* y, ExceptionInfo*); + MagickBooleanType IsMagickColorSimilar(const MagickPixelPacket*, const MagickPixelPacket*); + MagickBooleanType IsMonochromeImage(const Image*, ExceptionInfo*); + MagickBooleanType IsOpacitySimilar(const Image*, const PixelPacket*, const PixelPacket*); + MagickBooleanType IsOpaqueImage(const Image*, ExceptionInfo*); + MagickBooleanType ListColorInfo(FILE*, ExceptionInfo*); + MagickBooleanType QueryColorCompliance(const char*, const ComplianceType, PixelPacket*, ExceptionInfo*); + MagickBooleanType QueryColorDatabase(const char*, PixelPacket*, ExceptionInfo*); + MagickBooleanType QueryColorname(const Image*, const PixelPacket*, const ComplianceType, char*, ExceptionInfo*); + MagickBooleanType QueryMagickColorCompliance(const char*, const ComplianceType, MagickPixelPacket*, ExceptionInfo*); + MagickBooleanType QueryMagickColor(const char*, MagickPixelPacket*, ExceptionInfo*); + MagickBooleanType QueryMagickColorname(const Image*, const MagickPixelPacket*, const ComplianceType, char*, ExceptionInfo*); + + void ColorComponentTerminus(); + void ConcatenateColorComponent(const MagickPixelPacket*, const ChannelType, const ComplianceType, char*); + void GetColorTuple(const MagickPixelPacket*, const MagickBooleanType, char*); +} diff --git a/dmagick/c/colormap.d b/dmagick/c/colormap.d new file mode 100644 index 0000000..12eecb3 --- /dev/null +++ b/dmagick/c/colormap.d @@ -0,0 +1,13 @@ +module dmagick.c.colormap; + +import core.sys.posix.sys.types; + +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + MagickBooleanType AcquireImageColormap(Image*, const size_t); + MagickBooleanType CycleColormapImage(Image*, const ssize_t); + MagickBooleanType SortColormapByIntensity(Image*); +} diff --git a/dmagick/c/colorspace.d b/dmagick/c/colorspace.d new file mode 100644 index 0000000..59d4efd --- /dev/null +++ b/dmagick/c/colorspace.d @@ -0,0 +1,39 @@ +module dmagick.c.colorspace; + +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + enum ColorspaceType + { + UndefinedColorspace, + RGBColorspace, + GRAYColorspace, + TransparentColorspace, + OHTAColorspace, + LabColorspace, + XYZColorspace, + YCbCrColorspace, + YCCColorspace, + YIQColorspace, + YPbPrColorspace, + YUVColorspace, + CMYKColorspace, + sRGBColorspace, + HSBColorspace, + HSLColorspace, + HWBColorspace, + Rec601LumaColorspace, + Rec601YCbCrColorspace, + Rec709LumaColorspace, + Rec709YCbCrColorspace, + LogColorspace, + CMYColorspace + } + + MagickBooleanType RGBTransformImage(Image*, const ColorspaceType); + MagickBooleanType SetImageColorspace(Image*, const ColorspaceType); + MagickBooleanType TransformImageColorspace(Image*, const ColorspaceType); + MagickBooleanType TransformRGBImage(Image*, const ColorspaceType); +} diff --git a/dmagick/c/compare.d b/dmagick/c/compare.d new file mode 100644 index 0000000..b2a755f --- /dev/null +++ b/dmagick/c/compare.d @@ -0,0 +1,31 @@ +module dmagick.c.compare; + +import dmagick.c.exception; +import dmagick.c.geometry; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + enum MetricType + { + UndefinedMetric, + AbsoluteErrorMetric, + MeanAbsoluteErrorMetric, + MeanErrorPerPixelMetric, + MeanSquaredErrorMetric, + PeakAbsoluteErrorMetric, + PeakSignalToNoiseRatioMetric, + RootMeanSquaredErrorMetric + } + + double* GetImageChannelDistortions(Image*, const Image*, const MetricType, ExceptionInfo*); + + Image* CompareImageChannels(Image*, const Image*, const ChannelType, const MetricType, double*, ExceptionInfo*); + Image* CompareImages(Image*, const Image*, const MetricType, double*, ExceptionInfo*); + Image* SimilarityImage(Image*, const Image*, RectangleInfo*, double*, ExceptionInfo*); + + MagickBooleanType GetImageChannelDistortion(Image*, const Image*, const ChannelType, const MetricType, double*, ExceptionInfo*); + MagickBooleanType GetImageDistortion(Image*, const Image*, const MetricType, double*, ExceptionInfo*); + MagickBooleanType IsImagesEqual(Image*, const Image*); +} diff --git a/dmagick/c/composite.d b/dmagick/c/composite.d new file mode 100644 index 0000000..e280fc8 --- /dev/null +++ b/dmagick/c/composite.d @@ -0,0 +1,81 @@ +module dmagick.c.composite; + +import core.sys.posix.sys.types; + +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + enum CompositeOperator + { + 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, + MinusCompositeOp, + ModulateCompositeOp, + MultiplyCompositeOp, + OutCompositeOp, + OverCompositeOp, + OverlayCompositeOp, + PlusCompositeOp, + ReplaceCompositeOp, + SaturateCompositeOp, + ScreenCompositeOp, + SoftLightCompositeOp, + SrcAtopCompositeOp, + SrcCompositeOp, + SrcInCompositeOp, + SrcOutCompositeOp, + SrcOverCompositeOp, + ModulusSubtractCompositeOp, + ThresholdCompositeOp, + XorCompositeOp, + DivideCompositeOp, + DistortCompositeOp, + BlurCompositeOp, + PegtopLightCompositeOp, + VividLightCompositeOp, + PinLightCompositeOp, + LinearDodgeCompositeOp, + LinearBurnCompositeOp, + MathematicsCompositeOp + } + + MagickBooleanType CompositeImage(Image*, const CompositeOperator, const Image*, const ssize_t, const ssize_t); + MagickBooleanType CompositeImageChannel(Image*, const ChannelType, const CompositeOperator, const Image*, const ssize_t, const ssize_t); + MagickBooleanType TextureImage(Image*, const Image*); +} diff --git a/dmagick/c/compress.d b/dmagick/c/compress.d new file mode 100644 index 0000000..bee6bfa --- /dev/null +++ b/dmagick/c/compress.d @@ -0,0 +1,42 @@ +module dmagick.c.compress; + +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + enum CompressionType + { + UndefinedCompression, + NoCompression, + BZipCompression, + DXT1Compression, + DXT3Compression, + DXT5Compression, + FaxCompression, + Group4Compression, + JPEGCompression, + JPEG2000Compression, + LosslessJPEGCompression, + LZWCompression, + RLECompression, + ZipCompression, + ZipSCompression, + PizCompression, + Pxr24Compression, + B44Compression, + B44ACompression + } + + struct Ascii85Info {} + + MagickBooleanType HuffmanDecodeImage(Image*); + MagickBooleanType HuffmanEncodeImage(const ImageInfo*, Image*, Image*); + MagickBooleanType LZWEncodeImage(Image*, const size_t, ubyte*); + MagickBooleanType PackbitsEncodeImage(Image*, const size_t, ubyte*); + MagickBooleanType ZLIBEncodeImage(Image*, const size_t, ubyte*); + + void Ascii85Encode(Image*, const ubyte); + void Ascii85Flush(Image*); + void Ascii85Initialize(Image*); +} diff --git a/dmagick/c/configure.d b/dmagick/c/configure.d new file mode 100644 index 0000000..ffd7942 --- /dev/null +++ b/dmagick/c/configure.d @@ -0,0 +1,46 @@ +module dmagick.c.configure; + +import core.stdc.stdio; + +import dmagick.c.exception; +import dmagick.c.hashmap; +import dmagick.c.magickType; + +extern(C) +{ + struct ConfigureInfo + { + char* + path, + name, + value; + + MagickBooleanType + exempt, + stealth; + + ConfigureInfo* + previous, + next; + + size_t + signature; + } + + char** GetConfigureList(const char*, size_t*, ExceptionInfo*); + char* GetConfigureOption(const char*); + + const(char*) GetConfigureValue(const ConfigureInfo*); + + const(ConfigureInfo*) GetConfigureInfo(const char*, ExceptionInfo*); + const(ConfigureInfo**) GetConfigureInfoList(const char*, size_t*, ExceptionInfo*); + + LinkedListInfo* DestroyConfigureOptions(LinkedListInfo *); + LinkedListInfo* GetConfigurePaths(const char *,ExceptionInfo *); + LinkedListInfo* GetConfigureOptions(const char *,ExceptionInfo *); + + MagickBooleanType ConfigureComponentGenesis(); + MagickBooleanType ListConfigureInfo(FILE*, ExceptionInfo*); + + void ConfigureComponentTerminus(); +} diff --git a/dmagick/c/constitute.d b/dmagick/c/constitute.d new file mode 100644 index 0000000..ddf3de7 --- /dev/null +++ b/dmagick/c/constitute.d @@ -0,0 +1,33 @@ +module dmagick.c.constitute; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + enum StorageType + { + UndefinedPixel, + CharPixel, + DoublePixel, + FloatPixel, + IntegerPixel, + LongPixel, + QuantumPixel, + ShortPixel + } + + Image* ConstituteImage(const size_t, const size_t, const char*, const StorageType, const void*, ExceptionInfo*); + Image* PingImage(const ImageInfo*, ExceptionInfo*); + Image* PingImages(const ImageInfo*, ExceptionInfo*); + Image* ReadImage(const ImageInfo*, ExceptionInfo*); + Image* ReadImages(const ImageInfo*, ExceptionInfo*); + Image* ReadInlineImage(const ImageInfo*, const char*, ExceptionInfo*); + + MagickBooleanType ConstituteComponentGenesis(); + MagickBooleanType WriteImage(const ImageInfo*, Image*); + MagickBooleanType WriteImages(const ImageInfo*, Image*, const char*, ExceptionInfo*); + + void ConstituteComponentTerminus(); +} diff --git a/dmagick/c/decorate.d b/dmagick/c/decorate.d new file mode 100644 index 0000000..7aa15f1 --- /dev/null +++ b/dmagick/c/decorate.d @@ -0,0 +1,29 @@ +module dmagick.c.decorate; + +import core.sys.posix.sys.types; + +import dmagick.c.exception; +import dmagick.c.geometry; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + struct FrameInfo + { + size_t + width, + height; + + ssize_t + x, + y, + inner_bevel, + outer_bevel; + } + + Image* BorderImage(const Image*, const RectangleInfo*, ExceptionInfo*); + Image* FrameImage(const Image*, const FrameInfo*, ExceptionInfo*); + + MagickBooleanType RaiseImage(Image*, const RectangleInfo*, const MagickBooleanType); +} diff --git a/dmagick/c/deprecate.d b/dmagick/c/deprecate.d new file mode 100644 index 0000000..e68cc5e --- /dev/null +++ b/dmagick/c/deprecate.d @@ -0,0 +1,193 @@ +module dmagick.c.deprecate; + +import core.vararg; +import core.stdc.stdio; +import core.sys.posix.sys.types; + +import dmagick.c.cacheView; +import dmagick.c.colorspace; +import dmagick.c.constitute; +import dmagick.c.draw; +import dmagick.c.exception; +import dmagick.c.geometry; +import dmagick.c.image; +import dmagick.c.magickType; +import dmagick.c.pixel; +import dmagick.c.quantize; +import dmagick.c.quantum; +import dmagick.c.registry; +import dmagick.c.resample; +import dmagick.c.semaphore; + +deprecated extern(C) +{ + enum MagickLayerMethod + { + UndefinedMagickLayerMethod + } + + alias MagickOffsetType ExtendedSignedIntegralType; + alias MagickSizeType ExtendedUnsignedIntegralType; + alias MagickRealType ExtendedRationalType; + + struct ViewInfo {} + + alias MagickBooleanType function(const char*, const MagickOffsetType, const MagickSizeType, ExceptionInfo*) MonitorHandler; + + struct ImageAttribute + { + char* + key, + value; + + MagickBooleanType + compression; + + ImageAttribute* + previous, + next; + } + + CacheView* CloseCacheView(CacheView*); + CacheView* OpenCacheView(const Image*); + + char* AllocateString(const char*); + char* InterpretImageAttributes(const ImageInfo*, Image*, const char*); + char* PostscriptGeometry(const char*); + char* TranslateText(const ImageInfo *,Image *,const char *); + + const(ImageAttribute*) GetImageAttribute(const Image*, const char*); + const(ImageAttribute*) GetImageClippingPathAttribute(Image*); + const(ImageAttribute*) GetNextImageAttribute(const Image*); + + const(IndexPacket*) AcquireCacheViewIndexes(const CacheView*); + const(IndexPacket*) AcquireIndexes(const Image*); + + const(PixelPacket*) AcquirePixels(const Image*); + const(PixelPacket*) AcquireCacheViewPixels(const CacheView*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*); + const(PixelPacket*) AcquireImagePixels(const Image*, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo*); + + Image* AllocateImage(const ImageInfo*); + Image* AverageImages(const Image*, ExceptionInfo*); + Image* ExtractSubimageFromImage(Image*, const Image*, ExceptionInfo*); + Image* GetImageFromMagickRegistry(const char*, ssize_t* id, ExceptionInfo*); + Image* GetImageList(const Image*, const ssize_t, ExceptionInfo*); + Image* GetNextImage(const Image*); + Image* GetPreviousImage(const Image*); + Image* FlattenImages(Image*, ExceptionInfo*); + Image* MaximumImages(const Image*, ExceptionInfo*); + Image* MinimumImages(const Image*, ExceptionInfo*); + Image* MosaicImages(Image*, ExceptionInfo*); + Image* PopImageList(Image**); + Image* RecolorImage(const Image*, const size_t, const double*, ExceptionInfo*); + Image* ShiftImageList(Image**); + Image* SpliceImageList(Image*, const ssize_t, const size_t, const Image*, ExceptionInfo*); + Image* ZoomImage(const Image*, const size_t, const size_t, ExceptionInfo*); + + IndexPacket* GetCacheViewIndexes(CacheView*); + IndexPacket* GetIndexes(const Image*); + IndexPacket ValidateColormapIndex(Image*, const size_t); + + int GetImageGeometry(Image*, const char*, const uint, RectangleInfo*); + int ParseImageGeometry(const char*, ssize_t*, ssize_t*, size_t*, size_t*); + + ssize_t GetImageListIndex(const Image*); + ssize_t SetMagickRegistry(const RegistryType, const void*, const size_t, ExceptionInfo*); + + MagickBooleanType AcquireOneCacheViewPixel(const CacheView*, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*); + MagickBooleanType AcquireOneCacheViewVirtualPixel(const CacheView*, const VirtualPixelMethod, const ssize_t, const ssize_t, PixelPacket*, ExceptionInfo*); + MagickBooleanType AffinityImage(const QuantizeInfo*, Image*, const Image*); + MagickBooleanType AffinityImages(const QuantizeInfo*, Image*, const Image*); + MagickBooleanType AllocateImageColormap(Image*, const size_t); + MagickBooleanType ClipPathImage(Image*, const char*, const MagickBooleanType); + MagickBooleanType CloneImageAttributes(Image*, const Image*); + MagickBooleanType ColorFloodfillImage(Image*, const DrawInfo*, const PixelPacket, const ssize_t, const ssize_t, const PaintMethod); + MagickBooleanType DeleteImageAttribute(Image*, const char*); + MagickBooleanType DeleteMagickRegistry(const ssize_t); + MagickBooleanType DescribeImage(Image*, FILE*, const MagickBooleanType); + MagickBooleanType FormatImageAttribute(Image*, const char*, const char*, ...); + MagickBooleanType FormatImageAttributeList(Image*, const char*, const char*, va_list); + MagickBooleanType FuzzyColorCompare(const Image*, const PixelPacket*, const PixelPacket*); + MagickBooleanType FuzzyOpacityCompare(const Image*, const PixelPacket*, const PixelPacket*); + MagickBooleanType LevelImageColors(Image*, const ChannelType, const MagickPixelPacket*, const MagickPixelPacket*, const MagickBooleanType); + MagickBooleanType MagickMonitor(const char*, const MagickOffsetType, const MagickSizeType, void*); + MagickBooleanType MapImage(Image*, const Image*, const MagickBooleanType); + MagickBooleanType MapImages(Image*, const Image*, const MagickBooleanType); + MagickBooleanType MatteFloodfillImage(Image*, const PixelPacket, const Quantum, const ssize_t, const ssize_t, const PaintMethod); + MagickBooleanType OpaqueImage(Image*, const PixelPacket, const PixelPacket); + MagickBooleanType PaintFloodfillImage(Image*, const ChannelType, const MagickPixelPacket*, const ssize_t, const ssize_t, const DrawInfo*, const PaintMethod); + MagickBooleanType PaintOpaqueImage(Image*, const MagickPixelPacket*, const MagickPixelPacket*); + MagickBooleanType PaintOpaqueImageChannel(Image*, const ChannelType, const MagickPixelPacket*, const MagickPixelPacket*); + MagickBooleanType PaintTransparentImage(Image*, const MagickPixelPacket*, const Quantum); + MagickBooleanType SetExceptionInfo(ExceptionInfo*, ExceptionType); + MagickBooleanType SetImageAttribute(Image*, const char*, const char*); + MagickBooleanType SyncCacheViewPixels(CacheView*); + MagickBooleanType SyncImagePixels(Image*); + MagickBooleanType TransparentImage(Image*, const PixelPacket, const Quantum); + + MagickPixelPacket AcquireOneMagickPixel(const Image*, const ssize_t, const ssize_t, ExceptionInfo*); + + MonitorHandler GetMonitorHandler(); + MonitorHandler SetMonitorHandler(MonitorHandler); + + MagickOffsetType SizeBlob(Image* image); + + MagickPixelPacket InterpolatePixelColor(const Image*, CacheView*, const InterpolatePixelMethod, const double, const double, ExceptionInfo*); + + MagickStatusType ParseSizeGeometry(const Image*, const char*, RectangleInfo*); + + PixelPacket AcquireOnePixel(const Image*, const ssize_t, const ssize_t, ExceptionInfo*); + PixelPacket AcquireOneVirtualPixel(const Image*, const VirtualPixelMethod, const ssize_t, const ssize_t, ExceptionInfo*); + PixelPacket* GetCacheView(CacheView*, const ssize_t, const ssize_t, const size_t, const size_t); + PixelPacket* GetCacheViewPixels(CacheView*, const ssize_t, const ssize_t, const size_t, const size_t); + PixelPacket* GetImagePixels(Image*, const ssize_t, const ssize_t, const size_t, const size_t); + PixelPacket GetOnePixel(Image*, const ssize_t, const ssize_t); + PixelPacket* GetPixels(const Image*); + PixelPacket* SetCacheViewPixels(CacheView*, const ssize_t, const ssize_t, const size_t, const size_t); + PixelPacket* SetImagePixels(Image*, const ssize_t, const ssize_t, const size_t, const size_t); + + size_t GetImageListSize(const Image*); + size_t PopImagePixels(Image*, const QuantumType, ubyte*); + size_t PushImagePixels(Image*, const QuantumType, const byte*); + + uint ChannelImage(Image*, const ChannelType); + uint ChannelThresholdImage(Image*, const char*); + uint DispatchImage(const Image*, const ssize_t, const ssize_t, const size_t, const size_t, const char*, const StorageType, void*, ExceptionInfo*); + uint FuzzyColorMatch(const PixelPacket*, const PixelPacket*, const double); + uint GetNumberScenes(const Image*); + uint GetMagickGeometry(const char*, ssize_t*, ssize_t*, size_t*, size_t*); + uint IsSubimage(const char*, const uint); + uint PushImageList(Image**, const Image*, ExceptionInfo*); + uint QuantizationError(Image*); + uint RandomChannelThresholdImage(Image*, const char*, const char*, ExceptionInfo*); + uint SetImageList(Image**, const Image*, const ssize_t, ExceptionInfo*); + uint TransformColorspace(Image*, const ColorspaceType); + uint ThresholdImage(Image*, const double); + uint ThresholdImageChannel(Image*, const char*); + uint UnshiftImageList(Image**, const Image*, ExceptionInfo*); + + void* AcquireMemory(const size_t); + void AllocateNextImage(const ImageInfo*, Image*); + void* CloneMemory(void*, const void*, const size_t); + void DestroyImageAttributes(Image*); + void DestroyImages(Image*); + void DestroyMagick(); + void DestroyMagickRegistry(); + void* GetConfigureBlob(const char*, char*, size_t*, ExceptionInfo*); + void* GetMagickRegistry(const ssize_t, RegistryType*, size_t*, ExceptionInfo*); + void IdentityAffine(AffineMatrix*); + void LiberateMemory(void**); + void LiberateSemaphoreInfo(SemaphoreInfo**); + void FormatString(char*, const char*, ...); + void FormatStringList(char*, const char*, va_list); + void HSLTransform(const double, const double, const double, Quantum*, Quantum*, Quantum*); + void InitializeMagick(const char*); + void MagickIncarnate(const char*); + void ReacquireMemory(void**, const size_t); + void ResetImageAttributeIterator(const Image*); + void SetCacheThreshold(const size_t); + void SetImage(Image*, const Quantum); + void Strip(char*); + void TemporaryFilename(char*); + void TransformHSL(const Quantum, const Quantum, const Quantum, double*, double*, double*); +} diff --git a/dmagick/c/display.d b/dmagick/c/display.d new file mode 100644 index 0000000..3b11356 --- /dev/null +++ b/dmagick/c/display.d @@ -0,0 +1,11 @@ +module dmagick.c.display; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + MagickBooleanType DisplayImages(const ImageInfo*, Image*); + MagickBooleanType RemoteDisplayCommand(const ImageInfo*, const char*, const char*, ExceptionInfo*); +} diff --git a/dmagick/c/distort.d b/dmagick/c/distort.d new file mode 100644 index 0000000..bb32224 --- /dev/null +++ b/dmagick/c/distort.d @@ -0,0 +1,43 @@ +module dmagick.c.distort; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + enum DistortImageMethod + { + UndefinedDistortion, + AffineDistortion, + AffineProjectionDistortion, + ScaleRotateTranslateDistortion, + PerspectiveDistortion, + PerspectiveProjectionDistortion, + BilinearForwardDistortion, + BilinearDistortion = BilinearForwardDistortion, + BilinearReverseDistortion, + PolynomialDistortion, + ArcDistortion, + PolarDistortion, + DePolarDistortion, + BarrelDistortion, + BarrelInverseDistortion, + ShepardsDistortion, + SentinelDistortion + } + + enum SparseColorMethod + { + UndefinedColorInterpolate = DistortImageMethod.UndefinedDistortion, + BarycentricColorInterpolate = DistortImageMethod.AffineDistortion, + BilinearColorInterpolate = DistortImageMethod.BilinearReverseDistortion, + PolynomialColorInterpolate = DistortImageMethod.PolynomialDistortion, + ShepardsColorInterpolate = DistortImageMethod.ShepardsDistortion, + + VoronoiColorInterpolate = DistortImageMethod.SentinelDistortion + } + + Image* DistortImage(const Image*, const DistortImageMethod, const size_t, const double*, MagickBooleanType, ExceptionInfo* exception); + Image* SparseColorImage(const Image*, const ChannelType, const SparseColorMethod, const size_t, const double*, ExceptionInfo*); +} diff --git a/dmagick/c/draw.d b/dmagick/c/draw.d new file mode 100644 index 0000000..7032abe --- /dev/null +++ b/dmagick/c/draw.d @@ -0,0 +1,369 @@ +module dmagick.c.draw; + +import dmagick.c.composite; +import dmagick.c.geometry; +import dmagick.c.image; +import dmagick.c.magickType; +import dmagick.c.pixel; +import dmagick.c.type; + +extern(C) +{ + enum AlignType + { + UndefinedAlign, + LeftAlign, + CenterAlign, + RightAlign + } + + enum ClipPathUnits + { + UndefinedPathUnits, + UserSpace, + UserSpaceOnUse, + ObjectBoundingBox + } + + enum DecorationType + { + UndefinedDecoration, + NoDecoration, + UnderlineDecoration, + OverlineDecoration, + LineThroughDecoration + } + + enum DirectionType + { + UndefinedDirection, + RightToLeftDirection, + LeftToRightDirection + } + + enum FillRule + { + UndefinedRule, + + EvenOddRule, + NonZeroRule + } + + enum GradientType + { + UndefinedGradient, + LinearGradient, + RadialGradient + } + + enum LineCap + { + UndefinedCap, + ButtCap, + RoundCap, + SquareCap + } + + enum LineJoin + { + UndefinedJoin, + MiterJoin, + RoundJoin, + BevelJoin + } + + enum PaintMethod + { + UndefinedMethod, + PointMethod, + ReplaceMethod, + FloodfillMethod, + FillToBorderMethod, + ResetMethod + } + + enum PrimitiveType + { + UndefinedPrimitive, + PointPrimitive, + LinePrimitive, + RectanglePrimitive, + RoundRectanglePrimitive, + ArcPrimitive, + EllipsePrimitive, + CirclePrimitive, + PolylinePrimitive, + PolygonPrimitive, + BezierPrimitive, + ColorPrimitive, + MattePrimitive, + TextPrimitive, + ImagePrimitive, + PathPrimitive + } + + enum ReferenceType + { + UndefinedReference, + GradientReference + } + + enum SpreadMethod + { + UndefinedSpread, + PadSpread, + ReflectSpread, + RepeatSpread + } + + struct PointInfo + { + double + x, + y; + } + + struct StopInfo + { + MagickPixelPacket + color; + + MagickRealType + offset; + } + + struct GradientInfo + { + GradientType + type; + + RectangleInfo + bounding_box; + + SegmentInfo + gradient_vector; + + StopInfo* + stops; + + size_t + number_stops; + + SpreadMethod + spread; + + MagickBooleanType + ddebug; + + size_t + signature; + + PointInfo + center; + + MagickRealType + radius; + } + + struct ElementReference + { + char* + id; + + ReferenceType + type; + + GradientInfo + gradient; + + size_t + signature; + + ElementReference* + previous, + next; + } + + 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 + aalign; + + 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 + ddebug; + + size_t + signature; + + double + kerning, + interword_spacing, + interline_spacing; + + DirectionType + direction; + } + + struct PrimitiveInfo + { + PointInfo + point; + + size_t + coordinates; + + PrimitiveType + primitive; + + PaintMethod + method; + + char* + text; + } + + struct TypeMetric + { + PointInfo + pixels_per_em; + + double + ascent, + descent, + width, + height, + max_advance, + underline_position, + underline_thickness; + + SegmentInfo + bounds; + + PointInfo + origin; + } + + DrawInfo* AcquireDrawInfo(); + DrawInfo* CloneDrawInfo(const ImageInfo*, const DrawInfo*); + DrawInfo* DestroyDrawInfo(DrawInfo*); + + MagickBooleanType DrawAffineImage(Image*, const Image*, const AffineMatrix*); + MagickBooleanType DrawClipPath(Image*, const DrawInfo*, const char*); + MagickBooleanType DrawGradientImage(Image*, const DrawInfo*); + MagickBooleanType DrawImage(Image*, const DrawInfo*); + MagickBooleanType DrawPatternPath(Image*, const DrawInfo*, const char*, Image**); + MagickBooleanType DrawPrimitive(Image*, const DrawInfo*, const PrimitiveInfo*); + + void GetAffineMatrix(AffineMatrix*); + void GetDrawInfo(const ImageInfo*, DrawInfo*); +} diff --git a/dmagick/c/effect.d b/dmagick/c/effect.d new file mode 100644 index 0000000..b229a8f --- /dev/null +++ b/dmagick/c/effect.d @@ -0,0 +1,74 @@ +module dmagick.c.effect; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; +import dmagick.c.morphology; + +extern(C) +{ + enum PreviewType + { + 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 + } + + Image* AdaptiveBlurImage(const Image*, const double, const double, ExceptionInfo*); + Image* AdaptiveBlurImageChannel(const Image*, const ChannelType, const double, const double, ExceptionInfo*); + Image* AdaptiveSharpenImage(const Image*, const double, const double, ExceptionInfo*); + Image* AdaptiveSharpenImageChannel(const Image*, const ChannelType, const double, const double, ExceptionInfo*); + Image* BlurImage(const Image*, const double, const double, ExceptionInfo*); + Image* BlurImageChannel(const Image*, const ChannelType, const double, const double, ExceptionInfo*); + Image* ConvolveImage(const Image*, const size_t, const double*, ExceptionInfo*); + Image* ConvolveImageChannel(const Image*, const ChannelType, const size_t, const double*, ExceptionInfo*); + Image* DespeckleImage(const Image*, ExceptionInfo*); + Image* EdgeImage(const Image*, const double, ExceptionInfo*); + Image* EmbossImage(const Image*, const double, const double, ExceptionInfo*); + Image* FilterImage(const Image*, const KernelInfo*, ExceptionInfo*); + Image* FilterImageChannel(const Image*, const ChannelType, const KernelInfo*, ExceptionInfo*); + Image* GaussianBlurImage(const Image*, const double, const double, ExceptionInfo*); + Image* GaussianBlurImageChannel(const Image*, const ChannelType, const double, const double, ExceptionInfo*); + Image* MedianFilterImage(const Image*, const double, ExceptionInfo*); + Image* MotionBlurImage(const Image*, const double, const double, const double, ExceptionInfo*); + Image* MotionBlurImageChannel(const Image*, const ChannelType, const double, const double, const double, ExceptionInfo*); + Image* PreviewImage(const Image*, const PreviewType, ExceptionInfo*); + Image* RadialBlurImage(const Image*, const double, ExceptionInfo*); + Image* RadialBlurImageChannel(const Image*, const ChannelType, const double, ExceptionInfo*); + Image* ReduceNoiseImage(const Image*, const double, ExceptionInfo*); + Image* SelectiveBlurImage(const Image*, const double, const double, const double, ExceptionInfo*); + Image* SelectiveBlurImageChannel(const Image*, const ChannelType, const double, const double, const double, ExceptionInfo*); + Image* ShadeImage(const Image*, const MagickBooleanType, const double, const double, ExceptionInfo*); + Image* SharpenImage(const Image*, const double, const double, ExceptionInfo*); + Image* SharpenImageChannel(const Image*, const ChannelType ,const double, const double, ExceptionInfo*); + Image* SpreadImage(const Image*, const double, ExceptionInfo*); + Image* UnsharpMaskImage(const Image*, const double, const double, const double, const double, ExceptionInfo*); + Image* UnsharpMaskImageChannel(const Image*, const ChannelType, const double, const double, const double, const double, ExceptionInfo*); +} diff --git a/dmagick/c/enhance.d b/dmagick/c/enhance.d new file mode 100644 index 0000000..6138e2c --- /dev/null +++ b/dmagick/c/enhance.d @@ -0,0 +1,44 @@ +module dmagick.c.enhance; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; +import dmagick.c.pixel; + +extern(C) +{ + MagickBooleanType AutoGammaImage(Image*); + MagickBooleanType AutoGammaImageChannel(Image*, const ChannelType); + MagickBooleanType AutoLevelImage(Image*); + MagickBooleanType AutoLevelImageChannel(Image*, const ChannelType); + MagickBooleanType BrightnessContrastImage(Image*, const double, const double); + MagickBooleanType BrightnessContrastImageChannel(Image*, const ChannelType, const double, const double); + MagickBooleanType ClutImage(Image*, const Image*); + MagickBooleanType ClutImageChannel(Image*, const ChannelType, const Image*); + MagickBooleanType ColorDecisionListImage(Image*, const char*); + MagickBooleanType ContrastImage(Image*, const MagickBooleanType); + MagickBooleanType ContrastStretchImage(Image*, const char*); + MagickBooleanType ContrastStretchImageChannel(Image*, const ChannelType, const double, const double); + MagickBooleanType EqualizeImage(Image* image); + MagickBooleanType EqualizeImageChannel(Image* image, const ChannelType); + MagickBooleanType GammaImage(Image*, const char*); + MagickBooleanType GammaImageChannel(Image*, const ChannelType, const double); + MagickBooleanType HaldClutImage(Image*, const Image*); + MagickBooleanType HaldClutImageChannel(Image*, const ChannelType, const Image*); + MagickBooleanType LevelImage(Image*, const char*); + MagickBooleanType LevelImageChannel(Image*, const ChannelType, const double, const double, const double); + MagickBooleanType LevelizeImage(Image*, const double, const double, const double); + MagickBooleanType LevelizeImageChannel(Image*, const ChannelType, const double, const double, const double); + MagickBooleanType LevelColorsImage(Image*, const MagickPixelPacket*, const MagickPixelPacket*, const MagickBooleanType); + MagickBooleanType LevelColorsImageChannel(Image*, const ChannelType, const MagickPixelPacket*, const MagickPixelPacket*, const MagickBooleanType); + MagickBooleanType LinearStretchImage(Image*, const double, const double); + MagickBooleanType ModulateImage(Image*, const char*); + MagickBooleanType NegateImage(Image*, const MagickBooleanType); + MagickBooleanType NegateImageChannel(Image*, const ChannelType, const MagickBooleanType); + MagickBooleanType NormalizeImage(Image*); + MagickBooleanType NormalizeImageChannel(Image*, const ChannelType); + MagickBooleanType SigmoidalContrastImage(Image*, const MagickBooleanType, const char*); + MagickBooleanType SigmoidalContrastImageChannel(Image*, const ChannelType, const MagickBooleanType, const double, const double); + + Image* EnhanceImage(const Image*, ExceptionInfo*); +} diff --git a/dmagick/c/exception.d b/dmagick/c/exception.d new file mode 100644 index 0000000..9236455 --- /dev/null +++ b/dmagick/c/exception.d @@ -0,0 +1,137 @@ +module dmagick.c.exception; + +import core.vararg; + +import dmagick.c.magickType; +import dmagick.c.semaphore; + +extern(C) +{ + enum ExceptionType + { + 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 + } + + struct ExceptionInfo + { + ExceptionType + severity; + + int + error_number; + + char* + reason, + description; + + void* + exceptions; + + MagickBooleanType + relinquish; + + SemaphoreInfo* + semaphore; + + size_t + signature; + } + + alias void function(const ExceptionType, const char*, const char*) ErrorHandler; + alias void function(const ExceptionType, const char*, const char*) FatalErrorHandler; + alias void function(const ExceptionType, const char*, const char*) WarningHandler; + + char* GetExceptionMessage(const int); + + const(char*) GetLocaleExceptionMessage(const ExceptionType, const char*); + + ErrorHandler SetErrorHandler(ErrorHandler); + + ExceptionInfo* AcquireExceptionInfo(); + ExceptionInfo* DestroyExceptionInfo(ExceptionInfo*); + + FatalErrorHandler SetFatalErrorHandler(FatalErrorHandler); + + MagickBooleanType ThrowException(ExceptionInfo*, const ExceptionType, const char*, const char*); + MagickBooleanType ThrowMagickException(ExceptionInfo*, const char*, const char*, const size_t, const ExceptionType, const char*, const char*, ...); + MagickBooleanType ThrowMagickExceptionList(ExceptionInfo*, const char*, const char*, const size_t, const ExceptionType, const char*, const char*, va_list); + + void CatchException(ExceptionInfo*); + void ClearMagickException(ExceptionInfo*); + void GetExceptionInfo(ExceptionInfo*); + void InheritException(ExceptionInfo*, const ExceptionInfo*); + void MagickError(const ExceptionType, const char*, const char*); + void MagickFatalError(const ExceptionType, const char*, const char*); + void MagickWarning(const ExceptionType, const char*, const char*); + + WarningHandler SetWarningHandler(WarningHandler); +} diff --git a/dmagick/c/feature.d b/dmagick/c/feature.d new file mode 100644 index 0000000..1ebef79 --- /dev/null +++ b/dmagick/c/feature.d @@ -0,0 +1,28 @@ +module dmagick.c.feature; + +import dmagick.c.exception; +import dmagick.c.image; + +extern(C) +{ + struct ChannelFeatures + { + double[4] + angular_second_moment, + contrast, + correlation, + variance_sum_of_squares, + inverse_difference_moment, + sum_average, + sum_variance, + sum_entropy, + entropy, + difference_variance, + difference_entropy, + measure_of_correlation_1, + measure_of_correlation_2, + maximum_correlation_coefficient; + } + + ChannelFeatures* GetImageChannelFeatures(const Image*, const size_t, ExceptionInfo*); +} diff --git a/dmagick/c/fourier.d b/dmagick/c/fourier.d new file mode 100644 index 0000000..d866dac --- /dev/null +++ b/dmagick/c/fourier.d @@ -0,0 +1,11 @@ +module dmagick.c.fourier; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + Image* ForwardFourierTransformImage(const Image*, const MagickBooleanType, ExceptionInfo*); + Image* InverseFourierTransformImage(const Image*, const Image*, const MagickBooleanType, ExceptionInfo*); +} diff --git a/dmagick/c/fx.d b/dmagick/c/fx.d new file mode 100644 index 0000000..b02a49c --- /dev/null +++ b/dmagick/c/fx.d @@ -0,0 +1,50 @@ +module dmagick.c.fx; + +import core.sys.posix.sys.types; + +import dmagick.c.draw; +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; +import dmagick.c.morphology; +import dmagick.c.pixel; + +extern(C) +{ + enum NoiseType + { + UndefinedNoise, + UniformNoise, + GaussianNoise, + MultiplicativeGaussianNoise, + ImpulseNoise, + LaplacianNoise, + PoissonNoise, + RandomNoise + } + + Image* AddNoiseImage(const Image*, const NoiseType, ExceptionInfo*); + Image* AddNoiseImageChannel(const Image*, const ChannelType, const NoiseType, ExceptionInfo*); + Image* BlueShiftImage(const Image*, const double, ExceptionInfo*); + Image* CharcoalImage(const Image*, const double, const double, ExceptionInfo*); + Image* ColorizeImage(const Image*, const char*, const PixelPacket, ExceptionInfo*); + Image* ColorMatrixImage(const Image*, const KernelInfo* kernel, ExceptionInfo*); + Image* FxImage(const Image*, const char*, ExceptionInfo*); + Image* FxImageChannel(const Image*, const ChannelType, const char*, ExceptionInfo*); + Image* ImplodeImage(const Image*, const double, ExceptionInfo*); + Image* MorphImages(const Image*, const size_t, ExceptionInfo*); + Image* PolaroidImage(const Image*, const DrawInfo*, const double, ExceptionInfo*); + Image* SepiaToneImage(const Image*, const double, ExceptionInfo*); + Image* ShadowImage(const Image*, const double, const double, const ssize_t, const ssize_t, ExceptionInfo*); + Image* SketchImage(const Image*, const double, const double, const double, ExceptionInfo*); + Image* SteganoImage(const Image*, const Image*, ExceptionInfo*); + Image* StereoImage(const Image*, const Image*, ExceptionInfo*); + Image* StereoAnaglyphImage(const Image*, const Image*, const ssize_t, const ssize_t, ExceptionInfo*); + Image* SwirlImage(const Image*, double, ExceptionInfo*); + Image* TintImage(const Image*, const char*, const PixelPacket, ExceptionInfo*); + Image* VignetteImage(const Image*, const double, const double, const ssize_t, const ssize_t, ExceptionInfo*); + Image* WaveImage(const Image*, const double, const double, ExceptionInfo*); + + MagickBooleanType PlasmaImage(Image*, const SegmentInfo*, size_t, size_t); + MagickBooleanType SolarizeImage(Image*, const double); +} diff --git a/dmagick/c/gem.d b/dmagick/c/gem.d new file mode 100644 index 0000000..1833005 --- /dev/null +++ b/dmagick/c/gem.d @@ -0,0 +1,23 @@ +module dmagick.c.gem; + +import dmagick.c.geometry; +import dmagick.c.magickType; +import dmagick.c.fx; +import dmagick.c.random; + +extern(C) +{ + double ExpandAffine(const AffineMatrix*); + double GenerateDifferentialNoise(RandomInfo*, const Quantum, const NoiseType, const MagickRealType); + + size_t GetOptimalKernelWidth(const double, const double); + size_t GetOptimalKernelWidth1D(const double, const double); + size_t GetOptimalKernelWidth2D(const double, const double); + + void ConvertHSBToRGB(const double, const double, const double, Quantum*, Quantum*, Quantum*); + void ConvertHSLToRGB(const double, const double, const double, Quantum*, Quantum*, Quantum*); + void ConvertHWBToRGB(const double, const double, const double, Quantum*, Quantum *,Quantum*); + void ConvertRGBToHSB(const Quantum, const Quantum, const Quantum, double*, double*, double*); + void ConvertRGBToHSL(const Quantum, const Quantum, const Quantum, double*, double*, double*); + void ConvertRGBToHWB(const Quantum, const Quantum, const Quantum, double*, double*, double*); +} diff --git a/dmagick/c/geometry.d b/dmagick/c/geometry.d new file mode 100644 index 0000000..126944e --- /dev/null +++ b/dmagick/c/geometry.d @@ -0,0 +1,119 @@ +module dmagick.c.geometry; + +import core.sys.posix.sys.types; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + enum GeometryFlags + { + NoValue = 0x0000, + + XValue = 0x0001, + XiValue = 0x0001, + + YValue = 0x0002, + PsiValue = 0x0002, + + WidthValue = 0x0004, + RhoValue = 0x0004, + + HeightValue = 0x0008, + SigmaValue = 0x0008, + ChiValue = 0x0010, + XiNegative = 0x0020, + + XNegative = 0x0020, + PsiNegative = 0x0040, + + YNegative = 0x0040, + ChiNegative = 0x0080, + PercentValue = 0x1000, + AspectValue = 0x2000, + NormalizeValue = 0x2000, + LessValue = 0x4000, + GreaterValue = 0x8000, + MinimumValue = 0x10000, + CorrelateNormalizeValue = 0x10000, + AreaValue = 0x20000, + DecimalValue = 0x40000, + + AllValues = 0x7fffffff + } + + enum GravityType + { + UndefinedGravity, + ForgetGravity = 0, + NorthWestGravity = 1, + NorthGravity = 2, + NorthEastGravity = 3, + WestGravity = 4, + CenterGravity = 5, + EastGravity = 6, + SouthWestGravity = 7, + SouthGravity = 8, + SouthEastGravity = 9, + StaticGravity = 10 + } + + struct AffineMatrix + { + double + sx, + rx, + ry, + sy, + tx, + ty; + } + + struct GeometryInfo + { + double + rho, + sigma, + xi, + psi, + chi; + } + + struct OffsetInfo + { + ssize_t + x, + y; + } + + struct RectangleInfo + { + size_t + width, + height; + + ssize_t + x, + y; + } + + char* GetPageGeometry(const char*); + + MagickBooleanType IsGeometry(const char*); + MagickBooleanType IsSceneGeometry(const char*, const MagickBooleanType); + + MagickStatusType GetGeometry(const char*, ssize_t*, ssize_t*, size_t*, size_t*); + MagickStatusType ParseAbsoluteGeometry(const char*, RectangleInfo*); + MagickStatusType ParseAffineGeometry(const char*, AffineMatrix*, ExceptionInfo*); + MagickStatusType ParseGeometry(const char*, GeometryInfo*); + MagickStatusType ParseGravityGeometry(const Image*, const char*, RectangleInfo*, ExceptionInfo*); + MagickStatusType ParseMetaGeometry(const char*, ssize_t*, ssize_t*, size_t*, size_t*); + MagickStatusType ParsePageGeometry(const Image*, const char*, RectangleInfo*, ExceptionInfo*); + MagickStatusType ParseRegionGeometry(const Image*, const char*, RectangleInfo*, ExceptionInfo*); + + void GravityAdjustGeometry(const size_t, const size_t, const GravityType, RectangleInfo*); + void SetGeometry(const Image*, RectangleInfo*); + void SetGeometryInfo(GeometryInfo*); +} diff --git a/dmagick/c/hashmap.d b/dmagick/c/hashmap.d new file mode 100644 index 0000000..a0bcfb2 --- /dev/null +++ b/dmagick/c/hashmap.d @@ -0,0 +1,47 @@ +module dmagick.c.hashmap; + +import dmagick.c.magickType; + +extern(C) +{ + struct HashmapInfo {} + + struct LinkedListInfo {} + + HashmapInfo* DestroyHashmap(HashmapInfo*); + HashmapInfo* NewHashmap(const size_t, size_t function(const void*), + MagickBooleanType function(const void*, const void*), void* function(void*), void* function(void*)); + + LinkedListInfo* DestroyLinkedList(LinkedListInfo*, void* function(void*)); + LinkedListInfo* NewLinkedList(const size_t); + + MagickBooleanType AppendValueToLinkedList(LinkedListInfo*, const void*); + MagickBooleanType CompareHashmapString(const void*, const void*); + MagickBooleanType CompareHashmapStringInfo(const void*, const void*); + MagickBooleanType InsertValueInLinkedList(LinkedListInfo*, const size_t, const void*); + MagickBooleanType InsertValueInSortedLinkedList(LinkedListInfo*, int function(const void*, const void*), void**, const void*); + MagickBooleanType IsHashmapEmpty(const HashmapInfo*); + MagickBooleanType IsLinkedListEmpty(const LinkedListInfo*); + MagickBooleanType LinkedListToArray(LinkedListInfo*, void**); + MagickBooleanType PutEntryInHashmap(HashmapInfo*, const void*, const void*); + + size_t GetNumberOfElementsInLinkedList(const LinkedListInfo*); + size_t GetNumberOfEntriesInHashmap(const HashmapInfo*); + size_t HashPointerType(const void*); + size_t HashStringType(const void*); + size_t HashStringInfoType(const void*); + + void ClearLinkedList(LinkedListInfo*, void* function(void*)); + void* GetLastValueInLinkedList(LinkedListInfo*); + void* GetNextKeyInHashmap(HashmapInfo*); + void* GetNextValueInHashmap(HashmapInfo*); + void* GetNextValueInLinkedList(LinkedListInfo*); + void* GetValueFromHashmap(HashmapInfo*, const void*); + void* GetValueFromLinkedList(LinkedListInfo*, const size_t); + void* RemoveElementByValueFromLinkedList(LinkedListInfo*, const void*); + void* RemoveElementFromLinkedList(LinkedListInfo*, const size_t); + void* RemoveEntryFromHashmap(HashmapInfo*, const void*); + void* RemoveLastElementFromLinkedList(LinkedListInfo*); + void ResetHashmapIterator(HashmapInfo*); + void ResetLinkedListIterator(LinkedListInfo*); +} diff --git a/dmagick/c/histogram.d b/dmagick/c/histogram.d new file mode 100644 index 0000000..2341186 --- /dev/null +++ b/dmagick/c/histogram.d @@ -0,0 +1,33 @@ +module dmagick.c.histogram; + +import core.stdc.stdio; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; +import dmagick.c.pixel; + +extern(C) +{ + struct ColorPacket + { + PixelPacket + pixel; + + IndexPacket + index; + + MagickSizeType + count; + } + + ColorPacket* GetImageHistogram(const Image*, size_t*, ExceptionInfo*); + + Image* UniqueImageColors(const Image*, ExceptionInfo*); + + MagickBooleanType IsHistogramImage(const Image*, ExceptionInfo*); + MagickBooleanType IsPaletteImage(const Image*, ExceptionInfo*); + MagickBooleanType MinMaxStretchImage(Image*, const ChannelType, const double, const double); + + size_t GetNumberColors(const Image*, FILE*, ExceptionInfo*); +} diff --git a/dmagick/c/identify.d b/dmagick/c/identify.d new file mode 100644 index 0000000..a1b523c --- /dev/null +++ b/dmagick/c/identify.d @@ -0,0 +1,8 @@ +module dmagick.c.identify; + +import core.stdc.stdio; + +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) MagickBooleanType IdentifyImage(Image*, FILE*, const MagickBooleanType); diff --git a/dmagick/c/image.d b/dmagick/c/image.d new file mode 100644 index 0000000..54adb1e --- /dev/null +++ b/dmagick/c/image.d @@ -0,0 +1,536 @@ +module dmagick.c.image; + +import core.stdc.stdio; +import core.sys.posix.sys.types; + +import dmagick.c.cacheView; +import dmagick.c.color; +import dmagick.c.colorspace; +import dmagick.c.composite; +import dmagick.c.compress; +import dmagick.c.compress; +import dmagick.c.effect; +import dmagick.c.exception; +import dmagick.c.geometry; +import dmagick.c.layer; +import dmagick.c.magickType; +import dmagick.c.monitor; +import dmagick.c.pixel; +import dmagick.c.profile; +import dmagick.c.quantum; +import dmagick.c.resample; +import dmagick.c.semaphore; +import dmagick.c.stream; +import dmagick.c.timer; + +extern(C) +{ + enum AlphaChannelType + { + UndefinedAlphaChannel, + ActivateAlphaChannel, + BackgroundAlphaChannel, + CopyAlphaChannel, + DeactivateAlphaChannel, + ExtractAlphaChannel, + OpaqueAlphaChannel, + ResetAlphaChannel, + SetAlphaChannel, + ShapeAlphaChannel, + TransparentAlphaChannel + } + + enum ImageType + { + UndefinedType, + BilevelType, + GrayscaleType, + GrayscaleMatteType, + PaletteType, + PaletteMatteType, + TrueColorType, + TrueColorMatteType, + ColorSeparationType, + ColorSeparationMatteType, + OptimizeType, + PaletteBilevelMatteType + } + + enum InterlaceType + { + UndefinedInterlace, + NoInterlace, + LineInterlace, + PlaneInterlace, + PartitionInterlace, + GIFInterlace, + JPEGInterlace, + PNGInterlace + } + + enum OrientationType + { + UndefinedOrientation, + TopLeftOrientation, + TopRightOrientation, + BottomRightOrientation, + BottomLeftOrientation, + LeftTopOrientation, + RightTopOrientation, + RightBottomOrientation, + LeftBottomOrientation + } + + enum ResolutionType + { + UndefinedResolution, + PixelsPerInchResolution, + PixelsPerCentimeterResolution + } + + struct PrimaryInfo + { + double + x, + y, + z; + } + + struct SegmentInfo + { + double + x1, + y1, + x2, + y2; + } + + enum TransmitType + { + UndefinedTransmitType, + FileTransmitType, + BlobTransmitType, + StreamTransmitType, + ImageTransmitType + } + + struct ChromaticityInfo + { + PrimaryInfo + red_primary, + green_primary, + blue_primary, + white_point; + } + + struct Image + { + ClassType + storage_class; + + ColorspaceType + colorspace; + + CompressionType + compression; + + size_t + quality; + + OrientationType + orientation; + + //MagickBooleanType + int + taint, + matte; + + size_t + columns, + rows, + depth, + colors; + + PixelPacket* + colormap; + + PixelPacket + background_color, + border_color, + matte_color; + + double + gamma; + + ChromaticityInfo + chromaticity; + + RenderingIntent + rendering_intent; + + void* + profiles; + + ResolutionType + units; + + char* + montage, + directory, + geometry; + + ssize_t + offset; + + double + x_resolution, + y_resolution; + + RectangleInfo + page, + extract_info, + tile_info; + + double + bias, + blur, + fuzz; + + FilterTypes + filter; + + InterlaceType + interlace; + + EndianType + endian; + + GravityType + gravity; + + CompositeOperator + compose; + + DisposeType + dispose; + + Image* + clip_mask; + + size_t + scene, + delay; + + ssize_t + ticks_per_second; + + size_t + iterations, + total_colors; + + ssize_t + start_loop; + + ErrorInfo + error; + + TimerInfo + timer; + + MagickProgressMonitor + progress_monitor; + + void* + client_data, + cache, + attributes; + + Ascii85Info* + ascii85; + + BlobInfo* + blob; + + char[MaxTextExtent] + filename, + magick_filename, + magick; + + size_t + magick_columns, + magick_rows; + + ExceptionInfo + exception; + + //MagickBooleanType + int + ddebug; + + ssize_t + reference_count; + + SemaphoreInfo* + semaphore; + + ProfileInfo + color_profile, + iptc_profile; + + ProfileInfo* + generic_profile; + + size_t + generic_profiles; + + size_t + signature; + + Image* + previous, + list, + next; + + InterpolatePixelMethod + interpolate; + + //MagickBooleanType + int + black_point_compensation; + + PixelPacket + transparent_color; + + Image* + mask; + + RectangleInfo + tile_offset; + + void* + properties, + artifacts; + + ImageType + type; + + //MagickBooleanType + int + dither; + + MagickSizeType + extent; + + //MagickBooleanType + int + ping; + } + + struct ImageInfo + { + CompressionType + compression; + + OrientationType + orientation; + + //MagickBooleanType + int + 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, + server_name, + font, + texture, + density; + + double + pointsize, + fuzz; + + PixelPacket + background_color, + border_color, + matte_color; + + //MagickBooleanType + int + dither, + monochrome; + + size_t + colors; + + ColorspaceType + colorspace; + + ImageType + type; + + PreviewType + preview_type; + + ssize_t + group; + + //MagickBooleanType + int + ping, + verbose; + + char* + view, + authenticate; + + ChannelType + channel; + + Image* + attributes; + + void* + options; + + MagickProgressMonitor + progress_monitor; + + void* + client_data, + cache; + + StreamHandler + stream; + + FILE* + file; + + void* + blob; + + size_t + length; + + char[MaxTextExtent] + magick, + unique, + zero, + filename; + + //MagickBooleanType + int + ddebug; + + char* + tile; + + size_t + subimage, + subrange; + + PixelPacket + pen; + + size_t + signature; + + VirtualPixelMethod + virtual_pixel_method; + + PixelPacket + transparent_color; + + void* + profile; + + //MagickBooleanType + int + synchronize; + } + + ExceptionType CatchImageException(Image*); + + FILE* GetImageInfoFile(const ImageInfo*); + + Image* AcquireImage(const ImageInfo*); + Image* AppendImages(const Image*, const MagickBooleanType, ExceptionInfo*); + Image* CloneImage(const Image*, const size_t, const size_t, const MagickBooleanType, ExceptionInfo*); + Image* CombineImages(const Image*, const ChannelType, ExceptionInfo*); + Image* DestroyImage(Image*); + Image* GetImageClipMask(const Image*, ExceptionInfo*); + Image* GetImageMask(const Image*, ExceptionInfo*); + Image* NewMagickImage(const ImageInfo*, const size_t, const size_t, const MagickPixelPacket*); + Image* ReferenceImage(Image*); + Image* SeparateImages(const Image*, const ChannelType, ExceptionInfo*); + + ImageInfo* AcquireImageInfo(); + ImageInfo* CloneImageInfo(const ImageInfo*); + ImageInfo* DestroyImageInfo(ImageInfo*); + + MagickBooleanType ClipImage(Image*); + MagickBooleanType ClipImagePath(Image*, const char*, const MagickBooleanType); + MagickBooleanType GetImageAlphaChannel(const Image*); + MagickBooleanType IsTaintImage(const Image*); + MagickBooleanType IsMagickConflict(const char*); + MagickBooleanType IsHighDynamicRangeImage(const Image*, ExceptionInfo*); + MagickBooleanType IsImageObject(const Image*); + MagickBooleanType ListMagickInfo(FILE*, ExceptionInfo*); + MagickBooleanType ModifyImage(Image**, ExceptionInfo*); + MagickBooleanType ResetImagePage(Image*, const char*); + MagickBooleanType SeparateImageChannel(Image*, const ChannelType); + MagickBooleanType SetImageAlphaChannel(Image*, const AlphaChannelType); + MagickBooleanType SetImageBackgroundColor(Image*); + MagickBooleanType SetImageClipMask(Image*, const Image*); + MagickBooleanType SetImageColor(Image*, const MagickPixelPacket*); + MagickBooleanType SetImageExtent(Image*, const size_t, const size_t); + MagickBooleanType SetImageInfo(ImageInfo*, const uint, ExceptionInfo*); + MagickBooleanType SetImageMask(Image*, const Image*); + MagickBooleanType SetImageOpacity(Image*, const Quantum); + MagickBooleanType SetImageStorageClass(Image*, const ClassType); + MagickBooleanType SetImageType(Image*, const ImageType); + MagickBooleanType StripImage(Image*); + MagickBooleanType SyncImage(Image*); + MagickBooleanType SyncImageSettings(const ImageInfo*, Image*); + MagickBooleanType SyncImagesSettings(ImageInfo*, Image*); + + size_t InterpretImageFilename(const ImageInfo*, Image*, const char*, int, char*); + + ssize_t GetImageReferenceCount(Image*); + + VirtualPixelMethod GetImageVirtualPixelMethod(const Image*); + VirtualPixelMethod SetImageVirtualPixelMethod(const Image*, const VirtualPixelMethod); + + void AcquireNextImage(const ImageInfo*, Image*); + void DestroyImagePixels(Image*); + void DisassociateImageStream(Image*); + void GetImageException(Image*, ExceptionInfo*); + void GetImageInfo(ImageInfo*); + void SetImageInfoBlob(ImageInfo*, const void*, const size_t); + void SetImageInfoFile(ImageInfo*, FILE*); +} diff --git a/dmagick/c/imageView.d b/dmagick/c/imageView.d new file mode 100644 index 0000000..cd3ddb5 --- /dev/null +++ b/dmagick/c/imageView.d @@ -0,0 +1,48 @@ +module dmagick.c.imageView; + +import core.sys.posix.sys.types; + +import dmagick.c.exception; +import dmagick.c.geometry; +import dmagick.c.image; +import dmagick.c.magickType; +import dmagick.c.pixel; + +extern(C) +{ + struct ImageView {} + + alias MagickBooleanType function(const ImageView*, const ImageView*, ImageView*, const ssize_t, const int, void*) DuplexTransferImageViewMethod; + alias MagickBooleanType function(const ImageView*, const ssize_t, const int, void*) GetImageViewMethod; + alias MagickBooleanType function(ImageView*, const ssize_t, const int, void*) SetImageViewMethod; + alias MagickBooleanType function(const ImageView*, ImageView*, const ssize_t, const int, void*) TransferImageViewMethod; + alias MagickBooleanType function(ImageView*, const ssize_t, const int, void*) UpdateImageViewMethod; + + char* GetImageViewException(const ImageView*, ExceptionType*); + + const(IndexPacket*) GetImageViewVirtualIndexes(const ImageView*); + + const(PixelPacket*) GetImageViewVirtualPixels(const ImageView*); + + Image* GetImageViewImage(const ImageView*); + + ImageView* CloneImageView(const ImageView*); + ImageView* DestroyImageView(ImageView*); + ImageView* NewImageView(Image*); + ImageView* NewImageViewRegion(Image*, const ssize_t, const ssize_t, const size_t, const size_t); + + IndexPacket* GetImageViewAuthenticIndexes(const ImageView*); + + MagickBooleanType DuplexTransferImageViewIterator(ImageView*, ImageView*, ImageView*, DuplexTransferImageViewMethod, void*); + MagickBooleanType GetImageViewIterator(ImageView*, GetImageViewMethod, void*); + MagickBooleanType IsImageView(const ImageView*); + MagickBooleanType SetImageViewIterator(ImageView*, SetImageViewMethod, void*); + MagickBooleanType TransferImageViewIterator(ImageView*, ImageView*, TransferImageViewMethod, void*); + MagickBooleanType UpdateImageViewIterator(ImageView*, UpdateImageViewMethod, void*); + + PixelPacket* GetImageViewAuthenticPixels(const ImageView*); + + RectangleInfo GetImageViewExtent(const ImageView*); + + void SetImageViewDescription(ImageView*, const char*); +} diff --git a/dmagick/c/layer.d b/dmagick/c/layer.d new file mode 100644 index 0000000..b71490e --- /dev/null +++ b/dmagick/c/layer.d @@ -0,0 +1,53 @@ +module dmagick.c.layer; + +import core.sys.posix.sys.types; + +import dmagick.c.composite; +import dmagick.c.exception; +import dmagick.c.image; + +extern(C) +{ + enum DisposeType + { + UnrecognizedDispose, + UndefinedDispose = 0, + NoneDispose = 1, + BackgroundDispose = 2, + PreviousDispose = 3 + } + + enum ImageLayerMethod + { + UndefinedLayer, + CoalesceLayer, + CompareAnyLayer, + CompareClearLayer, + CompareOverlayLayer, + DisposeLayer, + OptimizeLayer, + OptimizeImageLayer, + OptimizePlusLayer, + OptimizeTransLayer, + RemoveDupsLayer, + RemoveZeroLayer, + CompositeLayer, + MergeLayer, + FlattenLayer, + MosaicLayer, + TrimBoundsLayer + } + + Image* CoalesceImages(const Image*, ExceptionInfo*); + Image* DisposeImages(const Image*, ExceptionInfo*); + Image* CompareImageLayers(const Image*, const ImageLayerMethod, ExceptionInfo*); + Image* DeconstructImages(const Image*, ExceptionInfo*); + Image* MergeImageLayers(Image*, const ImageLayerMethod, ExceptionInfo*); + Image* OptimizeImageLayers(const Image*, ExceptionInfo*); + Image* OptimizePlusImageLayers(const Image*, ExceptionInfo*); + + void CompositeLayers(Image*, const CompositeOperator, Image*, const ssize_t, const ssize_t, ExceptionInfo*); + void OptimizeImageTransparency(const Image*, ExceptionInfo*); + void RemoveDuplicateLayers(Image**, ExceptionInfo*); + void RemoveZeroDelayLayers(Image**, ExceptionInfo*); +} diff --git a/dmagick/c/list.d b/dmagick/c/list.d new file mode 100644 index 0000000..9b91807 --- /dev/null +++ b/dmagick/c/list.d @@ -0,0 +1,39 @@ +module dmagick.c.list; + +import core.sys.posix.sys.types; + +import dmagick.c.exception; +import dmagick.c.image; + +extern(C) +{ + Image* CloneImageList(const Image*, ExceptionInfo*); + Image* CloneImages(const Image*, const char*, ExceptionInfo*); + Image* DestroyImageList(Image*); + Image* GetFirstImageInList(const Image*); + Image* GetImageFromList(const Image*, const ssize_t); + Image* GetLastImageInList(const Image*); + Image* GetNextImageInList(const Image*); + Image* GetPreviousImageInList(const Image*); + Image** ImageListToArray(const Image*, ExceptionInfo*); + Image* NewImageList(); + Image* RemoveImageFromList(Image**); + Image* RemoveLastImageFromList(Image**); + Image* RemoveFirstImageFromList(Image**); + Image* SpliceImageIntoList(Image**, const size_t, const Image*); + Image* SplitImageList(Image*); + Image* SyncNextImageInList(const Image*); + + size_t GetImageListLength(const Image*); + + ssize_t GetImageIndexInList(const Image*); + + void AppendImageToList(Image**, const Image*); + void DeleteImageFromList(Image**); + void DeleteImages(Image**, const char*, ExceptionInfo*); + void InsertImageInList(Image**, Image*); + void PrependImageToList(Image**, Image*); + void ReplaceImageInList(Image**, Image*); + void ReverseImageList(Image**); + void SyncImageList(Image*); +} diff --git a/dmagick/c/locale.d b/dmagick/c/locale.d new file mode 100644 index 0000000..73f1a11 --- /dev/null +++ b/dmagick/c/locale.d @@ -0,0 +1,43 @@ +module dmagick.c.locale; + +import core.stdc.stdio; + +import dmagick.c.exception; +import dmagick.c.hashmap; +import dmagick.c.magickType; + +extern(C) +{ + struct LocaleInfo + { + char* + path, + tag, + message; + + MagickBooleanType + stealth; + + LocaleInfo* + previous, + next; + + size_t + signature; + } + + char** GetLocaleList(const char*, size_t*, ExceptionInfo*); + + const(char*) GetLocaleMessage(const char*); + + const(LocaleInfo*) GetLocaleInfo_(const char*, ExceptionInfo*); + const(LocaleInfo**) GetLocaleInfoList(const char*, size_t*, ExceptionInfo*); + + LinkedListInfo* DestroyLocaleOptions(LinkedListInfo*); + LinkedListInfo* GetLocaleOptions(const char*, ExceptionInfo*); + + MagickBooleanType ListLocaleInfo(FILE*, ExceptionInfo*); + MagickBooleanType LocaleComponentGenesis(); + + void LocaleComponentTerminus(); +} diff --git a/dmagick/c/log.d b/dmagick/c/log.d new file mode 100644 index 0000000..d7db729 --- /dev/null +++ b/dmagick/c/log.d @@ -0,0 +1,56 @@ +module dmagick.c.log; + +import core.stdc.stdio; +import core.vararg; + +import dmagick.c.exception; +import dmagick.c.magickType; + +extern(C) +{ + enum LogEventType + { + 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, + AllEvents = 0x7fffffff + } + + struct LogInfo {} + + char** GetLogList(const char*, size_t*, ExceptionInfo*); + + const(char*) GetLogName(); + const(char*) SetLogName(const char*); + + const(LogInfo**) GetLogInfoList(const char*, size_t*, ExceptionInfo*); + + LogEventType SetLogEventMask(const char*); + + MagickBooleanType IsEventLogging(); + MagickBooleanType ListLogInfo(FILE*, ExceptionInfo*); + MagickBooleanType LogComponentGenesis(); + MagickBooleanType LogMagickEvent(const LogEventType, const char*, const char*, const size_t, const char*, ...); + MagickBooleanType LogMagickEventList(const LogEventType, const char*, const char*, const size_t, const char*, va_list); + + void CloseMagickLog(); + void LogComponentTerminus(); + void SetLogFormat(const char*); +} diff --git a/dmagick/c/magic.d b/dmagick/c/magic.d new file mode 100644 index 0000000..1157633 --- /dev/null +++ b/dmagick/c/magic.d @@ -0,0 +1,50 @@ +module dmagick.c.magic; + +import core.stdc.stdio; +import core.vararg; + +import dmagick.c.exception; +import dmagick.c.magickType; + +extern(C) +{ + struct MagicInfo + { + char* + path, + name, + target; + + ubyte* + magic; + + size_t + length; + + MagickOffsetType + offset; + + MagickBooleanType + exempt, + stealth; + + MagicInfo* + previous, + next; + + size_t + signature; + } + + char** GetMagicList(const char*, size_t*, ExceptionInfo*); + + const(char*) GetMagicName(const MagicInfo*); + + MagickBooleanType ListMagicInfo(FILE*, ExceptionInfo*); + MagickBooleanType MagicComponentGenesis(); + + const(MagicInfo*) GetMagicInfo(const ubyte*, const size_t, ExceptionInfo*); + const(MagicInfo**) GetMagicInfoList(const char*, size_t*, ExceptionInfo*); + + void MagicComponentTerminus(); +} diff --git a/dmagick/c/magick.d b/dmagick/c/magick.d new file mode 100644 index 0000000..d343cd2 --- /dev/null +++ b/dmagick/c/magick.d @@ -0,0 +1,107 @@ +module dmagick.c.magick; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + enum MagickFormatType + { + UndefinedFormatType, + ImplicitFormatType, + ExplicitFormatType + } + + enum MagickThreadSupport + { + NoThreadSupport = 0x0000, + DecoderThreadSupport = 0x0001, + EncoderThreadSupport = 0x0002 + } + + alias Image* function(const ImageInfo*, ExceptionInfo*) DecodeImageHandler; + alias MagickBooleanType function(const ImageInfo*, Image*) EncodeImageHandler; + alias MagickBooleanType function(const ubyte*, const size_t) IsImageFormatHandler; + + struct MagickInfo + { + char* + name, + description, + vversion, + note, + mmodule; + + 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; + + MagickInfo* + previous, + next; + + size_t + signature; + } + + char** GetMagickList(const char*, size_t*, ExceptionInfo*); + + const(char*) GetMagickDescription(const MagickInfo*); + + DecodeImageHandler* GetImageDecoder(const MagickInfo*); + + EncodeImageHandler* GetImageEncoder(const MagickInfo*); + + int GetMagickPrecision(); + int SetMagickPrecision(const int); + + MagickBooleanType GetImageMagick(const ubyte*, const size_t, char*); + MagickBooleanType GetMagickAdjoin(const MagickInfo*); + MagickBooleanType GetMagickBlobSupport(const MagickInfo*); + MagickBooleanType GetMagickEndianSupport(const MagickInfo*); + MagickBooleanType GetMagickRawSupport(const MagickInfo*); + MagickBooleanType GetMagickSeekableStream(const MagickInfo*); + MagickBooleanType IsMagickInstantiated(); + MagickBooleanType MagickComponentGenesis(); + MagickBooleanType UnregisterMagickInfo(const char*); + + const(MagickInfo*) GetMagickInfo(const char*, ExceptionInfo*); + const(MagickInfo**) GetMagickInfoList(const char*, size_t*, ExceptionInfo*); + + MagickInfo* RegisterMagickInfo(MagickInfo*); + MagickInfo* SetMagickInfo(const char*); + + MagickStatusType GetMagickThreadSupport(const MagickInfo*); + + void MagickComponentTerminus(); + void MagickCoreGenesis(const char*, const MagickBooleanType); + void MagickCoreTerminus(); +} diff --git a/dmagick/c/magickDelegate.d b/dmagick/c/magickDelegate.d new file mode 100644 index 0000000..e458c33 --- /dev/null +++ b/dmagick/c/magickDelegate.d @@ -0,0 +1,52 @@ +module dmagick.c.magickDelegate; + +import core.stdc.stdio; +import core.sys.posix.sys.types; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + struct DelegateInfo + { + char* + path, + decode, + encode, + commands; + + ssize_t + mode; + + MagickBooleanType + thread_support, + spawn, + stealth; + + DelegateInfo* + previous, + next; + + size_t + signature; + } + + char* GetDelegateCommand(const ImageInfo*, Image*, const char*, const char*, ExceptionInfo*); + char** GetDelegateList(const char *,size_t *,ExceptionInfo *); + + const(char*) GetDelegateCommands(const DelegateInfo*); + + const(DelegateInfo*) GetDelegateInfo(const char*, const char*, ExceptionInfo* exception); + const(DelegateInfo**) GetDelegateInfoList(const char*, size_t*, ExceptionInfo*); + + ssize_t GetDelegateMode(const DelegateInfo*); + + MagickBooleanType DelegateComponentGenesis(); + MagickBooleanType GetDelegateThreadSupport(const DelegateInfo*); + MagickBooleanType InvokeDelegate(ImageInfo*, Image*, const char*, const char*, ExceptionInfo*); + MagickBooleanType ListDelegateInfo(FILE*, ExceptionInfo*); + + void DelegateComponentTerminus(); +} diff --git a/dmagick/c/magickModule.d b/dmagick/c/magickModule.d new file mode 100644 index 0000000..6776fde --- /dev/null +++ b/dmagick/c/magickModule.d @@ -0,0 +1,66 @@ +module dmagick.c.magickModule; + +import core.stdc.stdio; +import core.stdc.time; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + enum MagickModuleType + { + MagickImageCoderModule, + MagickImageFilterModule + } + + struct ModuleInfo + { + char* + path, + tag; + + void* + handle; + + void + function() unregister_module; + + size_t + function() register_module; + + time_t + timestamp; + + MagickBooleanType + stealth; + + ModuleInfo* + previous, + next; + + size_t + signature; + } + + size_t ImageFilterHandler(Image**, const int, const char**, ExceptionInfo*); + + char** GetModuleList(const char*, const MagickModuleType, size_t*, ExceptionInfo*); + + const(ModuleInfo**) GetModuleInfoList(const char*, size_t*, ExceptionInfo*); + + MagickBooleanType InitializeModuleList(ExceptionInfo*); + MagickBooleanType InvokeDynamicImageFilter(const char*, Image**, const int, const char**, ExceptionInfo*); + MagickBooleanType ListModuleInfo(FILE*, ExceptionInfo*); + MagickBooleanType ModuleComponentGenesis(); + MagickBooleanType OpenModule(const char*, ExceptionInfo*); + MagickBooleanType OpenModules(ExceptionInfo*); + + ModuleInfo* GetModuleInfo(const char*, ExceptionInfo*); + + void DestroyModuleList(); + void ModuleComponentTerminus(); + void RegisterStaticModules(); + void UnregisterStaticModules(); +} diff --git a/dmagick/c/magickString.d b/dmagick/c/magickString.d new file mode 100644 index 0000000..8606069 --- /dev/null +++ b/dmagick/c/magickString.d @@ -0,0 +1,78 @@ +module dmagick.c.magickString; + +import core.stdc.stdio; +import core.stdc.time; +import core.sys.posix.sys.types; +import core.vararg; + +import dmagick.c.exception; +import dmagick.c.magickType; + +extern(C) +{ + struct StringInfo + { + char[MaxTextExtent] + path; + + ubyte* + datum; + + size_t + length, + signature; + } + + char* AcquireString(const char*); + char* CloneString(char**, const char*); + char* ConstantString(const char*); + char* DestroyString(char*); + char** DestroyStringList(char**); + char* EscapeString(const char*, const char); + char* FileToString(const char*, const size_t, ExceptionInfo*); + char* GetEnvironmentValue(const char*); + char* StringInfoToHexString(const StringInfo*); + char* StringInfoToString(const StringInfo*); + char** StringToArgv(const char*, int*); + char* StringToken(const char*, char**); + char** StringToList(const char*); + + const(char*) GetStringInfoPath(const StringInfo*); + + int CompareStringInfo(const StringInfo*, const StringInfo*); + int LocaleCompare(const char*, const char*); + int LocaleNCompare(const char*, const char*, const size_t); + + MagickBooleanType ConcatenateString(char**, const char*); + MagickBooleanType SubstituteString(char**, const char*, const char*); + + size_t ConcatenateMagickString(char*, const char*, const size_t); + size_t CopyMagickString(char*, const char*, const size_t); + size_t GetStringInfoLength(const StringInfo*); + + ssize_t FormatMagickSize(const MagickSizeType, const MagickBooleanType, char*); + ssize_t FormatMagickString(char*, const size_t, const char*, ...); + ssize_t FormatMagickStringList(char*, const size_t, const char*, va_list); + ssize_t FormatMagickTime(const time_t, const size_t, char*); + + StringInfo* AcquireStringInfo(const size_t); + StringInfo* CloneStringInfo(const StringInfo*); + StringInfo* ConfigureFileToStringInfo(const char*); + StringInfo* DestroyStringInfo(StringInfo*); + StringInfo* FileToStringInfo(const char*, const size_t, ExceptionInfo*); + StringInfo* SplitStringInfo(StringInfo*, const size_t); + StringInfo* StringToStringInfo(const char*); + + ubyte* GetStringInfoDatum(const StringInfo*); + + void ConcatenateStringInfo(StringInfo*, const StringInfo*); + void LocaleLower(char*); + void LocaleUpper(char*); + void PrintStringInfo(FILE *file, const char*, const StringInfo*); + void ResetStringInfo(StringInfo*); + void SetStringInfo(StringInfo*, const StringInfo*); + void SetStringInfoDatum(StringInfo*, const ubyte*); + void SetStringInfoLength(StringInfo*, const size_t); + void SetStringInfoPath(StringInfo*, const char*); + void StripString(char*); +} diff --git a/dmagick/c/magickType.d b/dmagick/c/magickType.d new file mode 100644 index 0000000..498fb61 --- /dev/null +++ b/dmagick/c/magickType.d @@ -0,0 +1,59 @@ +module dmagick.c.magickType; + +extern (C) +{ + alias double MagickRealType; + alias ushort Quantum; + alias uint MagickStatusType; + alias long MagickOffsetType; + alias ulong MagickSizeType; + + alias MagickSizeType QuantumAny; + + enum MaxTextExtent = 4096; + enum QuantumRange = 65535UL; + + enum ChannelType + { + 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, + AllChannels = 0x002F, + + 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 = 0x0127 //( (AllChannels | SyncChannels) &~ OpacityChannel) + } + + enum ClassType + { + UndefinedClass, + DirectClass, + PseudoClass + } + + alias int MagickBooleanType; + + //typedef enum + //{ + // MagickFalse = 0, + // MagickTrue = 1 + //} MagickBooleanType; + + struct BlobInfo {} + + //alias _Image Image; + //alias _ImageInfo ImageInfo; +} diff --git a/dmagick/c/magickVersion.d b/dmagick/c/magickVersion.d new file mode 100644 index 0000000..eaed81c --- /dev/null +++ b/dmagick/c/magickVersion.d @@ -0,0 +1,14 @@ +module dmagick.c.magickVersion; + +extern(C) +{ + char* GetMagickHomeURL(); + + const(char*) GetMagickCopyright(); + const(char*) GetMagickFeatures(); + const(char*) GetMagickPackageName(); + const(char*) GetMagickQuantumDepth(size_t*); + const(char*) GetMagickQuantumRange(size_t*); + const(char*) GetMagickReleaseDate(); + const(char*) GetMagickVersion(size_t*); +} diff --git a/dmagick/c/matrix.d b/dmagick/c/matrix.d new file mode 100644 index 0000000..ecbd998 --- /dev/null +++ b/dmagick/c/matrix.d @@ -0,0 +1,13 @@ +module dmagick.c.matrix; + +import dmagick.c.magickType; + +extern(C) +{ + double** AcquireMagickMatrix(const size_t, const size_t); + double** RelinquishMagickMatrix(double**, const size_t); + + MagickBooleanType GaussJordanElimination(double**, double**, const size_t, const size_t); + + void LeastSquaresAddTerms(double**, double**, const double*, const double*, const size_t, const size_t); +} diff --git a/dmagick/c/memory.d b/dmagick/c/memory.d new file mode 100644 index 0000000..8c10eeb --- /dev/null +++ b/dmagick/c/memory.d @@ -0,0 +1,21 @@ +module dmagick.c.memory; + +extern(C) +{ + alias void* function(size_t) AcquireMemoryHandler; + alias void function(void*) DestroyMemoryHandler; + alias void* function(void*, size_t) ResizeMemoryHandler; + + void* AcquireAlignedMemory(const size_t, const size_t); + void* AcquireMagickMemory(const size_t); + void* AcquireQuantumMemory(const size_t, const size_t); + void* CopyMagickMemory(void*, const void*, const size_t); + void DestroyMagickMemory(); + void GetMagickMemoryMethods(AcquireMemoryHandler*, ResizeMemoryHandler*, DestroyMemoryHandler*); + void* RelinquishAlignedMemory(void*); + void* RelinquishMagickMemory(void*); + void* ResetMagickMemory(void*, int, const size_t); + void* ResizeMagickMemory(void*, const size_t); + void* ResizeQuantumMemory(void*, const size_t, const size_t); + void SetMagickMemoryMethods(AcquireMemoryHandler, ResizeMemoryHandler, DestroyMemoryHandler); +} diff --git a/dmagick/c/mime.d b/dmagick/c/mime.d new file mode 100644 index 0000000..8e2b337 --- /dev/null +++ b/dmagick/c/mime.d @@ -0,0 +1,26 @@ +module dmagick.c.mime; + +import core.stdc.stdio; + +import dmagick.c.exception; +import dmagick.c.magickType; + +extern(C) +{ + struct MimeInfo {} + + char** GetMimeList(const char*, size_t*, ExceptionInfo*); + char* MagickToMime(const char*); + + const(char*) GetMimeDescription(const MimeInfo*); + const(char*) GetMimeType(const MimeInfo*); + + MagickBooleanType ListMimeInfo(FILE*, ExceptionInfo*); + MagickBooleanType LoadMimeLists(const char*, ExceptionInfo*); + MagickBooleanType MimeComponentGenesis(); + + const(MimeInfo*) GetMimeInfo(const char*, const ubyte*, const size_t, ExceptionInfo*); + const(MimeInfo**) GetMimeInfoList(const char*, size_t*, ExceptionInfo*); + + void MimeComponentTerminus(); +} diff --git a/dmagick/c/monitor.d b/dmagick/c/monitor.d new file mode 100644 index 0000000..6d0651e --- /dev/null +++ b/dmagick/c/monitor.d @@ -0,0 +1,23 @@ +module dmagick.c.monitor; + +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + alias MagickBooleanType function(const char*, const MagickOffsetType, const MagickSizeType, void*) MagickProgressMonitor; + + MagickProgressMonitor SetImageProgressMonitor(Image*, const MagickProgressMonitor, void*); + MagickProgressMonitor SetImageInfoProgressMonitor(ImageInfo*, const MagickProgressMonitor, void*); +} + +static pure nothrow MagickBooleanType QuantumTick(const MagickOffsetType offset, const MagickSizeType span) +{ + if (span <= 100) + return(true); + if (offset == cast(MagickOffsetType) (span-1)) + return(true); + if ((offset % (span/100)) == 0) + return(true); + return(false); +} diff --git a/dmagick/c/montage.d b/dmagick/c/montage.d new file mode 100644 index 0000000..0603e79 --- /dev/null +++ b/dmagick/c/montage.d @@ -0,0 +1,65 @@ +module dmagick.c.montage; + +import dmagick.c.exception; +import dmagick.c.geometry; +import dmagick.c.image; +import dmagick.c.magickType; +import dmagick.c.pixel; + +extern(C) +{ + enum MontageMode + { + UndefinedMode, + FrameMode, + UnframeMode, + ConcatenateMode + } + + 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[MaxTextExtent] + filename; + + MagickBooleanType + ddebug; + + size_t + signature; + } + + Image* MontageImages(const Image*, const MontageInfo*, ExceptionInfo*); + Image* MontageImageList(const ImageInfo*, const MontageInfo*, const Image*, ExceptionInfo*); + + MontageInfo* CloneMontageInfo(const ImageInfo*, const MontageInfo*); + MontageInfo* DestroyMontageInfo(MontageInfo*); + + void GetMontageInfo(const ImageInfo*, MontageInfo*); +} diff --git a/dmagick/c/morphology.d b/dmagick/c/morphology.d new file mode 100644 index 0000000..baae868 --- /dev/null +++ b/dmagick/c/morphology.d @@ -0,0 +1,120 @@ +module dmagick.c.morphology; + +import core.sys.posix.sys.types; + +import dmagick.c.exception; +import dmagick.c.geometry; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + enum KernelInfoType + { + UndefinedKernel, + UnityKernel, + GaussianKernel, + DoGKernel, + LoGKernel, + BlurKernel, + CometKernel, + LaplacianKernel, + SobelKernel, + FreiChenKernel, + RobertsKernel, + PrewittKernel, + CompassKernel, + KirschKernel, + DiamondKernel, + SquareKernel, + RectangleKernel, + DiskKernel, + PlusKernel, + CrossKernel, + RingKernel, + PeaksKernel, + EdgesKernel, + CornersKernel, + ThinDiagonalsKernel, + LineEndsKernel, + LineJunctionsKernel, + RidgesKernel, + ConvexHullKernel, + SkeletonKernel, + ChebyshevKernel, + ManhattanKernel, + EuclideanKernel, + UserDefinedKernel + } + + enum MorphologyMethod + { + UndefinedMorphology, + + ConvolveMorphology, + CorrelateMorphology, + + ErodeMorphology, + DilateMorphology, + ErodeIntensityMorphology, + DilateIntensityMorphology, + DistanceMorphology, + + OpenMorphology, + CloseMorphology, + OpenIntensityMorphology, + CloseIntensityMorphology, + SmoothMorphology, + + EdgeInMorphology, + EdgeOutMorphology, + EdgeMorphology, + TopHatMorphology, + BottomHatMorphology, + + HitAndMissMorphology, + ThinningMorphology, + ThickenMorphology + } + + struct KernelInfo + { + KernelInfoType + type; + + size_t + width, + height; + + ssize_t + x, + y; + + double* values; + + double + minimum, + maximum, + negative_range, + positive_range, + angle; + + KernelInfo* + next; + + size_t + signature; + } + + + KernelInfo* AcquireKernelInfo(const char*); + KernelInfo* AcquireKernelBuiltIn(const KernelInfoType, const GeometryInfo*); + KernelInfo* CloneKernelInfo(const KernelInfo*); + KernelInfo* DestroyKernelInfo(KernelInfo*); + + Image* MorphologyImage(const Image*, const MorphologyMethod, const ssize_t, const KernelInfo*, ExceptionInfo*); + Image* MorphologyImageChannel(const Image*, const ChannelType, const MorphologyMethod, const ssize_t, const KernelInfo*, ExceptionInfo*); + + void ScaleGeometryKernelInfo(KernelInfo*, const char*); + void ShowKernelInfo(KernelInfo*); +} diff --git a/dmagick/c/option.d b/dmagick/c/option.d new file mode 100644 index 0000000..a766a87 --- /dev/null +++ b/dmagick/c/option.d @@ -0,0 +1,132 @@ +module dmagick.c.option; + +import core.stdc.stdio; +import core.sys.posix.sys.types; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + enum MagickOption + { + MagickUndefinedOptions = -1, + MagickAlignOptions = 0, + MagickAlphaOptions, + MagickBooleanOptions, + 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, + MagickImageListOptions, + MagickIntentOptions, + MagickInterlaceOptions, + MagickInterpolateOptions, + MagickKernelOptions, + MagickLayerOptions, + MagickLineCapOptions, + MagickLineJoinOptions, + MagickListOptions, + MagickLocaleOptions, + MagickLogEventOptions, + MagickLogOptions, + MagickMagicOptions, + MagickMethodOptions, + MagickMetricOptions, + MagickMimeOptions, + MagickModeOptions, + MagickModuleOptions, + MagickMorphologyOptions, + MagickNoiseOptions, + MagickOrientationOptions, + MagickPolicyOptions, + MagickPolicyDomainOptions, + MagickPolicyRightsOptions, + MagickPreviewOptions, + MagickPrimitiveOptions, + MagickQuantumFormatOptions, + MagickResolutionOptions, + MagickResourceOptions, + MagickSparseColorOptions, + MagickStorageOptions, + MagickStretchOptions, + MagickStyleOptions, + MagickThresholdOptions, + MagickTypeOptions, + MagickValidateOptions, + MagickVirtualPixelOptions + } + + enum ValidateType + { + UndefinedValidate, + NoValidate = 0x00000, + CompareValidate = 0x00001, + CompositeValidate = 0x00002, + ConvertValidate = 0x00004, + FormatsInMemoryValidate = 0x00008, + FormatsOnDiskValidate = 0x00010, + IdentifyValidate = 0x00020, + ImportExportValidate = 0x00040, + MontageValidate = 0x00080, + StreamValidate = 0x00100, + AllValidate = 0x7fffffff + } + + struct OptionInfo + { + const(char*) + mnemonic; + + ssize_t + type; + + MagickBooleanType + stealth; + } + + char** GetMagickOptions(const MagickOption); + char* GetNextImageOption(const ImageInfo*); + char* RemoveImageOption(ImageInfo*, const char*); + + const(char*) GetImageOption(const ImageInfo*, const char*); + const(char*) MagickOptionToMnemonic(const MagickOption, const ssize_t); + + MagickBooleanType CloneImageOptions(ImageInfo*, const ImageInfo*); + MagickBooleanType DefineImageOption(ImageInfo*, const char*); + MagickBooleanType DeleteImageOption(ImageInfo*, const char*); + MagickBooleanType IsMagickOption(const char*); + MagickBooleanType ListMagickOptions(FILE*, const MagickOption, ExceptionInfo*); + MagickBooleanType SetImageOption(ImageInfo*, const char*, const char*); + + ssize_t ParseChannelOption(const char*); + ssize_t ParseMagickOption(const MagickOption, const MagickBooleanType,const char*); + + void DestroyImageOptions(ImageInfo*); + void ResetImageOptions(const ImageInfo*); + void ResetImageOptionIterator(const ImageInfo*); +} diff --git a/dmagick/c/paint.d b/dmagick/c/paint.d new file mode 100644 index 0000000..2b366f5 --- /dev/null +++ b/dmagick/c/paint.d @@ -0,0 +1,21 @@ +module dmagick.c.paint; + +import core.sys.posix.sys.types; + +import dmagick.c.draw; +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; +import dmagick.c.pixel; + +extern(C) +{ + Image* OilPaintImage(const Image*, const double, ExceptionInfo*); + + MagickBooleanType FloodfillPaintImage(Image*, const ChannelType, const DrawInfo*, const MagickPixelPacket*, const ssize_t, const ssize_t, const MagickBooleanType); + MagickBooleanType GradientImage(Image*, const GradientType, const SpreadMethod, const PixelPacket*, const PixelPacket*); + MagickBooleanType OpaquePaintImage(Image*, const MagickPixelPacket*, const MagickPixelPacket*, const MagickBooleanType); + MagickBooleanType OpaquePaintImageChannel(Image*, const ChannelType, const MagickPixelPacket*, const MagickPixelPacket*, const MagickBooleanType); + MagickBooleanType TransparentPaintImage(Image*, const MagickPixelPacket*, const Quantum, const MagickBooleanType); + MagickBooleanType TransparentPaintImageChroma(Image*, const MagickPixelPacket*, const MagickPixelPacket*, const Quantum, const MagickBooleanType); +} diff --git a/dmagick/c/pixel.d b/dmagick/c/pixel.d new file mode 100644 index 0000000..95f4cfb --- /dev/null +++ b/dmagick/c/pixel.d @@ -0,0 +1,74 @@ +module dmagick.c.pixel; + +import core.sys.posix.sys.types; + +import dmagick.c.magickType; +import dmagick.c.colorspace; +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.constitute; + +extern(C) +{ + struct DoublePixelPacket + { + double + red, + green, + blue, + opacity, + index; + } + + struct LongPixelPacket + { + uint + red, + green, + blue, + opacity, + index; + } + + struct MagickPixelPacket + { + ClassType + storage_class; + + ColorspaceType + colorspace; + + MagickBooleanType + matte; + + double + fuzz; + + size_t + depth; + + MagickRealType + red, + green, + blue, + opacity, + index; + } + + alias Quantum IndexPacket; + + struct PixelPacket + { + Quantum + blue, + green, + red, + opacity; + + } + + MagickBooleanType ExportImagePixels(const Image*, const ssize_t, const ssize_t, const size_t, const size_t, const char*, const StorageType, void*, ExceptionInfo*); + MagickBooleanType ImportImagePixels(Image*, const ssize_t, const ssize_t, const size_t, const size_t, const char*, const StorageType, const void*); + + void GetMagickPixelPacket(const Image*, MagickPixelPacket*); +} diff --git a/dmagick/c/policy.d b/dmagick/c/policy.d new file mode 100644 index 0000000..733e116 --- /dev/null +++ b/dmagick/c/policy.d @@ -0,0 +1,42 @@ +module dmagick.c.policy; + +import core.stdc.stdio; + +import dmagick.c.exception; +import dmagick.c.magickType; + +extern(C) +{ + enum PolicyDomain + { + UndefinedPolicyDomain, + CoderPolicyDomain, + DelegatePolicyDomain, + FilterPolicyDomain, + PathPolicyDomain, + ResourcePolicyDomain, + SystemPolicyDomain + } + + enum PolicyRights + { + UndefinedPolicyRights = 0x00, + NoPolicyRights = 0x00, + ReadPolicyRights = 0x01, + WritePolicyRights = 0x02, + ExecutePolicyRights = 0x04 + } + + struct PolicyInfo {} + + char* GetPolicyValue(const char* name); + char** GetPolicyList(const char*, size_t*, ExceptionInfo*); + + const(PolicyInfo**) GetPolicyInfoList(const char*, size_t*, ExceptionInfo*); + + MagickBooleanType IsRightsAuthorized(const PolicyDomain, const PolicyRights, const char*); + MagickBooleanType ListPolicyInfo(FILE*, ExceptionInfo*); + MagickBooleanType PolicyComponentGenesis(); + + void PolicyComponentTerminus(); +} diff --git a/dmagick/c/prepress.d b/dmagick/c/prepress.d new file mode 100644 index 0000000..2a53d7e --- /dev/null +++ b/dmagick/c/prepress.d @@ -0,0 +1,5 @@ +module dmagick.c.prepress; + +import dmagick.c.image; + +extern(C) double GetImageTotalInkDensity(Image* image); diff --git a/dmagick/c/profile.d b/dmagick/c/profile.d new file mode 100644 index 0000000..44dbbf6 --- /dev/null +++ b/dmagick/c/profile.d @@ -0,0 +1,47 @@ +module dmagick.c.profile; + +import dmagick.c.magickString; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + struct ProfileInfo + { + char* + name; + + size_t + length; + + ubyte* + info; + + size_t + signature; + } + + enum RenderingIntent + { + UndefinedIntent, + SaturationIntent, + PerceptualIntent, + AbsoluteIntent, + RelativeIntent + } + + char* GetNextImageProfile(const Image*); + + const(StringInfo) *GetImageProfile(const Image *,const char *); + + MagickBooleanType CloneImageProfiles(Image*, const Image*); + MagickBooleanType DeleteImageProfile(Image*, const char*); + MagickBooleanType ProfileImage(Image*, const char*, const void*, const size_t, const MagickBooleanType); + MagickBooleanType SetImageProfile(Image*, const char*, const StringInfo*); + MagickBooleanType SyncImageProfiles(Image*); + + StringInfo* RemoveImageProfile(Image*, const char*); + + void DestroyImageProfiles(Image*); + void ResetImageProfileIterator(const Image*); +} diff --git a/dmagick/c/property.d b/dmagick/c/property.d new file mode 100644 index 0000000..1fd6193 --- /dev/null +++ b/dmagick/c/property.d @@ -0,0 +1,26 @@ +module dmagick.c.property; + +import core.vararg; + +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + char* GetNextImageProperty(const Image*); + char* InterpretImageProperties(const ImageInfo*, Image*, const char*); + char* RemoveImageProperty(Image*, const char*); + + const(char*) GetImageProperty(const Image*, const char*); + const(char*) GetMagickProperty(const ImageInfo*, Image*, const char*); + + MagickBooleanType CloneImageProperties(Image*, const Image*); + MagickBooleanType DefineImageProperty(Image*, const char*); + MagickBooleanType DeleteImageProperty(Image*, const char*); + MagickBooleanType FormatImageProperty(Image*, const char*, const char*, ...); + MagickBooleanType FormatImagePropertyList(Image*, const char*, const char*, va_list); + MagickBooleanType SetImageProperty(Image*, const char*, const char*); + + void DestroyImageProperties(Image*); + void ResetImagePropertyIterator(const Image*); +} diff --git a/dmagick/c/quantize.d b/dmagick/c/quantize.d new file mode 100644 index 0000000..72584e2 --- /dev/null +++ b/dmagick/c/quantize.d @@ -0,0 +1,54 @@ +module dmagick.c.quantize; + +import dmagick.c.colorspace; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + enum DitherMethod + { + UndefinedDitherMethod, + NoDitherMethod, + RiemersmaDitherMethod, + FloydSteinbergDitherMethod + } + + struct QuantizeInfo + { + size_t + number_colors; + + size_t + tree_depth; + + MagickBooleanType + dither; + + ColorspaceType + colorspace; + + MagickBooleanType + measure_error; + + size_t + signature; + + DitherMethod + dither_method; + } + + MagickBooleanType CompressImageColormap(Image*); + MagickBooleanType GetImageQuantizeError(Image*); + MagickBooleanType PosterizeImage(Image*, const size_t, const MagickBooleanType); + MagickBooleanType QuantizeImage(const QuantizeInfo*, Image*); + MagickBooleanType QuantizeImages(const QuantizeInfo*, Image*); + MagickBooleanType RemapImage(const QuantizeInfo*, Image*, const Image*); + MagickBooleanType RemapImages(const QuantizeInfo*, Image*, const Image*); + + QuantizeInfo* AcquireQuantizeInfo(const ImageInfo*); + QuantizeInfo* CloneQuantizeInfo(const QuantizeInfo*); + QuantizeInfo* DestroyQuantizeInfo(QuantizeInfo*); + + void GetQuantizeInfo(QuantizeInfo*); +} diff --git a/dmagick/c/quantum.d b/dmagick/c/quantum.d new file mode 100644 index 0000000..5d534dd --- /dev/null +++ b/dmagick/c/quantum.d @@ -0,0 +1,103 @@ +module dmagick.c.quantum; + +import dmagick.c.cacheView; +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + enum EndianType + { + UndefinedEndian, + LSBEndian, + MSBEndian + } + + enum QuantumAlphaType + { + UndefinedQuantumAlpha, + AssociatedQuantumAlpha, + DisassociatedQuantumAlpha + } + + enum QuantumFormatType + { + UndefinedQuantumFormat, + FloatingPointQuantumFormat, + SignedQuantumFormat, + UnsignedQuantumFormat + } + + enum QuantumType + { + UndefinedQuantum, + AlphaQuantum, + BlackQuantum, + BlueQuantum, + CMYKAQuantum, + CMYKQuantum, + CyanQuantum, + GrayAlphaQuantum, + GrayQuantum, + GreenQuantum, + IndexAlphaQuantum, + IndexQuantum, + MagentaQuantum, + OpacityQuantum, + RedQuantum, + RGBAQuantum, + BGRAQuantum, + RGBOQuantum, + RGBQuantum, + YellowQuantum, + GrayPadQuantum, + RGBPadQuantum, + CbYCrYQuantum, + CbYCrQuantum, + CbYCrAQuantum, + CMYKOQuantum, + BGRQuantum, + BGROQuantum + } + + struct QuantumInfo {} + + alias ClampToQuantum RoundToQuantum; + static pure nothrow Quantum ClampToQuantum(const MagickRealType value) + { + if (value <= 0.0) + return(cast(Quantum) 0); + if (value >= cast(MagickRealType) 65535UL) + return(cast(Quantum) 65535UL); + return(cast(Quantum) (value+0.5)); + } + + static pure nothrow ubyte ScaleQuantumToChar(const Quantum quantum) + { + return(cast(ubyte) (((quantum+128UL)-((quantum+128UL) >> 8)) >> 8)); + } + + MagickBooleanType SetQuantumDepth(const Image*, QuantumInfo*, const size_t); + MagickBooleanType SetQuantumFormat(const Image*, QuantumInfo*, const QuantumFormatType); + MagickBooleanType SetQuantumPad(const Image*, QuantumInfo*, const size_t); + + QuantumInfo* AcquireQuantumInfo(const ImageInfo*, Image*); + QuantumInfo* DestroyQuantumInfo(QuantumInfo*); + + QuantumType GetQuantumType(Image*, ExceptionInfo*); + + size_t ExportQuantumPixels(const Image*, const CacheView*, const QuantumInfo*, const QuantumType, ubyte*, ExceptionInfo*); + size_t GetQuantumExtent(const Image*, const QuantumInfo*, const QuantumType); + size_t ImportQuantumPixels(Image*, CacheView*, const QuantumInfo*, const QuantumType, const ubyte*, ExceptionInfo*); + + ubyte* GetQuantumPixels(const QuantumInfo*); + + void GetQuantumInfo(const ImageInfo*, QuantumInfo*); + void SetQuantumAlphaType(QuantumInfo*, const QuantumAlphaType); + void SetQuantumImageType(Image*, const QuantumType); + void SetQuantumMinIsWhite(QuantumInfo*, const MagickBooleanType); + void SetQuantumPack(QuantumInfo*, const MagickBooleanType); + void SetQuantumQuantum(QuantumInfo*, const size_t); + void SetQuantumScale(QuantumInfo*, const double); +} diff --git a/dmagick/c/random.d b/dmagick/c/random.d new file mode 100644 index 0000000..4af5ffd --- /dev/null +++ b/dmagick/c/random.d @@ -0,0 +1,24 @@ +module dmagick.c.random; + +import dmagick.c.magickString; +import dmagick.c.magickType; + +extern(C) +{ + struct RandomInfo {} + + double GetRandomValue(RandomInfo*); + double GetPseudoRandomValue(RandomInfo*); + + MagickBooleanType RandomComponentGenesis(); + + RandomInfo* AcquireRandomInfo(); + RandomInfo* DestroyRandomInfo(RandomInfo*); + + StringInfo* GetRandomKey(RandomInfo*, const size_t); + + void RandomComponentTerminus(); + void SeedPseudoRandomGenerator(const size_t); + void SetRandomKey(RandomInfo*, const size_t, ubyte*); + void SetRandomTrueRandom(const MagickBooleanType); +} diff --git a/dmagick/c/registry.d b/dmagick/c/registry.d new file mode 100644 index 0000000..38ae2fe --- /dev/null +++ b/dmagick/c/registry.d @@ -0,0 +1,27 @@ +module dmagick.c.registry; + +import dmagick.c.exception; +import dmagick.c.magickType; + +extern(C) +{ + enum RegistryType + { + UndefinedRegistryType, + ImageRegistryType, + ImageInfoRegistryType, + StringRegistryType + } + + char* GetNextImageRegistry(); + + MagickBooleanType DefineImageRegistry(const RegistryType, const char*, ExceptionInfo*); + MagickBooleanType DeleteImageRegistry(const char*); + MagickBooleanType RegistryComponentGenesis(); + MagickBooleanType SetImageRegistry(const RegistryType, const char*, const void*, ExceptionInfo*); + + void* GetImageRegistry(const RegistryType, const char*, ExceptionInfo*); + void RegistryComponentTerminus(); + void* RemoveImageRegistry(const char*); + void ResetImageRegistryIterator(); +} diff --git a/dmagick/c/resample.d b/dmagick/c/resample.d new file mode 100644 index 0000000..77fc6b1 --- /dev/null +++ b/dmagick/c/resample.d @@ -0,0 +1,65 @@ +module dmagick.c.resample; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; +import dmagick.c.pixel; +import dmagick.c.cacheView; + +extern(C) +{ + enum FilterTypes + { + UndefinedFilter, + PointFilter, + BoxFilter, + TriangleFilter, + HermiteFilter, + HanningFilter, + HammingFilter, + BlackmanFilter, + GaussianFilter, + QuadraticFilter, + CubicFilter, + CatromFilter, + MitchellFilter, + LanczosFilter, + JincFilter, + SincFilter, + KaiserFilter, + WelshFilter, + ParzenFilter, + LagrangeFilter, + BohmanFilter, + BartlettFilter, + SincFastFilter, + Lanczos2DFilter, + RobidouxFilter, + SentinelFilter + } + + enum InterpolatePixelMethod + { + UndefinedInterpolatePixel, + AverageInterpolatePixel, + BicubicInterpolatePixel, + BilinearInterpolatePixel, + FilterInterpolatePixel, + IntegerInterpolatePixel, + MeshInterpolatePixel, + NearestNeighborInterpolatePixel, + SplineInterpolatePixel + } + + struct ResampleFilter {} + + MagickBooleanType ResamplePixelColor(ResampleFilter*, const double, const double, MagickPixelPacket*); + MagickBooleanType SetResampleFilterInterpolateMethod(ResampleFilter*, const InterpolatePixelMethod); + MagickBooleanType SetResampleFilterVirtualPixelMethod(ResampleFilter*, const VirtualPixelMethod); + + ResampleFilter* AcquireResampleFilter(const Image*, ExceptionInfo*); + ResampleFilter* DestroyResampleFilter(ResampleFilter*); + + void ScaleResampleFilter(ResampleFilter*, const double, const double, const double, const double); + void SetResampleFilter(ResampleFilter*, const FilterTypes, const double); +} diff --git a/dmagick/c/resize.d b/dmagick/c/resize.d new file mode 100644 index 0000000..7a4aaba --- /dev/null +++ b/dmagick/c/resize.d @@ -0,0 +1,18 @@ +module dmagick.c.resize; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.resample; + +extern(C) +{ + Image* AdaptiveResizeImage(const Image*, const size_t, const size_t, ExceptionInfo*); + Image* LiquidRescaleImage(const Image*, const size_t, const size_t, const double, const double, ExceptionInfo*); + Image* MagnifyImage(const Image*, ExceptionInfo*); + Image* MinifyImage(const Image*, ExceptionInfo*); + Image* ResampleImage(const Image*, const double, const double, const FilterTypes, const double, ExceptionInfo*); + Image* ResizeImage(const Image*, const size_t, const size_t, const FilterTypes, const double, ExceptionInfo*); + Image* SampleImage(const Image*, const size_t, const size_t, ExceptionInfo*); + Image* ScaleImage(const Image*, const size_t, const size_t, ExceptionInfo*); + Image* ThumbnailImage(const Image*, const size_t, const size_t, ExceptionInfo*); +} diff --git a/dmagick/c/resource.d b/dmagick/c/resource.d new file mode 100644 index 0000000..1e97a59 --- /dev/null +++ b/dmagick/c/resource.d @@ -0,0 +1,37 @@ +module dmagick.c.resource; + +import core.stdc.stdio; + +import dmagick.c.exception; +import dmagick.c.magickType; + +extern(C) +{ + enum ResourceType + { + UndefinedResource, + AreaResource, + DiskResource, + FileResource, + MapResource, + MemoryResource, + ThreadResource, + TimeResource, + ThrottleResource + } + + int AcquireUniqueFileResource(char*); + + MagickBooleanType AcquireMagickResource(const ResourceType, const MagickSizeType); + MagickBooleanType ListMagickResourceInfo(FILE*, ExceptionInfo*); + MagickBooleanType RelinquishUniqueFileResource(const char*); + MagickBooleanType ResourceComponentGenesis(); + MagickBooleanType SetMagickResourceLimit(const ResourceType, const MagickSizeType); + + MagickSizeType GetMagickResource(const ResourceType); + MagickSizeType GetMagickResourceLimit(const ResourceType); + + void AsynchronousResourceComponentTerminus(); + void RelinquishMagickResource(const ResourceType, const MagickSizeType); + void ResourceComponentTerminus(); +} diff --git a/dmagick/c/segment.d b/dmagick/c/segment.d new file mode 100644 index 0000000..3f04bfa --- /dev/null +++ b/dmagick/c/segment.d @@ -0,0 +1,13 @@ +module dmagick.c.segment; + +import dmagick.c.colorspace; +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; +import dmagick.c.pixel; + +extern(C) +{ + MagickBooleanType GetImageDynamicThreshold(const Image*, const double, const double, MagickPixelPacket*, ExceptionInfo*); + MagickBooleanType SegmentImage(Image*, const ColorspaceType, const MagickBooleanType, const double, const double); +} diff --git a/dmagick/c/semaphore.d b/dmagick/c/semaphore.d new file mode 100644 index 0000000..92ed1ed --- /dev/null +++ b/dmagick/c/semaphore.d @@ -0,0 +1,19 @@ +module dmagick.c.semaphore; + +import dmagick.c.magickType; + +extern(C) +{ + struct SemaphoreInfo {} + + MagickBooleanType SemaphoreComponentGenesis(); + + SemaphoreInfo* AllocateSemaphoreInfo(); + + void AcquireSemaphoreInfo(SemaphoreInfo**); + void DestroySemaphoreInfo(SemaphoreInfo**); + void LockSemaphoreInfo(SemaphoreInfo*); + void RelinquishSemaphoreInfo(SemaphoreInfo*); + void SemaphoreComponentTerminus(); + void UnlockSemaphoreInfo(SemaphoreInfo*); +} diff --git a/dmagick/c/sheer.d b/dmagick/c/sheer.d new file mode 100644 index 0000000..6555e65 --- /dev/null +++ b/dmagick/c/sheer.d @@ -0,0 +1,13 @@ +module dmagick.c.sheer; + +import dmagick.c.exception; +import dmagick.c.geometry; +import dmagick.c.image; + +extern(C) +{ + Image* AffineTransformImage(const Image*, const AffineMatrix*, ExceptionInfo*); + Image* DeskewImage(const Image*, const double, ExceptionInfo*); + Image* RotateImage(const Image*, const double, ExceptionInfo*); + Image* ShearImage(const Image*, const double, const double, ExceptionInfo*); +} diff --git a/dmagick/c/signature.d b/dmagick/c/signature.d new file mode 100644 index 0000000..3d75b58 --- /dev/null +++ b/dmagick/c/signature.d @@ -0,0 +1,6 @@ +module dmagick.c.signature; + +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) MagickBooleanType SignatureImage(Image*); diff --git a/dmagick/c/splayTree.d b/dmagick/c/splayTree.d new file mode 100644 index 0000000..77c8489 --- /dev/null +++ b/dmagick/c/splayTree.d @@ -0,0 +1,30 @@ +module dmagick.c.splayTree; + +import dmagick.c.magickType; + +extern(C) +{ + struct SplayTreeInfo {} + + MagickBooleanType AddValueToSplayTree(SplayTreeInfo*, const void*, const void*); + MagickBooleanType DeleteNodeByValueFromSplayTree(SplayTreeInfo*, const void*); + MagickBooleanType DeleteNodeFromSplayTree(SplayTreeInfo*, const void*); + + const(void*) GetNextKeyInSplayTree(SplayTreeInfo*); + const(void*) GetNextValueInSplayTree(SplayTreeInfo*); + const(void*) GetValueFromSplayTree(SplayTreeInfo*, const void*); + + int CompareSplayTreeString(const void*, const void*); + int CompareSplayTreeStringInfo(const void*, const void*); + + SplayTreeInfo* CloneSplayTree(SplayTreeInfo*, void* function(void*), void* function(void*)); + SplayTreeInfo* DestroySplayTree(SplayTreeInfo*); + SplayTreeInfo* NewSplayTree(int function(const void*, const void*), void* function(void*), void* function(void*)); + + size_t GetNumberOfNodesInSplayTree(const SplayTreeInfo*); + + void* RemoveNodeByValueFromSplayTree(SplayTreeInfo*, const void*); + void* RemoveNodeFromSplayTree(SplayTreeInfo*, const void*); + void ResetSplayTree(SplayTreeInfo*); + void ResetSplayTreeIterator(SplayTreeInfo*); +} diff --git a/dmagick/c/statistic.d b/dmagick/c/statistic.d new file mode 100644 index 0000000..b63a184 --- /dev/null +++ b/dmagick/c/statistic.d @@ -0,0 +1,86 @@ +module dmagick.c.statistic; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + struct ChannelStatistics + { + size_t + depth; + + double + minima, + maxima, + sum, + sum_squared, + sum_cubed, + sum_fourth_power, + mean, + variance, + standard_deviation, + kurtosis, + skewness; + } + + enum MagickEvaluateOperator + { + 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 + } + + enum MagickFunction + { + UndefinedFunction, + PolynomialFunction, + SinusoidFunction, + ArcsinFunction, + ArctanFunction + } + + ChannelStatistics* GetImageChannelStatistics(const Image*, ExceptionInfo*); + + Image* EvaluateImages(const Image*, const MagickEvaluateOperator, ExceptionInfo*); + + MagickBooleanType EvaluateImage(Image*, const MagickEvaluateOperator, const double, ExceptionInfo*); + MagickBooleanType EvaluateImageChannel(Image*, const ChannelType, const MagickEvaluateOperator, const double, ExceptionInfo*); + MagickBooleanType FunctionImage(Image*, const MagickFunction, const size_t, const double*, ExceptionInfo*); + MagickBooleanType FunctionImageChannel(Image*, const ChannelType, const MagickFunction, const size_t, const double*, ExceptionInfo*); + MagickBooleanType GetImageChannelExtrema(const Image*, const ChannelType, size_t*, size_t*, ExceptionInfo*); + MagickBooleanType GetImageChannelMean(const Image*, const ChannelType, double*, double*, ExceptionInfo*); + MagickBooleanType GetImageChannelKurtosis(const Image*, const ChannelType, double*, double*, ExceptionInfo*); + MagickBooleanType GetImageChannelRange(const Image*, const ChannelType, double*, double*, ExceptionInfo*); + MagickBooleanType GetImageExtrema(const Image*, size_t*, size_t*, ExceptionInfo*); + MagickBooleanType GetImageRange(const Image*, double*, double*, ExceptionInfo*); + MagickBooleanType GetImageMean(const Image*, double*, double*, ExceptionInfo*); + MagickBooleanType GetImageKurtosis(const Image*, double*, double*, ExceptionInfo*); +} diff --git a/dmagick/c/stream.d b/dmagick/c/stream.d new file mode 100644 index 0000000..788ca72 --- /dev/null +++ b/dmagick/c/stream.d @@ -0,0 +1,14 @@ +module dmagick.c.stream; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + alias size_t function(const Image *,const void *,const size_t) StreamHandler; + + Image* ReadStream(const ImageInfo*, StreamHandler, ExceptionInfo*); + + MagickBooleanType WriteStream(const ImageInfo*, Image*, StreamHandler); +} diff --git a/dmagick/c/threshold.d b/dmagick/c/threshold.d new file mode 100644 index 0000000..4134b13 --- /dev/null +++ b/dmagick/c/threshold.d @@ -0,0 +1,34 @@ +module dmagick.c.threshold; + +import core.stdc.stdio; +import core.sys.posix.sys.types; + +import dmagick.c.exception; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + struct ThresholdMap {} + + Image* AdaptiveThresholdImage(const Image*, const size_t, const size_t, const ssize_t, ExceptionInfo*); + + ThresholdMap* DestroyThresholdMap(ThresholdMap*); + ThresholdMap* GetThresholdMap(const char*, ExceptionInfo*); + + MagickBooleanType BilevelImage(Image*, const double); + MagickBooleanType BilevelImageChannel(Image*, const ChannelType, const double); + MagickBooleanType BlackThresholdImage(Image*, const char*); + MagickBooleanType BlackThresholdImageChannel(Image*, const ChannelType, const char*, ExceptionInfo*); + MagickBooleanType ClampImage(Image*); + MagickBooleanType ClampImageChannel(Image*, const ChannelType); + MagickBooleanType ListThresholdMaps(FILE*, ExceptionInfo*); + MagickBooleanType OrderedDitherImage(Image*); + MagickBooleanType OrderedDitherImageChannel(Image*, const ChannelType, ExceptionInfo*); + MagickBooleanType OrderedPosterizeImage(Image*, const char*, ExceptionInfo*); + MagickBooleanType OrderedPosterizeImageChannel(Image*, const ChannelType, const char*, ExceptionInfo*); + MagickBooleanType RandomThresholdImage(Image*, const char*, ExceptionInfo*); + MagickBooleanType RandomThresholdImageChannel(Image*, const ChannelType, const char*, ExceptionInfo*); + MagickBooleanType WhiteThresholdImage(Image*, const char*); + MagickBooleanType WhiteThresholdImageChannel(Image *,const ChannelType,const char *,ExceptionInfo *); +} diff --git a/dmagick/c/timer.d b/dmagick/c/timer.d new file mode 100644 index 0000000..36603ce --- /dev/null +++ b/dmagick/c/timer.d @@ -0,0 +1,46 @@ +module dmagick.c.timer; + +import dmagick.c.magickType; + +extern(C) +{ + enum TimerState + { + UndefinedTimerState, + StoppedTimerState, + RunningTimerState + } + + struct Timer + { + double + start, + stop, + total; + } + + struct TimerInfo + { + Timer + user, + elapsed; + + TimerState + state; + + size_t + signature; + } + + double GetElapsedTime(TimerInfo*); + double GetUserTime(TimerInfo*); + + MagickBooleanType ContinueTimer(TimerInfo*); + + TimerInfo* AcquireTimerInfo(); + TimerInfo* DestroyTimerInfo(TimerInfo*); + + void GetTimerInfo(TimerInfo*); + void ResetTimer(TimerInfo*); + void StartTimer(TimerInfo*, const MagickBooleanType); +} diff --git a/dmagick/c/token.d b/dmagick/c/token.d new file mode 100644 index 0000000..007cc98 --- /dev/null +++ b/dmagick/c/token.d @@ -0,0 +1,19 @@ +module dmagick.c.token; + +import dmagick.c.magickType; + +extern(C) +{ + struct TokenInfo {} + + int Tokenizer(TokenInfo*, const uint, char*, const size_t, const char*, + const char*, const char*, const char*, const char, char*, int*, char*); + + MagickBooleanType GlobExpression(const char*, const char*, const MagickBooleanType); + MagickBooleanType IsGlob(const char*); + + TokenInfo* AcquireTokenInfo(); + TokenInfo* DestroyTokenInfo(TokenInfo*); + + void GetMagickToken(const char*, const char**, char*); +} diff --git a/dmagick/c/transform.d b/dmagick/c/transform.d new file mode 100644 index 0000000..462d1a9 --- /dev/null +++ b/dmagick/c/transform.d @@ -0,0 +1,28 @@ +module dmagick.c.transform; + +import core.sys.posix.sys.types; + +import dmagick.c.exception; +import dmagick.c.geometry; +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + Image* ChopImage(const Image*, const RectangleInfo*, ExceptionInfo*); + Image* ConsolidateCMYKImages(const Image*, ExceptionInfo*); + Image* CropImage(const Image*, const RectangleInfo*, ExceptionInfo*); + Image* ExcerptImage(const Image*, const RectangleInfo*, ExceptionInfo*); + Image* ExtentImage(const Image*, const RectangleInfo*, ExceptionInfo*); + Image* FlipImage(const Image*, ExceptionInfo*); + Image* FlopImage(const Image*, ExceptionInfo*); + Image* RollImage(const Image*, const ssize_t, const ssize_t, ExceptionInfo*); + Image* ShaveImage(const Image*, const RectangleInfo*, ExceptionInfo*); + Image* SpliceImage(const Image*, const RectangleInfo*, ExceptionInfo*); + Image* TransposeImage(const Image*, ExceptionInfo*); + Image* TransverseImage(const Image*, ExceptionInfo*); + Image* TrimImage(const Image*, ExceptionInfo*); + + MagickBooleanType TransformImage(Image**, const char*, const char*); + MagickBooleanType TransformImages(Image**, const char*, const char*); +} diff --git a/dmagick/c/type.d b/dmagick/c/type.d new file mode 100644 index 0000000..2365443 --- /dev/null +++ b/dmagick/c/type.d @@ -0,0 +1,82 @@ +module dmagick.c.type; + +import core.stdc.stdio; + +import dmagick.c.exception; +import dmagick.c.magickType; + +extern(C) +{ + enum StretchType + { + UndefinedStretch, + NormalStretch, + UltraCondensedStretch, + ExtraCondensedStretch, + CondensedStretch, + SemiCondensedStretch, + SemiExpandedStretch, + ExpandedStretch, + ExtraExpandedStretch, + UltraExpandedStretch, + AnyStretch + } + + enum StyleType + { + UndefinedStyle, + NormalStyle, + ItalicStyle, + ObliqueStyle, + AnyStyle + } + + 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; + + TypeInfo* + previous, + next; + + size_t + signature; + } + + char** GetTypeList(const char*, size_t*, ExceptionInfo*); + + MagickBooleanType ListTypeInfo(FILE*, ExceptionInfo*); + MagickBooleanType TypeComponentGenesis(); + + const(TypeInfo*) GetTypeInfo(const char*, ExceptionInfo*); + const(TypeInfo*) GetTypeInfoByFamily(const char*, const StyleType, const StretchType, const size_t, ExceptionInfo*); + const(TypeInfo**) GetTypeInfoList(const char*, size_t*, ExceptionInfo*); + + void TypeComponentTerminus(); +} diff --git a/dmagick/c/utility.d b/dmagick/c/utility.d new file mode 100644 index 0000000..bc4e2db --- /dev/null +++ b/dmagick/c/utility.d @@ -0,0 +1,51 @@ +module dmagick.c.utility; + +import core.stdc.stdio; +import core.sys.posix.sys.types; + +import dmagick.c.exception; +import dmagick.c.magickType; + +extern(C) +{ + enum PathType + { + UndefinedPath, + MagickPath, + RootPath, + HeadPath, + TailPath, + BasePath, + ExtensionPath, + SubimagePath, + CanonicalPath + } + + char* Base64Encode(const ubyte*, const size_t, size_t*); + char** GetPathComponents(const char*, size_t*); + char** ListFiles(const char*, const char*, size_t*); + + FILE* OpenMagickStream(const char*, const char*); + + int SystemCommand(const MagickBooleanType, const MagickBooleanType, const char*, ExceptionInfo*); + + MagickBooleanType AcquireUniqueFilename(char*); + MagickBooleanType AcquireUniqueSymbolicLink(const char*, char*); + MagickBooleanType ExpandFilenames(int*, char***); + MagickBooleanType GetPathAttributes(const char*, void*); + MagickBooleanType GetExecutionPath(char*, const size_t); + MagickBooleanType IsMagickTrue(const char*); + MagickBooleanType IsPathAccessible(const char*); + + size_t MultilineCensus(const char*); + + ssize_t GetMagickPageSize(); + + ubyte* Base64Decode(const char*, size_t*); + + void AppendImageFormat(const char*, char*); + void ChopPathComponents(char*, const size_t); + void ExpandFilename(char*); + void GetPathComponent(const char*, PathType, char*); + void MagickDelay(const MagickSizeType); +} diff --git a/dmagick/c/xmlTree.d b/dmagick/c/xmlTree.d new file mode 100644 index 0000000..dc1bbbb --- /dev/null +++ b/dmagick/c/xmlTree.d @@ -0,0 +1,36 @@ +module dmagick.c.xmlTree; + +import dmagick.c.exception; +import dmagick.c.magickType; +import dmagick.c.splayTree; + +extern(C) +{ + struct XMLTreeInfo {} + + char* CanonicalXMLContent(const char*, const MagickBooleanType); + char* XMLTreeInfoToXML(XMLTreeInfo*); + + const(char*) GetXMLTreeAttribute(XMLTreeInfo*, const char*); + const(char*) GetXMLTreeContent(XMLTreeInfo*); + const(char**) GetXMLTreeProcessingInstructions(XMLTreeInfo*, const char*); + const(char*) GetXMLTreeTag(XMLTreeInfo*); + + MagickBooleanType GetXMLTreeAttributes(const XMLTreeInfo*, SplayTreeInfo*); + + XMLTreeInfo* AddChildToXMLTree(XMLTreeInfo*, const char*, const size_t); + XMLTreeInfo* AddPathToXMLTree(XMLTreeInfo*, const char*, const size_t); + XMLTreeInfo* DestroyXMLTree(XMLTreeInfo*); + XMLTreeInfo* GetNextXMLTreeTag(XMLTreeInfo*); + XMLTreeInfo* GetXMLTreeChild(XMLTreeInfo*, const char*); + XMLTreeInfo* GetXMLTreeOrdered(XMLTreeInfo*); + XMLTreeInfo* GetXMLTreePath(XMLTreeInfo*, const char*); + XMLTreeInfo* GetXMLTreeSibling(XMLTreeInfo*); + XMLTreeInfo* InsertTagIntoXMLTree(XMLTreeInfo*, XMLTreeInfo*, const size_t); + XMLTreeInfo* NewXMLTree(const char*, ExceptionInfo*); + XMLTreeInfo* NewXMLTreeTag(const char*); + XMLTreeInfo* ParseTagFromXMLTree(XMLTreeInfo*); + XMLTreeInfo* PruneTagFromXMLTree(XMLTreeInfo*); + XMLTreeInfo* SetXMLTreeAttribute(XMLTreeInfo*, const char*, const char*); + XMLTreeInfo* SetXMLTreeContent(XMLTreeInfo*, const char*); +} diff --git a/dmagick/c/xwindow.d b/dmagick/c/xwindow.d new file mode 100644 index 0000000..80b416a --- /dev/null +++ b/dmagick/c/xwindow.d @@ -0,0 +1,21 @@ +module dmagick.c.xwindow; + +import dmagick.c.image; +import dmagick.c.magickType; + +extern(C) +{ + struct XImportInfo + { + MagickBooleanType + frame, + borders, + screen, + descend, + silent; + } + + Image* XImportImage(const ImageInfo*, XImportInfo*); + + void XGetImportInfo(XImportInfo*); +} |