2814 lines
108 KiB
Racket
2814 lines
108 KiB
Racket
#lang scheme/base
|
|
|
|
(require mzlib/foreign) (unsafe!)
|
|
|
|
(define (ffi-try-libs . libs)
|
|
(let loop ([libs* libs]
|
|
[exceptions '()])
|
|
(if (null? libs*)
|
|
(error 'ffi-try-libs "Could not load any of the libraries in ~a\n~a\n" libs exceptions)
|
|
(let ([lib (caar libs*)]
|
|
[version (cdar libs*)])
|
|
(with-handlers ([exn:fail:filesystem? (lambda (e)
|
|
(loop (cdr libs*) (cons e exceptions)))])
|
|
(ffi-lib lib version))))))
|
|
|
|
(define libwand (ffi-try-libs '("libWand" "6.0.1" "6")
|
|
'("libMagickWand" "1" "3")))
|
|
|
|
;; ===== Main Objects =========================================================
|
|
|
|
(define-syntax defmagick-pointer-type
|
|
(syntax-rules ()
|
|
[(_ _name destructor s->c)
|
|
(define-cpointer-type _name #f s->c
|
|
(lambda (ptr)
|
|
(if ptr
|
|
(begin (register-finalizer ptr destructor) ptr)
|
|
(error '_name "got a NULL pointer"))))]
|
|
[(_ _name destructor) (defmagick-pointer-type _name destructor #f)]))
|
|
|
|
(defmagick-pointer-type _MagickWand DestroyMagickWand)
|
|
(defmagick-pointer-type _DrawingWand DestroyDrawingWand)
|
|
(defmagick-pointer-type _Image DestroyImage)
|
|
(defmagick-pointer-type _DrawInfo DestroyDrawInfo)
|
|
(defmagick-pointer-type _PixelWand DestroyPixelWand
|
|
;; This can be implicitly built when given a color name
|
|
(lambda (x)
|
|
(let loop ([x x])
|
|
(cond [(string? x) (loop (NewPixelWand x))]
|
|
[(list? x) (loop (NewPixelWand x))]
|
|
[else x])))) ; can use NULL as a pixel wand (see floodfill)
|
|
|
|
;; Use a struct for this because we want to keep the associated image width
|
|
(define-struct PixelIterator (ptr [width #:mutable]))
|
|
(define _PixelIterator
|
|
(make-ctype _pointer PixelIterator-ptr
|
|
(lambda (ptr)
|
|
(if ptr
|
|
(let ([new (make-PixelIterator ptr #f)]) ; width set by makers
|
|
(register-finalizer new DestroyPixelIterator)
|
|
new)
|
|
(error '_PixelIterator "got a NULL pointer")))))
|
|
|
|
;; ===== Utilities ============================================================
|
|
|
|
(define (raise-wand-exception w)
|
|
((cond [(MagickWand? w) MagickGetException ]
|
|
[(PixelWand? w) PixelGetException ]
|
|
[(PixelIterator? w) PixelIteratorGetException]
|
|
[(DrawingWand? w) DrawGetException ]
|
|
[else (error 'raise-wand-exception "got an unknown value: ~e" w)])
|
|
w)
|
|
(error 'wand-exception "an undefined error occurred with ~e" w))
|
|
|
|
(define-fun-syntax _status
|
|
(syntax-id-rules (_status)
|
|
[_status (type: _bool
|
|
1st-arg: 1st
|
|
post: (r => (unless r (raise-wand-exception 1st))))]))
|
|
|
|
(define-syntax defmagick
|
|
(syntax-rules (:)
|
|
[(_ id : x ...) (define id (get-ffi-obj 'id libwand (_fun x ...)))]))
|
|
|
|
(define-syntax defmagick*
|
|
(syntax-rules ()
|
|
[(_ name x ...) (begin (defmagick name x ...) (provide name))]))
|
|
|
|
;; Used to convert (small) square matrices (lists of lists) to a memory block.
|
|
(define (_sqmatrix-of type)
|
|
(make-ctype _pointer
|
|
(lambda (m)
|
|
(let ([len (and (list? m) (length m))])
|
|
(unless (and len (< 0 len)
|
|
(andmap (lambda (x) (and (list? x) (= len (length x))))
|
|
m))
|
|
(error '_sqmatrix "expecting a rectangular matrix"))
|
|
(let ([block (malloc (* len len) type)])
|
|
(let loop ([n 0] [xs (apply append m)])
|
|
(unless (null? xs)
|
|
(ptr-set! block type n (car xs))
|
|
(loop (add1 n) (cdr xs))))
|
|
block)))
|
|
(lambda (x) (error '_sqmatrix "can be used only for ffi inputs"))))
|
|
|
|
;; This is a hack. What is needed is to be able to define a type that is a
|
|
;; struct of two doubles that translates to a list of two values.
|
|
(define _Points
|
|
(make-ctype _pointer
|
|
(lambda (l)
|
|
(unless (and (list? l)
|
|
(andmap (lambda (x) (and (list? x) (= 2 (length x)))) l))
|
|
(error '_Points "expecting a list of two-element lists, got ~e" l))
|
|
(list->cblock (apply append l) _double*))
|
|
(lambda (x)
|
|
(error '_Points "cannot be used as an output type"))))
|
|
|
|
;; Hack for the same reason as above.
|
|
(define _AffineMatrix
|
|
(make-ctype _pointer
|
|
(lambda (l)
|
|
(unless (and (list? l) (= 6 (length l)))
|
|
(error '_Points "expecting a list of six numbers, got ~e" l))
|
|
(list->cblock l _double*))
|
|
(lambda (x) (cblock->list x _double* 6))))
|
|
|
|
;; Utilities for MagickGetImagePixels/MagickSetImagePixels
|
|
|
|
(define (StorageType->type storage-type)
|
|
(case storage-type
|
|
[(UndefinedPixel) (error 'StorageType->type "got an UndefinedPixel")]
|
|
[(CharPixel) _byte]
|
|
[(ShortPixel) _word]
|
|
[(IntegerPixel) _uint]
|
|
[(LongPixel) _ulong]
|
|
[(FloatPixel) _float]
|
|
[(DoublePixel) _double*]))
|
|
|
|
;; Gets a list and a number, and returns a list of lists of length n.
|
|
(define (n-split l n)
|
|
(let loop ([l l][i 0][a2 null][a null])
|
|
(cond
|
|
[(null? l) (let ([a (if (null? a2)
|
|
a
|
|
(cons (reverse a2) a))])
|
|
(reverse a))]
|
|
[(= i n) (loop l 0 null (cons (reverse a2) a))]
|
|
[else (loop (cdr l) (add1 i) (cons (car l) a2) a)])))
|
|
|
|
;; _Quantum is something that the library tells us how big it is
|
|
(define _Quantum
|
|
(let* ([q ((get-ffi-obj "MagickGetQuantumDepth" libwand
|
|
(_fun _pointer -> _string))
|
|
#f)]
|
|
[err (lambda ()
|
|
(error 'libwand
|
|
"MagickGetQuantumDepth returned a bad value: ~s" q))])
|
|
(cond [(and (string? q) (regexp-match #rx"^Q([0-9]+)$" q))
|
|
=> (lambda (m)
|
|
(case (string->number (cadr m))
|
|
[( 8) _uint8] [(16) _uint16] [(32) _uint32]
|
|
[else (err)]))]
|
|
[else (err)])))
|
|
|
|
;; Used twice (PixelGetIndex/PixelSetIndex).
|
|
(define _IndexPacket _Quantum)
|
|
|
|
(define _MagickSizeType _uint64)
|
|
|
|
;; This type only needs to be created for PixelGetQuantumColor results.
|
|
;; (Could also define it as a macro for (_list ? _Quantum 4).)
|
|
(define-struct PixelPacket (ptr))
|
|
(define _PixelPacket
|
|
(make-ctype _pointer PixelPacket-ptr make-PixelPacket))
|
|
(define (NewPixelPacket)
|
|
(make-PixelPacket (malloc _Quantum 4)))
|
|
|
|
;; ===== Enumeration Types ====================================================
|
|
|
|
(define _MagickExceptionType
|
|
(_enum '(UndefinedException
|
|
WarningException = 300
|
|
ResourceLimitWarning = 300
|
|
TypeWarning = 305
|
|
OptionWarning = 310
|
|
DelegateWarning = 315
|
|
MissingDelegateWarning = 320
|
|
CorruptImageWarning = 325
|
|
FileOpenWarning = 330
|
|
BlobWarning = 335
|
|
StreamWarning = 340
|
|
CacheWarning = 345
|
|
CoderWarning = 350
|
|
ModuleWarning = 355
|
|
DrawWarning = 360
|
|
ImageWarning = 365
|
|
WandWarning = 370
|
|
XServerWarning = 380
|
|
MonitorWarning = 385
|
|
RegistryWarning = 390
|
|
ConfigureWarning = 395
|
|
ErrorException = 400
|
|
ResourceLimitError = 400
|
|
TypeError = 405
|
|
OptionError = 410
|
|
DelegateError = 415
|
|
MissingDelegateError = 420
|
|
CorruptImageError = 425
|
|
FileOpenError = 430
|
|
BlobError = 435
|
|
StreamError = 440
|
|
CacheError = 445
|
|
CoderError = 450
|
|
ModuleError = 455
|
|
DrawError = 460
|
|
ImageError = 465
|
|
WandError = 470
|
|
XServerError = 480
|
|
MonitorError = 485
|
|
RegistryError = 490
|
|
ConfigureError = 495
|
|
FatalErrorException = 700
|
|
ResourceLimitFatalError = 700
|
|
TypeFatalError = 705
|
|
OptionFatalError = 710
|
|
DelegateFatalError = 715
|
|
MissingDelegateFatalError = 720
|
|
CorruptImageFatalError = 725
|
|
FileOpenFatalError = 730
|
|
BlobFatalError = 735
|
|
StreamFatalError = 740
|
|
CacheFatalError = 745
|
|
CoderFatalError = 750
|
|
ModuleFatalError = 755
|
|
DrawFatalError = 760
|
|
ImageFatalError = 765
|
|
WandFatalError = 770
|
|
XServerFatalError = 780
|
|
MonitorFatalError = 785
|
|
RegistryFatalError = 790
|
|
ConfigureFatalError = 795
|
|
)))
|
|
|
|
(define _CompositeOperator
|
|
(_enum '(UndefinedCompositeOp
|
|
NoCompositeOp
|
|
AddCompositeOp
|
|
AtopCompositeOp
|
|
BlendCompositeOp
|
|
BumpmapCompositeOp
|
|
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
|
|
LuminizeCompositeOp
|
|
MinusCompositeOp
|
|
ModulateCompositeOp
|
|
MultiplyCompositeOp
|
|
OutCompositeOp
|
|
OverCompositeOp
|
|
OverlayCompositeOp
|
|
PlusCompositeOp
|
|
ReplaceCompositeOp
|
|
SaturateCompositeOp
|
|
ScreenCompositeOp
|
|
SoftLightCompositeOp
|
|
SrcAtopCompositeOp
|
|
SrcCompositeOp
|
|
SrcInCompositeOp
|
|
SrcOutCompositeOp
|
|
SrcOverCompositeOp
|
|
SubtractCompositeOp
|
|
ThresholdCompositeOp
|
|
XorCompositeOp
|
|
)))
|
|
|
|
(define _ColorspaceType
|
|
(_enum '(UndefinedColorspace
|
|
RGBColorspace
|
|
GRAYColorspace
|
|
TransparentColorspace
|
|
OHTAColorspace
|
|
LABColorspace
|
|
XYZColorspace
|
|
YCbCrColorspace
|
|
YCCColorspace
|
|
YIQColorspace
|
|
YPbPrColorspace
|
|
YUVColorspace
|
|
CMYKColorspace
|
|
sRGBColorspace
|
|
HSBColorspace
|
|
HSLColorspace
|
|
HWBColorspace
|
|
)))
|
|
|
|
(define _CompressionType
|
|
(_enum '(UndefinedCompression
|
|
NoCompression
|
|
BZipCompression
|
|
FaxCompression
|
|
Group4Compression
|
|
JPEGCompression
|
|
LosslessJPEGCompression
|
|
LZWCompression
|
|
RLECompression
|
|
ZipCompression
|
|
)))
|
|
|
|
(define _DisposeType
|
|
(_enum '(UnrecognizedDispose
|
|
UndefinedDispose = 0
|
|
NoneDispose = 1
|
|
BackgroundDispose = 2
|
|
PreviousDispose = 3
|
|
)))
|
|
|
|
(define _ImageType
|
|
(_enum '(UndefinedType
|
|
BilevelType
|
|
GrayscaleType
|
|
GrayscaleMatteType
|
|
PaletteType
|
|
PaletteMatteType
|
|
TrueColorType
|
|
TrueColorMatteType
|
|
ColorSeparationType
|
|
ColorSeparationMatteType
|
|
OptimizeType
|
|
)))
|
|
|
|
(define _InterlaceType
|
|
(_enum '(UndefinedInterlace
|
|
NoInterlace
|
|
LineInterlace
|
|
PlaneInterlace
|
|
PartitionInterlace
|
|
)))
|
|
|
|
(define _ChannelType
|
|
(_bitmask '(UndefinedChannel = #x0000
|
|
RedChannel = #x0001
|
|
CyanChannel = #x0001
|
|
GreenChannel = #x0002
|
|
MagentaChannel = #x0002
|
|
BlueChannel = #x0004
|
|
YellowChannel = #x0004
|
|
AlphaChannel = #x0008
|
|
OpacityChannel = #x0008
|
|
MatteChannel = #x0008 ; deprecated
|
|
BlackChannel = #x0020
|
|
IndexChannel = #x0020
|
|
AllChannels = #x7fffffff
|
|
)))
|
|
|
|
(define _MetricType
|
|
(_enum '(UndefinedMetric
|
|
MeanAbsoluteErrorMetric
|
|
MeanSquaredErrorMetric
|
|
PeakAbsoluteErrorMetric
|
|
PeakSignalToNoiseRatioMetric
|
|
RootMeanSquaredErrorMetric
|
|
)))
|
|
|
|
(define _NoiseType
|
|
(_enum '(UndefinedNoise
|
|
UniformNoise
|
|
GaussianNoise
|
|
MultiplicativeGaussianNoise
|
|
ImpulseNoise
|
|
LaplacianNoise
|
|
PoissonNoise
|
|
)))
|
|
|
|
(define _MagickEvaluateOperator
|
|
(_enum '(UndefinedEvaluateOperator
|
|
AddEvaluateOperator
|
|
AndEvaluateOperator
|
|
DivideEvaluateOperator
|
|
LeftShiftEvaluateOperator
|
|
MaxEvaluateOperator
|
|
MinEvaluateOperator
|
|
MultiplyEvaluateOperator
|
|
OrEvaluateOperator
|
|
RightShiftEvaluateOperator
|
|
SetEvaluateOperator
|
|
SubtractEvaluateOperator
|
|
XorEvaluateOperator
|
|
)))
|
|
|
|
(define _ResourceType
|
|
(_enum '(UndefinedResource
|
|
AreaResource
|
|
DiskResource
|
|
FileResource
|
|
MapResource
|
|
MemoryResource
|
|
)))
|
|
|
|
(define _StorageType
|
|
(_enum '(UndefinedPixel
|
|
CharPixel
|
|
ShortPixel
|
|
IntegerPixel
|
|
LongPixel
|
|
FloatPixel
|
|
DoublePixel
|
|
)))
|
|
|
|
(define _RenderingIntent
|
|
(_enum '(UndefinedIntent
|
|
SaturationIntent
|
|
PerceptualIntent
|
|
AbsoluteIntent
|
|
RelativeIntent
|
|
)))
|
|
|
|
(define _ResolutionType
|
|
(_enum '(UndefinedResolution
|
|
PixelsPerInchResolution
|
|
PixelsPerCentimeterResolution
|
|
)))
|
|
|
|
(define _VirtualPixelMethod
|
|
(_enum '(UndefinedVirtualPixelMethod
|
|
ConstantVirtualPixelMethod
|
|
EdgeVirtualPixelMethod
|
|
MirrorVirtualPixelMethod
|
|
TileVirtualPixelMethod
|
|
)))
|
|
|
|
(define _PreviewType
|
|
(_enum '(UndefinedPreview
|
|
RotatePreview
|
|
ShearPreview
|
|
RollPreview
|
|
HuePreview
|
|
SaturationPreview
|
|
BrightnessPreview
|
|
GammaPreview
|
|
SpiffPreview
|
|
DullPreview
|
|
GrayscalePreview
|
|
QuantizePreview
|
|
DespecklePreview
|
|
ReduceNoisePreview
|
|
AddNoisePreview
|
|
SharpenPreview
|
|
BlurPreview
|
|
ThresholdPreview
|
|
EdgeDetectPreview
|
|
SpreadPreview
|
|
SolarizePreview
|
|
ShadePreview
|
|
RaisePreview
|
|
SegmentPreview
|
|
SwirlPreview
|
|
ImplodePreview
|
|
WavePreview
|
|
OilPaintPreview
|
|
CharcoalDrawingPreview
|
|
JPEGPreview
|
|
)))
|
|
|
|
(define _FilterTypes
|
|
(_enum '(UndefinedFilter
|
|
PointFilter
|
|
BoxFilter
|
|
TriangleFilter
|
|
HermiteFilter
|
|
HanningFilter
|
|
HammingFilter
|
|
BlackmanFilter
|
|
GaussianFilter
|
|
QuadraticFilter
|
|
CubicFilter
|
|
CatromFilter
|
|
MitchellFilter
|
|
LanczosFilter
|
|
BesselFilter
|
|
SincFilter
|
|
)))
|
|
|
|
(define _MontageMode
|
|
(_enum '(UndefinedMode
|
|
FrameMode
|
|
UnframeMode
|
|
ConcatenateMode
|
|
)))
|
|
|
|
(define _StretchType
|
|
(_enum '(UndefinedStretch
|
|
NormalStretch
|
|
UltraCondensedStretch
|
|
ExtraCondensedStretch
|
|
CondensedStretch
|
|
SemiCondensedStretch
|
|
SemiExpandedStretch
|
|
ExpandedStretch
|
|
ExtraExpandedStretch
|
|
UltraExpandedStretch
|
|
AnyStretch
|
|
)))
|
|
|
|
(define _StyleType
|
|
(_enum '(UndefinedStyle
|
|
NormalStyle
|
|
ItalicStyle
|
|
ObliqueStyle
|
|
AnyStyle
|
|
)))
|
|
|
|
(define _GravityType
|
|
(_enum '(UndefinedGravity
|
|
ForgetGravity = 0
|
|
NorthWestGravity = 1
|
|
NorthGravity = 2
|
|
NorthEastGravity = 3
|
|
WestGravity = 4
|
|
CenterGravity = 5
|
|
EastGravity = 6
|
|
SouthWestGravity = 7
|
|
SouthGravity = 8
|
|
SouthEastGravity = 9
|
|
StaticGravity = 10
|
|
)))
|
|
|
|
(define _ClipPathUnits
|
|
(_enum '(UndefinedPathUnits
|
|
UserSpace
|
|
UserSpaceOnUse
|
|
ObjectBoundingBox
|
|
)))
|
|
|
|
(define _DecorationType
|
|
(_enum '(UndefinedDecoration
|
|
NoDecoration
|
|
UnderlineDecoration
|
|
OverlineDecoration
|
|
LineThroughDecoration
|
|
)))
|
|
|
|
(define _FillRule
|
|
(_enum '(UndefinedRule
|
|
EvenOddRule
|
|
NonZeroRule
|
|
)))
|
|
|
|
(define _LineCap
|
|
(_enum '(UndefinedCap
|
|
ButtCap
|
|
RoundCap
|
|
SquareCap
|
|
)))
|
|
|
|
(define _LineJoin
|
|
(_enum '(UndefinedJoin
|
|
MiterJoin
|
|
RoundJoin
|
|
BevelJoin
|
|
)))
|
|
|
|
(define _PaintMethod
|
|
(_enum '(UndefinedMethod
|
|
PointMethod
|
|
ReplaceMethod
|
|
FloodfillMethod
|
|
FillToBorderMethod
|
|
ResetMethod
|
|
)))
|
|
|
|
;; ===== MagickWand API =======================================================
|
|
|
|
;; MagickGetException returns the severity, reason, and description of any
|
|
;; error that occurs when using other methods in this API (as an exception).
|
|
(defmagick* MagickGetException :
|
|
_MagickWand (severity : (_ptr o _MagickExceptionType)) -> (message : _string)
|
|
-> (unless (eq? severity 'UndefinedException)
|
|
(error 'MagickWand "(~a) ~a" severity message)))
|
|
|
|
;; DestroyMagickWand deallocates memory associated with an MagickWand.
|
|
;; Intended for internal use only, must be defined after the above.
|
|
(defmagick DestroyMagickWand :
|
|
_MagickWand -> _void)
|
|
|
|
;; CloneMagickWand makes an exact copy of the specified wand.
|
|
(defmagick* CloneMagickWand :
|
|
_MagickWand -> _MagickWand)
|
|
|
|
;; GetImageFromMagickWand returns the current image from the magick wand.
|
|
(defmagick* GetImageFromMagickWand :
|
|
_MagickWand -> _Image)
|
|
|
|
;; MagickAdaptiveThresholdImage selects an individual threshold for each pixel
|
|
;; based on the range of intensity values in its local neighborhood. This
|
|
;; allows for thresholding of an image whose global intensity histogram doesn't
|
|
;; contain distinctive peaks.
|
|
(defmagick* MagickAdaptiveThresholdImage :
|
|
_MagickWand (width : _ulong) (height : _ulong) (offset : _long) -> _status)
|
|
|
|
;; MagickAddImage adds the specified images at the current image location.
|
|
(defmagick* MagickAddImage :
|
|
_MagickWand (insert-wand : _MagickWand) -> _status)
|
|
|
|
;; MagickAddNoiseImage adds random noise to the image.
|
|
(defmagick* MagickAddNoiseImage :
|
|
_MagickWand _NoiseType -> _status)
|
|
|
|
;; MagickAffineTransformImage transforms an image as dictated by the affine
|
|
;; matrix of the drawing wand.
|
|
(defmagick* MagickAffineTransformImage :
|
|
_MagickWand _DrawingWand -> _status)
|
|
|
|
;; MagickAnimateImages animates an image or image sequence.
|
|
(defmagick* MagickAnimateImages :
|
|
(w . server) ::
|
|
(w : _MagickWand) (_string = (and (pair? server) (car server))) -> _status)
|
|
|
|
;; MagickAnnotateImage annotates an image with text.
|
|
(defmagick* MagickAnnotateImage :
|
|
_MagickWand _DrawingWand
|
|
(x : _double*) (y : _double*) (angle : _double*) (text : _string)
|
|
-> _status)
|
|
|
|
;; MagickAppendImages append a set of images.
|
|
(defmagick* MagickAppendImages :
|
|
_MagickWand (top-to-bottom? : _bool) -> _MagickWand)
|
|
|
|
;; MagickAverageImages average a set of images.
|
|
(defmagick* MagickAverageImages :
|
|
_MagickWand -> _MagickWand)
|
|
|
|
;; MagickBlackThresholdImage is like MagickThresholdImage but forces all pixels
|
|
;; below the threshold into black while leaving all pixels above the threshold
|
|
;; unchanged.
|
|
(defmagick* MagickBlackThresholdImage :
|
|
_MagickWand _PixelWand -> _status)
|
|
|
|
;; MagickBlurImage blurs an image. We convolve the image with a gaussian
|
|
;; operator of the given radius and standard deviation (sigma). For reasonable
|
|
;; results, the radius should be larger than sigma. Use a radius of 0 and
|
|
;; MagickBlurImage selects a suitable radius for you.
|
|
(defmagick* MagickBlurImage :
|
|
_MagickWand (radius : _double*) (sigma : _double*) -> _status)
|
|
|
|
;; MagickBlurImageChannel blurs one or more image channels. We convolve the
|
|
;; image cnannel with a gaussian operator of the given radius and standard
|
|
;; deviation (sigma). For reasonable results, the radius should be larger than
|
|
;; sigma. Use a radius of 0 and MagickBlurImageChannel selects a suitable
|
|
;; radius for you.
|
|
(defmagick* MagickBlurImageChannel :
|
|
_MagickWand _ChannelType (radius : _double*) (sigma : _double*) -> _status)
|
|
|
|
;; MagickBorderImage surrounds the image with a border of the color defined by
|
|
;; the bordercolor pixel wand.
|
|
(defmagick* MagickBorderImage :
|
|
_MagickWand (border : _PixelWand) (width : _ulong) (height : _ulong)
|
|
-> _status)
|
|
|
|
;; MagickCharcoalImage simulates a charcoal drawing.
|
|
(defmagick* MagickCharcoalImage :
|
|
_MagickWand (radius : _double*) (sigma : _double*) -> _status)
|
|
|
|
;; MagickChopImage removes a region of an image and collapses the image to
|
|
;; occupy the removed portion.
|
|
(defmagick* MagickChopImage :
|
|
_MagickWand (width : _ulong) (height : _ulong) (x : _long) (y : _long)
|
|
-> _status)
|
|
|
|
;; MagickClipImage clips along the first path from the 8BIM profile, if
|
|
;; present.
|
|
(defmagick* MagickClipImage :
|
|
_MagickWand -> _status)
|
|
|
|
;; MagickClipPathImage clips along the named paths from the 8BIM profile, if
|
|
;; present. Later operations take effect inside the path. Id may be a number
|
|
;; if preceded with #, to work on a numbered path, e.g., "#1" to use the first
|
|
;; path. If inside? is non-zero, later operations take effect inside clipping
|
|
;; path. Otherwise later operations take effect outside clipping path.
|
|
(defmagick* MagickClipPathImage :
|
|
_MagickWand (name : _string) (inside? : _bool) -> _status)
|
|
|
|
;; MagickCoalesceImages composites a set of images while respecting any page
|
|
;; offsets and disposal methods. GIF, MIFF, and MNG animation sequences
|
|
;; typically start with an image background and each subsequent image varies in
|
|
;; size and offset. MagickCoalesceImages returns a new sequence where each
|
|
;; image in the sequence is the same size as the first and composited with the
|
|
;; next image in the sequence.
|
|
(defmagick* MagickCoalesceImages :
|
|
_MagickWand -> _MagickWand)
|
|
|
|
;; MagickColorFloodfillImage changes the color value of any pixel that matches
|
|
;; target and is an immediate neighbor. If the method FillToBorderMethod is
|
|
;; specified, the color value is changed for any neighbor pixel that does not
|
|
;; match the bordercolor member of image.
|
|
(defmagick* MagickColorFloodfillImage :
|
|
_MagickWand (fill : _PixelWand) (fuzz : _double*) (border : _PixelWand)
|
|
(x : _long) (y : _long)
|
|
-> _status)
|
|
|
|
;; MagickColorizeImage blends the fill color with each pixel in the image.
|
|
(defmagick* MagickColorizeImage :
|
|
_MagickWand (colorize : _PixelWand) (opacity : _PixelWand) -> _status)
|
|
|
|
;; MagickCombineImages combines one or more images into a single image. The
|
|
;; grayscale value of the pixels of each image in the sequence is assigned in
|
|
;; order to the specified hannels of the combined image. The typical ordering
|
|
;; would be image 1 => Red, 2 => Green, 3 => Blue, etc.
|
|
(defmagick* MagickCombineImages :
|
|
_MagickWand _ChannelType -> _MagickWand)
|
|
|
|
;; MagickCommentImage adds a comment to your image.
|
|
(defmagick* MagickCommentImage :
|
|
_MagickWand (comment : _string) -> _status)
|
|
|
|
;; MagickCompareImageChannels compares one or more image channels and returns
|
|
;; the specified distortion metric.
|
|
(defmagick* MagickCompareImageChannels :
|
|
_MagickWand (reference : _MagickWand)
|
|
_ChannelType _MetricType (distortion : (_ptr o _double*))
|
|
-> (comp : _MagickWand)
|
|
-> (list distortion comp))
|
|
|
|
;; MagickCompositeImage composite one image onto another at the specified
|
|
;; offset.
|
|
(defmagick* MagickCompositeImage :
|
|
_MagickWand (composite : _MagickWand) _CompositeOperator
|
|
(x-offset : _long) (y-offset : _long)
|
|
-> _status)
|
|
|
|
;; MagickContrastImage enhances the intensity differences between the lighter
|
|
;; and darker elements of the image. Set sharpen? to a value other than 0 to
|
|
;; increase the image contrast otherwise the contrast is reduced.
|
|
(defmagick* MagickContrastImage :
|
|
_MagickWand (sharpen? : _bool) -> _status)
|
|
|
|
;; MagickConvolveImage applies a custom convolution kernel to the image.
|
|
(defmagick* MagickConvolveImage :
|
|
(w kernel) ::
|
|
(w : _MagickWand)
|
|
(_ulong = (length kernel)) (kernel : (_sqmatrix-of _double*))
|
|
-> _status)
|
|
|
|
;; MagickConvolveImageChannel applies a custom convolution kernel to one or
|
|
;; more image channels.
|
|
(defmagick* MagickConvolveImageChannel :
|
|
(w channels kernel) ::
|
|
(w : _MagickWand) (channels : _ChannelType)
|
|
(_ulong = (length kernel)) (kernel : (_sqmatrix-of _double*))
|
|
-> _status)
|
|
|
|
;; MagickCropImage extracts a region of the image.
|
|
(defmagick* MagickCropImage :
|
|
_MagickWand (width : _ulong) (height : _ulong) (x : _long) (y : _long)
|
|
-> _status)
|
|
|
|
;; MagickCycleColormapImage displaces an image's colormap by a given number of
|
|
;; positions. If you cycle the colormap a number of times you can produce a
|
|
;; psychodelic effect.
|
|
(defmagick* MagickCycleColormapImage :
|
|
_MagickWand (displace : _long) -> _status)
|
|
|
|
;; MagickDeconstructImages compares each image with the next in a sequence and
|
|
;; returns the maximum bounding region of any pixel differences it discovers.
|
|
(defmagick* MagickDeconstructImages :
|
|
_MagickWand -> _MagickWand)
|
|
|
|
;; MagickDescribeImage describes an image by printing its attributes to the
|
|
;; file. Attributes include the image width, height, size, and others.
|
|
(defmagick* MagickDescribeImage :
|
|
_MagickWand -> _string)
|
|
|
|
;; MagickDespeckleImage reduces the speckle noise in an image while perserving
|
|
;; the edges of the original image.
|
|
(defmagick* MagickDespeckleImage :
|
|
_MagickWand -> _status)
|
|
|
|
;; MagickDisplayImage displays an image.
|
|
(defmagick* MagickDisplayImage :
|
|
(w . server) ::
|
|
(w : _MagickWand) (_string = (and (pair? server) (car server))) -> _status)
|
|
|
|
;; MagickDisplayImages displays an image or image sequence.
|
|
(defmagick* MagickDisplayImages :
|
|
(w . server) ::
|
|
(w : _MagickWand) (_string = (and (pair? server) (car server))) -> _status)
|
|
|
|
;; MagickDrawImage draw an image the specified number of degrees.
|
|
(defmagick* MagickDrawImage :
|
|
_MagickWand _DrawingWand -> _status)
|
|
|
|
;; MagickEdgeImage enhance edges within the image with a convolution filter of
|
|
;; the given radius. Use a radius of 0 and MagickEdgeImage selects a
|
|
;; suitable radius for you.
|
|
(defmagick* MagickEdgeImage :
|
|
_MagickWand (radius : _double*) -> _status)
|
|
|
|
;; MagickEmbossImage returns a grayscale image with a three-dimensional effect.
|
|
;; We convolve the image with a Gaussian operator of the given radius and
|
|
;; standard deviation (sigma). For reasonable results, radius should be larger
|
|
;; than sigma. Use a radius of 0 and MagickEmbossImage selects a suitable
|
|
;; radius for you.
|
|
(defmagick* MagickEmbossImage :
|
|
_MagickWand (radius : _double*) (sigma : _double*) -> _status)
|
|
|
|
;; MagickEnhanceImage applies a digital filter that improves the quality of a
|
|
;; noisy image.
|
|
(defmagick* MagickEnhanceImage :
|
|
_MagickWand -> _status)
|
|
|
|
;; MagickEqualizeImage equalizes the image histogram.
|
|
(defmagick* MagickEqualizeImage :
|
|
_MagickWand -> _status)
|
|
|
|
;; Use MagickEvaluateImage to apply an arithmetic, relational, or logical
|
|
;; operator to an image. These operations can be used to lighten or darken an
|
|
;; image, to increase or decrease contrast in an image, or to produce the
|
|
;; "negative" of an image.
|
|
(defmagick* MagickEvaluateImage :
|
|
_MagickWand _MagickEvaluateOperator (const : _double*) -> _status)
|
|
|
|
;; Use MagickEvaluateImageChannel to apply an arithmetic, relational, or
|
|
;; logical operator to an image. These operations can be used to lighten or
|
|
;; darken an image, to increase or decrease contrast in an image, or to produce
|
|
;; the "negative" of an image.
|
|
(defmagick* MagickEvaluateImageChannel :
|
|
_MagickWand _ChannelType _MagickEvaluateOperator (const : _double*)
|
|
-> _status)
|
|
|
|
;; MagickFlattenImages merges a sequence of images. This is useful for
|
|
;; combining Photoshop layers into a single image.
|
|
(defmagick* MagickFlattenImages :
|
|
_MagickWand -> _MagickWand)
|
|
|
|
;; MagickFlipImage creates a vertical mirror image by reflecting the pixels
|
|
;; around the central x-axis.
|
|
(defmagick* MagickFlipImage :
|
|
_MagickWand -> _status)
|
|
|
|
;; MagickFlopImage creates a horizontal mirror image by reflecting the pixels
|
|
;; around the central y-axis.
|
|
(defmagick* MagickFlopImage :
|
|
_MagickWand -> _status)
|
|
|
|
;; MagickFrameImage adds a simulated three-dimensional border around the image.
|
|
;; The width and height specify the border width of the vertical and horizontal
|
|
;; sides of the frame. The inner and outer bevels indicate the width of the
|
|
;; inner and outer shadows of the frame.
|
|
(defmagick* MagickFrameImage :
|
|
_MagickWand (matte : _PixelWand)
|
|
(width : _ulong) (height : _ulong)
|
|
(inner-bevel : _long) (outer-bevel : _long)
|
|
-> _status)
|
|
|
|
;; MagickFxImage evaluate expression for each pixel in the image.
|
|
(defmagick* MagickFxImage :
|
|
_MagickWand (expr : _string) -> _MagickWand)
|
|
|
|
;; MagickFxImageChannel evaluate expression for each pixel in the specified
|
|
;; channel.
|
|
(defmagick* MagickFxImageChannel :
|
|
_MagickWand _ChannelType (expr : _string) -> _MagickWand)
|
|
|
|
;; Use MagickGammaImage to gamma-correct an image. The same image viewed on
|
|
;; different devices will have perceptual differences in the way the image's
|
|
;; intensities are represented on the screen. Specify individual gamma levels
|
|
;; for the red, green, and blue channels, or adjust all three with the gamma
|
|
;; parameter. Values typically range from 0.8 to 2.3. You can also reduce the
|
|
;; influence of a particular channel with a gamma value of 0.
|
|
(defmagick* MagickGammaImage :
|
|
_MagickWand (gamma : _double*) -> _status)
|
|
|
|
;; Use MagickGammaImageChannel to gamma-correct a particular image channel.
|
|
;; The same image viewed on different devices will have perceptual differences
|
|
;; in the way the image's intensities are represented on the screen. Specify
|
|
;; individual gamma levels for the red, green, and blue channels, or adjust all
|
|
;; three with the gamma parameter. Values typically range from 0.8 to 2.3.
|
|
(defmagick* MagickGammaImageChannel :
|
|
_MagickWand _ChannelType (gamma : _double*) -> _status)
|
|
|
|
;; MagickGaussianBlurImage blurs an image. We convolve the image with a
|
|
;; Gaussian operator of the given radius and standard deviation (sigma). For
|
|
;; reasonable results, the radius should be larger than sigma. Use a radius of
|
|
;; 0 and MagickGaussianBlurImage selects a suitable radius for you.
|
|
(defmagick* MagickGaussianBlurImage :
|
|
_MagickWand (radius : _double*) (sigma : _double*) -> _status)
|
|
|
|
;; MagickGaussianBlurImageChannel blurs one or more image channels. We
|
|
;; convolve the image cnannel with a Gaussian operator of the given radius and
|
|
;; standard deviation (sigma). For reasonable results, the radius should be
|
|
;; larger than sigma. Use a radius of 0 and MagickGaussianBlurImageChannel
|
|
;; selects a suitable radius for you.
|
|
(defmagick* MagickGaussianBlurImageChannel :
|
|
_MagickWand _ChannelType (radius : _double*) (sigma : _double*) -> _status)
|
|
|
|
;; MagickGetCopyright returns the ImageMagick API copyright as a string.
|
|
(defmagick* MagickGetCopyright :
|
|
-> _string)
|
|
|
|
;; MagickGetFilename returns the filename associated with an image sequence.
|
|
(defmagick* MagickGetFilename :
|
|
_MagickWand -> _file)
|
|
|
|
;; MagickGetHomeURL returns the ImageMagick home URL.
|
|
(defmagick* MagickGetHomeURL :
|
|
-> _string)
|
|
|
|
;; MagickGetImage gets the image at the current image index.
|
|
(defmagick* MagickGetImage :
|
|
_MagickWand -> _MagickWand)
|
|
|
|
;; MagickGetImageBackgroundColor returns the image background color.
|
|
(defmagick* MagickGetImageBackgroundColor :
|
|
_MagickWand (c : _PixelWand = (NewPixelWand)) -> _status -> c)
|
|
|
|
;; MagickGetImageBluePrimary returns the chromaticy blue primary point for the
|
|
;; image.
|
|
(defmagick* MagickGetImageBluePrimary :
|
|
_MagickWand (x : (_ptr o _double*)) (y : (_ptr o _double*)) -> _status
|
|
-> (list x y))
|
|
|
|
;; MagickGetImageBorderColor returns the image border color.
|
|
(defmagick* MagickGetImageBorderColor :
|
|
_MagickWand (c : _PixelWand = (NewPixelWand)) -> _status -> c)
|
|
|
|
;; MagickGetImageChannelDepth gets the depth for a particular image channel.
|
|
(defmagick* MagickGetImageChannelDepth :
|
|
_MagickWand _ChannelType -> _ulong)
|
|
|
|
;; MagickGetImageChannelExtrema gets the extrema for one or more image
|
|
;; channels.
|
|
(defmagick* MagickGetImageChannelExtrema :
|
|
_MagickWand _ChannelType (min : (_ptr o _ulong)) (max : (_ptr o _ulong))
|
|
-> _status
|
|
-> (list min max))
|
|
|
|
;; MagickGetImageChannelMean gets the mean and standard deviation of one or
|
|
;; more image channels.
|
|
(defmagick* MagickGetImageChannelMean :
|
|
_MagickWand _ChannelType
|
|
(mean : (_ptr o _double*)) (standard-deviation : (_ptr o _double*))
|
|
-> _status
|
|
-> (list mean standard-deviation))
|
|
|
|
;; MagickGetImageColormapColor returns the color of the specified colormap
|
|
;; index.
|
|
(defmagick* MagickGetImageColormapColor :
|
|
_MagickWand (colormap-index : _ulong) (c : _PixelWand = (NewPixelWand))
|
|
-> _status -> c)
|
|
|
|
;; MagickGetImageColors gets the number of unique colors in the image.
|
|
(defmagick* MagickGetImageColors :
|
|
_MagickWand -> _ulong)
|
|
|
|
;; MagickGetImageColorspace gets the image colorspace.
|
|
(defmagick* MagickGetImageColorspace :
|
|
_MagickWand -> _ColorspaceType)
|
|
|
|
;; MagickGetImageCompose returns the composite operator associated with the
|
|
;; image.
|
|
(defmagick* MagickGetImageCompose :
|
|
_MagickWand -> _CompositeOperator)
|
|
|
|
;; MagickGetImageCompression gets the image compression.
|
|
(defmagick* MagickGetImageCompression :
|
|
_MagickWand -> _CompressionType)
|
|
|
|
;; MagickGetImageCompressionQuality gets the image compression quality.
|
|
(defmagick* MagickGetImageCompressionQuality :
|
|
_MagickWand -> _ulong)
|
|
|
|
;; MagickGetImageDelay gets the image delay.
|
|
(defmagick* MagickGetImageDelay :
|
|
_MagickWand -> _ulong)
|
|
|
|
;; MagickGetImageDepth gets the image depth.
|
|
(defmagick* MagickGetImageDepth :
|
|
_MagickWand -> _ulong)
|
|
|
|
;; MagickGetImageDispose gets the image disposal method.
|
|
(defmagick* MagickGetImageDispose :
|
|
_MagickWand -> _DisposeType)
|
|
|
|
;; MagickGetImageExtrema gets the extrema for the image.
|
|
(defmagick* MagickGetImageExtrema :
|
|
_MagickWand (min : (_ptr o _ulong)) (max : (_ptr o _ulong)) -> _status
|
|
-> (list min max))
|
|
|
|
;; MagickGetImageFilename returns the filename of a particular image in a
|
|
;; sequence.
|
|
(defmagick* MagickGetImageFilename :
|
|
_MagickWand -> _string)
|
|
|
|
;; MagickGetImageFormat returns the format of a particular image in a sequence.
|
|
(defmagick* MagickGetImageFormat :
|
|
_MagickWand -> _string)
|
|
|
|
;; MagickGetImageGamma gets the image gamma.
|
|
(defmagick* MagickGetImageGamma :
|
|
_MagickWand -> _double*)
|
|
|
|
;; MagickGetImageGreenPrimary returns the chromaticy green primary point.
|
|
(defmagick* MagickGetImageGreenPrimary :
|
|
_MagickWand (x : (_ptr o _double*)) (y : (_ptr o _double*)) -> _status
|
|
-> (list x y))
|
|
|
|
;; MagickGetImageHeight returns the image height.
|
|
(defmagick* MagickGetImageHeight :
|
|
_MagickWand -> _ulong)
|
|
|
|
;; MagickGetImageHistogram returns the image histogram as an array of PixelWand
|
|
;; wands.
|
|
(defmagick* MagickGetImageHistogram :
|
|
_MagickWand (len : (_ptr o _ulong)) -> (_list o _PixelWand len))
|
|
|
|
;; MagickGetImageIndex returns the index of the current image.
|
|
(defmagick* MagickGetImageIndex :
|
|
_MagickWand -> _long)
|
|
|
|
;; MagickGetImageInterlaceScheme gets the image interlace scheme.
|
|
(defmagick* MagickGetImageInterlaceScheme :
|
|
_MagickWand -> _InterlaceType)
|
|
|
|
;; MagickGetImageIterations gets the image iterations.
|
|
(defmagick* MagickGetImageIterations :
|
|
_MagickWand -> _ulong)
|
|
|
|
;; MagickGetImageMatteColor returns the image matte color.
|
|
(defmagick* MagickGetImageMatteColor :
|
|
_MagickWand (c : _PixelWand = (NewPixelWand)) -> _status -> c)
|
|
|
|
;; MagickGetImagePixels extracts pixel data from an image and returns it to
|
|
;; you. The method returns False on success otherwise True if an error is
|
|
;; encountered. The data is returned as char, short int, int, long, float, or
|
|
;; double in the order specified by map. Suppose you want to extract the first
|
|
;; scanline of a 640x480 image as character data in red-green-blue order:
|
|
;; (MagickGetImagePixels wand 0 0 640 1 "RGB" 'CharPixel)
|
|
;; `map' is a string that reflects the expected ordering of the pixel array.
|
|
;; It can be any combination or order of R = red, G = green, B = blue,
|
|
;; A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
|
|
;; Y = yellow, M = magenta, K = black, I = intensity (for grayscale), P = pad.
|
|
;; Note: the scheme interface uses a list of rows, each a list of values for
|
|
;; each element in the map.
|
|
(defmagick* MagickGetImagePixels :
|
|
_MagickWand (x : _long) (y : _long) (width : _ulong) (height : _ulong)
|
|
(map : _string) (storage-type : _StorageType)
|
|
;; create the block, remember size and type
|
|
(size : _? = (* width height (string-length map)))
|
|
(type : _? = (StorageType->type storage-type))
|
|
(block : _pointer = (malloc size type))
|
|
-> _status
|
|
-> (let loop ([n (sub1 size)] [r '()])
|
|
(if (< n 0)
|
|
(n-split (n-split r (string-length map)) width)
|
|
(loop (sub1 n) (cons (ptr-ref block type n) r)))))
|
|
|
|
;; MagickGetImageProfile returns the named image profile.
|
|
(defmagick* MagickGetImageProfile :
|
|
_MagickWand (profile-name : _string) (len : (_ptr o _ulong))
|
|
-> (_bytes o len))
|
|
|
|
;; MagickGetImageRedPrimary returns the chromaticy red primary point.
|
|
(defmagick* MagickGetImageRedPrimary :
|
|
_MagickWand (x : (_ptr o _double*)) (y : (_ptr o _double*)) -> _status
|
|
-> (list x y))
|
|
|
|
;; MagickGetImageRenderingIntent gets the image rendering intent.
|
|
(defmagick* MagickGetImageRenderingIntent :
|
|
_MagickWand -> _RenderingIntent)
|
|
|
|
;; MagickGetImageSignature generates an SHA-256 message digest for the image
|
|
;; pixel stream.
|
|
(defmagick* MagickGetImageSignature :
|
|
_MagickWand -> _string)
|
|
|
|
;; MagickGetImageSize returns the image size.
|
|
(defmagick* MagickGetImageSize :
|
|
_MagickWand -> _MagickSizeType)
|
|
|
|
;; MagickGetImageType gets the image type.
|
|
(defmagick* MagickGetImageType :
|
|
_MagickWand -> _ImageType)
|
|
|
|
;; MagickGetImageUnits gets the image units of resolution.
|
|
(defmagick* MagickGetImageUnits :
|
|
_MagickWand -> _ResolutionType)
|
|
|
|
;; MagickGetImageVirtualPixelMethod returns the virtual pixel method for the
|
|
;; sepcified image.
|
|
(defmagick* MagickGetImageVirtualPixelMethod :
|
|
_MagickWand -> _VirtualPixelMethod)
|
|
|
|
;; MagickGetImageWhitePoint returns the chromaticy white point.
|
|
(defmagick* MagickGetImageWhitePoint :
|
|
_MagickWand (x : (_ptr o _double*)) (y : (_ptr o _double*)) -> _status
|
|
-> (list x y))
|
|
|
|
;; MagickGetImageWidth returns the image width.
|
|
(defmagick* MagickGetImageWidth :
|
|
_MagickWand -> _ulong)
|
|
|
|
;; MagickGetImageResolution gets the image X & Y resolution.
|
|
(defmagick* MagickGetImageResolution :
|
|
_MagickWand (res-x : (_ptr o _double*)) (res-y : (_ptr o _double*))
|
|
-> _status
|
|
-> (list res-x res-y))
|
|
|
|
;; MagickGetNumberImages returns the number of images associated with a magick
|
|
;; wand.
|
|
(defmagick* MagickGetNumberImages :
|
|
_MagickWand -> _ulong)
|
|
|
|
;; MagickGetPackageName returns the ImageMagick package name.
|
|
(defmagick* MagickGetPackageName :
|
|
-> _string)
|
|
|
|
;; MagickGetQuantumDepth returns the ImageMagick quantum depth.
|
|
(defmagick* MagickGetQuantumDepth :
|
|
(q : (_ptr o _ulong)) -> _string -> q)
|
|
|
|
;; MagickGetReleaseDate returns the ImageMagick release date.
|
|
(defmagick* MagickGetReleaseDate :
|
|
-> _string)
|
|
|
|
;; MagickGetResourceLimit returns the specified resource in megabytes.
|
|
(defmagick* MagickGetResourceLimit :
|
|
_ResourceType -> _ulong)
|
|
|
|
;; MagickGetSamplingFactors gets the horizontal and vertical sampling factor.
|
|
(defmagick* MagickGetSamplingFactors :
|
|
_MagickWand (len : (_ptr o _ulong)) -> (_list o _double* len))
|
|
|
|
;; MagickGetSize returns the size associated with the magick wand.
|
|
(defmagick* MagickGetSize :
|
|
_MagickWand (width : (_ptr o _ulong)) (height : (_ptr o _ulong)) -> _status
|
|
-> (list width height))
|
|
|
|
;; MagickGetVersion returns the ImageMagick API version as a string and as a
|
|
;; number.
|
|
(defmagick* MagickGetVersion :
|
|
(v : (_ptr o _ulong)) -> (s : _string) -> (list v s))
|
|
|
|
;; MagickHasNextImage returns True if the wand has more images when traversing
|
|
;; the list in the forward direction
|
|
(defmagick* MagickHasNextImage :
|
|
_MagickWand -> _bool)
|
|
|
|
;; MagickHasPreviousImage returns True if the wand has more images when
|
|
;; traversing the list in the reverse direction
|
|
(defmagick* MagickHasPreviousImage :
|
|
_MagickWand -> _bool)
|
|
|
|
;; MagickImplodeImage creates a new image that is a copy of an existing one
|
|
;; with the image pixels "implode" by the specified percentage.
|
|
(defmagick* MagickImplodeImage :
|
|
_MagickWand (amount : _double*) -> _status)
|
|
|
|
;; MagickLabelImage adds a label to your image.
|
|
(defmagick* MagickLabelImage :
|
|
_MagickWand (label : _string) -> _status)
|
|
|
|
;; MagickLevelImage adjusts the levels of an image by scaling the colors
|
|
;; falling between specified white and black points to the full available
|
|
;; quantum range. The parameters provided represent the black, mid, and white
|
|
;; points. The black point specifies the darkest color in the image. Colors
|
|
;; darker than the black point are set to zero. Mid point specifies a gamma
|
|
;; correction to apply to the image. White point specifies the lightest color
|
|
;; in the image. Colors brighter than the white point are set to the maximum
|
|
;; quantum value.
|
|
(defmagick* MagickLevelImage :
|
|
_MagickWand
|
|
(black-point : _double*) (gamma : _double*) (white-point : _double*)
|
|
-> _status)
|
|
|
|
;; MagickLevelImageChannel adjusts the levels of the specified channel of the
|
|
;; reference image by scaling the colors falling between specified white and
|
|
;; black points to the full available quantum range. The parameters provided
|
|
;; represent the black, mid, and white points. The black point specifies the
|
|
;; darkest color in the image. Colors darker than the black point are set to
|
|
;; zero. Mid point specifies a gamma correction to apply to the image. White
|
|
;; point specifies the lightest color in the image. Colors brighter than the
|
|
;; white point are set to the maximum quantum value.
|
|
(defmagick* MagickLevelImageChannel :
|
|
_MagickWand _ChannelType
|
|
(black-point : _double*) (gamma : _double*) (white-point : _double*)
|
|
-> _status)
|
|
|
|
;; MagickMagnifyImage is a convenience method that scales an image
|
|
;; proportionally to twice its original size.
|
|
(defmagick* MagickMagnifyImage :
|
|
_MagickWand -> _status)
|
|
|
|
;; MagickMapImage replaces the colors of an image with the closest color from a
|
|
;; reference image.
|
|
(defmagick* MagickMapImage :
|
|
_MagickWand (mapping : _MagickWand) (dither? : _bool) -> _status)
|
|
|
|
;; MagickMatteFloodfillImage changes the transparency value of any pixel that
|
|
;; matches target and is an immediate neighbor. If the method
|
|
;; FillToBorderMethod is specified, the transparency value is changed for any
|
|
;; neighbor pixel that does not match the bordercolor member of image.
|
|
(defmagick* MagickMatteFloodfillImage :
|
|
_MagickWand
|
|
(opacity : _Quantum) (fuzz : _double*) (border : _PixelWand)
|
|
(x : _long) (y : _long)
|
|
-> _status)
|
|
|
|
;; MagickMedianFilterImage applies a digital filter that improves the quality
|
|
;; of a noisy image. Each pixel is replaced by the median in a set of
|
|
;; neighboring pixels as defined by radius.
|
|
(defmagick* MagickMedianFilterImage :
|
|
_MagickWand (radius : _double*) -> _status)
|
|
|
|
;; MagickMinifyImage is a convenience method that scales an image
|
|
;; proportionally to one-half its original size
|
|
(defmagick* MagickMinifyImage :
|
|
_MagickWand -> _status)
|
|
|
|
;; MagickModulateImage lets you control the brightness, saturation, and hue of
|
|
;; an image.
|
|
(defmagick* MagickModulateImage :
|
|
_MagickWand (brightness : _double*) (saturation : _double*) (hue : _double*)
|
|
-> _status)
|
|
|
|
;; Use MagickMontageImage to create a composite image by combining several
|
|
;; separate images. The images are tiled on the composite image with the name
|
|
;; of the image optionally appearing just below the individual tile.
|
|
(defmagick* MagickMontageImage :
|
|
_MagickWand _DrawingWand
|
|
(tile-geometry : _string) (thumbnail-geometry : _string)
|
|
_MontageMode (frame-geometry : _string) -> _MagickWand)
|
|
|
|
;; MagickMorphImages method morphs a set of images. Both the image pixels and
|
|
;; size are linearly interpolated to give the appearance of a meta-morphosis
|
|
;; from one image to the next.
|
|
(defmagick* MagickMorphImages :
|
|
_MagickWand (num-of-frames : _ulong) -> _MagickWand)
|
|
|
|
;; MagickMosaicImages inlays an image sequence to form a single coherent
|
|
;; picture. It returns a wand with each image in the sequence composited at
|
|
;; the location defined by the page offset of the image.
|
|
(defmagick* MagickMosaicImages :
|
|
_MagickWand -> _MagickWand)
|
|
|
|
;; MagickMotionBlurImage simulates motion blur. We convolve the image with a
|
|
;; Gaussian operator of the given radius and standard deviation (sigma). For
|
|
;; reasonable results, radius should be larger than sigma. Use a radius of 0
|
|
;; and MagickMotionBlurImage selects a suitable radius for you. Angle gives
|
|
;; the angle of the blurring motion.
|
|
(defmagick* MagickMotionBlurImage :
|
|
_MagickWand (radius : _double*) (sigma : _double*) (angle : _double*)
|
|
-> _status)
|
|
|
|
;; MagickNegateImage negates the colors in the reference image. The Grayscale
|
|
;; option means that only grayscale values within the image are negated.
|
|
(defmagick* MagickNegateImage :
|
|
_MagickWand (gray? : _bool) -> _status)
|
|
|
|
;; MagickNegateImageChannel negates the colors in the specified channel of the
|
|
;; reference image. The Grayscale option means that only grayscale values
|
|
;; within the image are negated. You can also reduce the influence of a
|
|
;; particular channel with a gamma value of 0.
|
|
(defmagick* MagickNegateImageChannel :
|
|
_MagickWand _ChannelType (gray? : _bool) -> _status)
|
|
|
|
;; MagickNextImage associates the next image in the image list with a magick
|
|
;; wand.
|
|
(defmagick* MagickNextImage :
|
|
_MagickWand -> _status)
|
|
|
|
;; MagickNormalizeImage enhances the contrast of a color image by adjusting the
|
|
;; pixels color to span the entire range of colors available
|
|
(defmagick* MagickNormalizeImage :
|
|
_MagickWand -> _status)
|
|
|
|
;; MagickOilPaintImage applies a special effect filter that simulates an oil
|
|
;; painting. Each pixel is replaced by the most frequent color occurring in a
|
|
;; circular region defined by radius.
|
|
(defmagick* MagickOilPaintImage :
|
|
_MagickWand _double* -> _status)
|
|
|
|
;; MagickOpaqueImage changes any pixel that matches color with the color
|
|
;; defined by fill.
|
|
(defmagick* MagickOpaqueImage :
|
|
_MagickWand (target : _PixelWand) (fill : _PixelWand) (fuzz : _double*)
|
|
-> _status)
|
|
|
|
;; MagickPingImage is like MagickReadImage except the only valid information
|
|
;; returned is the image width, height, size, and format. It is designed to
|
|
;; efficiently obtain this information from a file without reading the entire
|
|
;; image sequence into memory.
|
|
(defmagick* MagickPingImage :
|
|
_MagickWand _file -> _status)
|
|
|
|
;; MagickPosterizeImage reduces the image to a limited number of color level.
|
|
(defmagick* MagickPosterizeImage :
|
|
_MagickWand (levels : _ulong) (dither? : _bool) -> _status)
|
|
|
|
;; MagickPreviewImages tiles 9 thumbnails of the specified image with an image
|
|
;; processing operation applied at varying strengths. This is helpful to
|
|
;; quickly pin-point an appropriate parameter for an image processing
|
|
;; operation.
|
|
(defmagick* MagickPreviewImages :
|
|
_MagickWand _PreviewType -> _MagickWand)
|
|
|
|
;; MagickPreviousImage assocates the previous image in an image list with the
|
|
;; magick wand.
|
|
(defmagick* MagickPreviousImage :
|
|
_MagickWand -> _status)
|
|
|
|
;; Use MagickProfileImage to add or remove a ICC, IPTC, or generic profile from
|
|
;; an image. If the profile is #f (NULL), it is removed from the image
|
|
;; otherwise added. Use a name of '*' and a profile of NULL to remove all
|
|
;; profiles from the image.
|
|
(defmagick* MagickProfileImage :
|
|
_MagickWand (profile-name : _string)
|
|
(profile : _bytes) (_ulong = (bytes-length profile))
|
|
-> _status)
|
|
|
|
;; MagickQuantizeImage analyzes the colors within a reference image and chooses
|
|
;; a fixed number of colors to represent the image. The goal of the algorithm
|
|
;; is to minimize the color difference between the input and output image while
|
|
;; minimizing the processing time.
|
|
(defmagick* MagickQuantizeImage :
|
|
_MagickWand (num-colors : _ulong) _ColorspaceType (tree-depth : _ulong)
|
|
(dither? : _bool) (measure-error? : _bool)
|
|
-> _status)
|
|
|
|
;; MagickQuantizeImages analyzes the colors within a sequence of images and
|
|
;; chooses a fixed number of colors to represent the image. The goal of the
|
|
;; algorithm is to minimize the color difference between the input and output
|
|
;; image while minimizing the processing time.
|
|
(defmagick* MagickQuantizeImages :
|
|
_MagickWand
|
|
(num-colors : _ulong) _ColorspaceType (tree-depth : _ulong)
|
|
(dither? : _bool) (measure-error? : _bool)
|
|
-> _status)
|
|
|
|
;; MagickQueryConfigureOptions returns any configure options that match the
|
|
;; specified pattern (e.g. "*" for all). Options include NAME, VERSION,
|
|
;; LIB_VERSION, etc.
|
|
(defmagick* MagickQueryConfigureOptions :
|
|
(pattern : _string) (len : (_ptr o _ulong)) -> (_list o _string len))
|
|
|
|
;; MagickQueryFontMetrics returns a 7 element list representing the following
|
|
;; font metrics: char-width, char-height, ascender, descender, text-width,
|
|
;; text-height, max-horizontal-advance.
|
|
(defmagick* MagickQueryFontMetrics :
|
|
_MagickWand _DrawingWand (text : _string) -> (_list o _double* 7))
|
|
|
|
;; MagickQueryFonts returns any font that match the specified pattern (e.g. "*"
|
|
;; for all).
|
|
(defmagick* MagickQueryFonts :
|
|
(pattern : _string) (len : (_ptr o _ulong)) -> (_list o _string len))
|
|
|
|
;; MagickQueryFormats returns any image formats that match the specified
|
|
;; pattern (e.g. "*" for all).
|
|
(defmagick* MagickQueryFormats :
|
|
(pattern : _string) (len : (_ptr o _ulong)) -> (_list o _string len))
|
|
|
|
;; MagickRadialBlurImage radial blurs an image.
|
|
(defmagick* MagickRadialBlurImage :
|
|
_MagickWand (angle : _double*) -> _status)
|
|
|
|
;; MagickRaiseImage creates a simulated three-dimensional button-like effect by
|
|
;; lightening and darkening the edges of the image. Members width and height
|
|
;; of raise_info define the width of the vertical and horizontal edge of the
|
|
;; effect.
|
|
(defmagick* MagickRaiseImage :
|
|
_MagickWand
|
|
(width : _ulong) (height : _ulong) (x : _long) (y : _long) (raise? : _bool)
|
|
-> _status)
|
|
|
|
;; MagickReadImage reads an image or image sequence.
|
|
;; Extended: the wand argument is optional -- will be made and returned if not
|
|
;; given.
|
|
(defmagick* MagickReadImage :
|
|
(arg . args) ::
|
|
(w : _MagickWand = (if (null? args) (NewMagickWand) arg))
|
|
(_file = (if (null? args) arg (car args)))
|
|
-> _status
|
|
-> (if (null? args) w (void)))
|
|
|
|
;; MagickReadImageBlob reads an image or image sequence from a blob.
|
|
(defmagick* MagickReadImageBlob :
|
|
_MagickWand (blob : _bytes) (_ulong = (bytes-length blob)) -> _status)
|
|
|
|
;; MagickReadImageFile reads an image or image sequence from an open file
|
|
;; descriptor.
|
|
(defmagick* MagickReadImageFile :
|
|
_MagickWand (FILE* : _pointer) -> _status)
|
|
|
|
;; MagickReduceNoiseImage smooths the contours of an image while still
|
|
;; preserving edge information. The algorithm works by replacing each pixel
|
|
;; with its neighbor closest in value. A neighbor is defined by radius. Use a
|
|
;; radius of 0 and MagickReduceNoiseImage selects a suitable radius for you.
|
|
(defmagick* MagickReduceNoiseImage :
|
|
_MagickWand (radius : _double*) -> _status)
|
|
|
|
;; MagickRelinquishMemory relinquishes memory resources returned by such
|
|
;; methods as MagickDescribeImage, MagickGetException, etc.
|
|
;; Looks like this is not needed with a GC (tried it with the result of
|
|
;; MagickDescribeImage many times, got an error).
|
|
;; (defmagick* MagickRelinquishMemory :
|
|
;; _pointer -> _status)
|
|
|
|
;; MagickRemoveImage removes an image from the image list.
|
|
(defmagick* MagickRemoveImage :
|
|
_MagickWand -> _status)
|
|
|
|
;; MagickRemoveImageProfile removes the named image profile and returns it.
|
|
(defmagick* MagickRemoveImageProfile :
|
|
_MagickWand (profile-name : _string) (len : (_ptr o _ulong))
|
|
-> (_bytes o len))
|
|
|
|
;; MagickResampleImage resample image to desired resolution. Most of the
|
|
;; filters are FIR (finite impulse response), however, Bessel, Gaussian, and
|
|
;; Sinc are IIR (infinite impulse response). Bessel and Sinc are windowed
|
|
;; (brought down to zero) with the Blackman filter.
|
|
(defmagick* MagickResampleImage :
|
|
_MagickWand
|
|
(x-res : _double*) (y-res : _double*) _FilterTypes (blur-factor : _double*)
|
|
-> _status)
|
|
|
|
;; MagickResetIterator resets the wand iterator. Use it in conjunction with
|
|
;; MagickNextImage to iterate over all the images in a wand container.
|
|
(defmagick* MagickResetIterator :
|
|
_MagickWand -> _void)
|
|
|
|
;; MagickResizeImage scales an image to the desired dimensions with some
|
|
;; filter. Most of the filters are FIR (finite impulse response), however,
|
|
;; Bessel, Gaussian, and Sinc are IIR (infinite impulse response). Bessel and
|
|
;; Sinc are windowed (brought down to zero) with the Blackman filter.
|
|
(defmagick* MagickResizeImage :
|
|
_MagickWand
|
|
(width : _ulong) (height : _ulong) _FilterTypes (blur-factor : _double*)
|
|
-> _status)
|
|
|
|
;; MagickRollImage offsets an image as defined by x_offset and y_offset.
|
|
(defmagick* MagickRollImage :
|
|
_MagickWand (x-offset : _long) (y-offset : _long) -> _status)
|
|
|
|
;; MagickRotateImage rotates an image the specified number of degrees. Empty
|
|
;; triangles left over from rotating the image are filled with the background
|
|
;; color.
|
|
(defmagick* MagickRotateImage :
|
|
_MagickWand (background : _PixelWand) (degrees : _double*) -> _status)
|
|
|
|
;; MagickSampleImage scales an image to the desired dimensions with pixel
|
|
;; sampling. Unlike other scaling methods, this method does not introduce any
|
|
;; additional color into the scaled image.
|
|
(defmagick* MagickSampleImage :
|
|
_MagickWand (width : _ulong) (height : _ulong) -> _status)
|
|
|
|
;; MagickScaleImage scales the size of an image to the given dimensions.
|
|
(defmagick* MagickScaleImage :
|
|
_MagickWand (width : _ulong) (height : _ulong) -> _status)
|
|
|
|
;; MagickSeparateImageChannel separates a channel from the image and returns a
|
|
;; grayscale image. A channel is a particular color component of each pixel in
|
|
;; the image.
|
|
(defmagick* MagickSeparateImageChannel :
|
|
_MagickWand _ChannelType -> _status)
|
|
|
|
;; MagickSetFilename sets the filename before you read or write an image file.
|
|
(defmagick* MagickSetFilename :
|
|
_MagickWand _file -> _status)
|
|
|
|
;; MagickSetImage replaces the last image returned by MagickSetImageIndex,
|
|
;; MagickNextImage, MagickPreviousImage with the images from the specified
|
|
;; wand.
|
|
(defmagick* MagickSetImage :
|
|
_MagickWand (set-wand : _MagickWand) -> _status)
|
|
|
|
;; MagickSetImageBackgroundColor sets the image background color.
|
|
(defmagick* MagickSetImageBackgroundColor :
|
|
_MagickWand (background : _PixelWand) -> _status)
|
|
|
|
;; MagickSetImageBluePrimary sets the image chromaticity blue primary point.
|
|
(defmagick* MagickSetImageBluePrimary :
|
|
_MagickWand (x : _double*) (y : _double*) -> _status)
|
|
|
|
;; MagickSetImageBorderColor sets the image border color.
|
|
(defmagick* MagickSetImageBorderColor :
|
|
_MagickWand (border-color : _PixelWand) -> _status)
|
|
|
|
;; MagickSetImageChannelDepth sets the depth of a particular image channel.
|
|
(defmagick* MagickSetImageChannelDepth :
|
|
_MagickWand _ChannelType (depth : _ulong) -> _status)
|
|
|
|
;; MagickSetImageColormapColor sets the color of the specified colormap index.
|
|
(defmagick* MagickSetImageColormapColor :
|
|
_MagickWand (index : _ulong) _PixelWand -> _status)
|
|
|
|
;; MagickSetImageColorspace sets the image colorspace.
|
|
(defmagick* MagickSetImageColorspace :
|
|
_MagickWand _ColorspaceType -> _status)
|
|
|
|
;; MagickSetImageCompose sets the image composite operator, useful for
|
|
;; specifying how to composite the image thumbnail when using the
|
|
;; MagickMontageImage method.
|
|
(defmagick* MagickSetImageCompose :
|
|
_MagickWand _CompositeOperator -> _status)
|
|
|
|
;; MagickSetImageCompression sets the image compression.
|
|
(defmagick* MagickSetImageCompression :
|
|
_MagickWand _CompressionType -> _status)
|
|
|
|
;; MagickSetImageCompressionQuality sets the image compression quality.
|
|
(defmagick* MagickSetImageCompressionQuality :
|
|
_MagickWand (quality : _ulong) -> _status)
|
|
|
|
;; MagickSetImageDelay sets the image delay.
|
|
(defmagick* MagickSetImageDelay :
|
|
_MagickWand (delay : _ulong) -> _status)
|
|
|
|
;; MagickSetImageDepth sets the image depth.
|
|
(defmagick* MagickSetImageDepth :
|
|
_MagickWand (depth : _ulong) -> _status)
|
|
|
|
;; MagickSetImageDispose sets the image disposal method.
|
|
(defmagick* MagickSetImageDispose :
|
|
_MagickWand _DisposeType -> _status)
|
|
|
|
;; MagickSetImageFilename sets the filename of a particular image in a
|
|
;; sequence.
|
|
(defmagick* MagickSetImageFilename :
|
|
_MagickWand _file -> _status)
|
|
|
|
;; MagickSetImageGamma sets the image gamma.
|
|
(defmagick* MagickSetImageGamma :
|
|
_MagickWand (gamma : _double*) -> _status)
|
|
|
|
;; MagickSetImageGreenPrimary sets the image chromaticity green primary point.
|
|
(defmagick* MagickSetImageGreenPrimary :
|
|
_MagickWand (y : _double*) (x : _double*) -> _status)
|
|
|
|
;; MagickSetImageIndex replaces the last image returned by MagickSetImageIndex,
|
|
;; MagickNextImage, MagickPreviousImage with the images from the specified
|
|
;; wand.
|
|
(defmagick* MagickSetImageIndex :
|
|
_MagickWand (index : _long) -> _status)
|
|
|
|
;; MagickSetImageInterlaceScheme sets the image interlace scheme.
|
|
(defmagick* MagickSetImageInterlaceScheme :
|
|
_MagickWand _InterlaceType -> _status)
|
|
|
|
;; MagickSetImageIterations sets the image iterations.
|
|
(defmagick* MagickSetImageIterations :
|
|
_MagickWand (iterations : _ulong) -> _status)
|
|
|
|
;; MagickSetImageMatteColor sets the image matte color.
|
|
(defmagick* MagickSetImageMatteColor :
|
|
_MagickWand (matte : _PixelWand) -> _status)
|
|
|
|
;; MagickSetImageOption associates one or options with a particular image
|
|
;; format (e.g. (MagickSetImageOption wand "jpeg" "perserve" "yes")).
|
|
(defmagick* MagickSetImageOption :
|
|
_MagickWand (format : _string) (key : _string) (value : _string) -> _status)
|
|
|
|
;; MagickSetImagePixels accepts pixel data and stores it in the image at the
|
|
;; location you specify. The method returns False on success otherwise True if
|
|
;; an error is encountered. The pixel data can be either char, short int, int,
|
|
;; long, float, or double in the order specified by map. Suppose your want
|
|
;; want to upload the first scanline of a 640x480 image from character data in
|
|
;; red-green-blue order:
|
|
;; (MagickSetImagePixels wand 0 0 640 1 "RGB" 'CharPixel pixels)
|
|
;; `map' is a string that reflects the expected ordering of the pixel array.
|
|
;; It can be any combination or order of R = red, G = green, B = blue,
|
|
;; A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
|
|
;; Y = yellow, M = magenta, K = black, I = intensity (for grayscale), P = pad.
|
|
;; Note: the scheme interface uses a list of rows, each a list of values for
|
|
;; each element in the map. Also, the map here should not have the type
|
|
;; character as in the MagickWand API (it is a documentation bug), and there is
|
|
;; no need for width and height too.
|
|
(defmagick* MagickSetImagePixels :
|
|
(w x y map storage-type matrix) ::
|
|
(w : _MagickWand) (x : _long) (y : _long)
|
|
(width : _ulong = (length (car matrix))) (height : _ulong = (length matrix))
|
|
(map : _string) (storage-type : _StorageType)
|
|
(_pointer = (let* ([size (* width height (string-length map))]
|
|
[type (StorageType->type storage-type)]
|
|
[block (malloc size type)])
|
|
(let loop ([m matrix] [n 0])
|
|
(cond [(null? m) n]
|
|
[(pair? m) (loop (cdr m) (loop (car m) n))]
|
|
[else (ptr-set! block type n m) (add1 n)]))
|
|
block))
|
|
-> _status)
|
|
|
|
;; MagickSetImageProfile adds a named profile to the magick wand. If a profile
|
|
;; with the same name already exists, it is replaced. This method differs from
|
|
;; the MagickProfileImage method in that it does not apply any CMS color
|
|
;; profiles.
|
|
(defmagick* MagickSetImageProfile :
|
|
_MagickWand (profile-name : _string)
|
|
(profile : _bytes) (_ulong = (bytes-length profile))
|
|
-> _status)
|
|
|
|
;; MagickSetImageRedPrimary sets the image chromaticity red primary point.
|
|
(defmagick* MagickSetImageRedPrimary :
|
|
_MagickWand (x : _double*) (y : _double*) -> _status)
|
|
|
|
;; MagickSetImageRenderingIntent sets the image rendering intent.
|
|
(defmagick* MagickSetImageRenderingIntent :
|
|
_MagickWand _RenderingIntent -> _status)
|
|
|
|
;; MagickSetImageResolution sets the image resolution.
|
|
(defmagick* MagickSetImageResolution :
|
|
_MagickWand (res-x : _double*) (res-y : _double*) -> _status)
|
|
|
|
;; MagickSetImageScene sets the image scene.
|
|
(defmagick* MagickSetImageScene :
|
|
_MagickWand (schene-number : _ulong) -> _status)
|
|
|
|
;; MagickSetImageType sets the image type.
|
|
(defmagick* MagickSetImageType :
|
|
_MagickWand _ImageType -> _status)
|
|
|
|
;; MagickSetImageUnits sets the image units of resolution.
|
|
(defmagick* MagickSetImageUnits :
|
|
_MagickWand _ResolutionType -> _status)
|
|
|
|
;; MagickSetImageVirtualPixelMethod sets the image virtual pixel method.
|
|
(defmagick* MagickSetImageVirtualPixelMethod :
|
|
_MagickWand _VirtualPixelMethod -> _status)
|
|
|
|
;; MagickSetImageWhitePoint sets the image chromaticity white point.
|
|
(defmagick* MagickSetImageWhitePoint :
|
|
_MagickWand (x : _double*) (y : _double*) -> _status)
|
|
|
|
;; MagickSetInterlaceScheme sets the image compression.
|
|
(defmagick* MagickSetInterlaceScheme :
|
|
_MagickWand _InterlaceType -> _status)
|
|
|
|
;; MagickSetPassphrase sets the passphrase.
|
|
(defmagick* MagickSetPassphrase :
|
|
_MagickWand (passphrase : _string) -> _status)
|
|
|
|
;; MagickSetResourceLimit sets the limit for a particular resource in
|
|
;; megabytes.
|
|
(defmagick* MagickSetResourceLimit :
|
|
_ResourceType (limit : _ulong) -> _status)
|
|
|
|
;; MagickSetSamplingFactors sets the image sampling factors.
|
|
(defmagick* MagickSetSamplingFactors :
|
|
(w factors) ::
|
|
(w : _MagickWand) (_ulong = (length factors)) (factors : (_list i _double*))
|
|
-> _status)
|
|
|
|
;; MagickSetSize sets the size of the magick wand. Set it before you read a
|
|
;; raw image format such as RGB, GRAY, or CMYK.
|
|
(defmagick* MagickSetSize :
|
|
_MagickWand (width : _ulong) (height : _ulong) -> _status)
|
|
|
|
;; MagickSharpenImage sharpens an image. We convolve the image with a Gaussian
|
|
;; operator of the given radius and standard deviation (sigma). For reasonable
|
|
;; results, the radius should be larger than sigma. Use a radius of 0 and
|
|
;; SharpenImage selects a suitable radius for you.
|
|
(defmagick* MagickSharpenImage :
|
|
_MagickWand (radius : _double*) (sigma : _double*) -> _status)
|
|
|
|
;; MagickSharpenImageChannel sharpens one or more image channels. We convolve
|
|
;; the image cnannel with a gaussian operator of the given radius and standard
|
|
;; deviation (sigma). For reasonable results, the radius should be larger than
|
|
;; sigma. Use a radius of 0 and GaussinSharpenImageChannel selects a suitable
|
|
;; radius for you.
|
|
(defmagick* MagickSharpenImageChannel :
|
|
_MagickWand _ChannelType (radius : _double*) (sigma : _double*) -> _status)
|
|
|
|
;; MagickShaveImage shaves pixels from the image edges. It allocates the
|
|
;; memory necessary for the new Image structure and returns a pointer to the
|
|
;; new image.
|
|
(defmagick* MagickShaveImage :
|
|
_MagickWand (width : _ulong) (height : _ulong) -> _status)
|
|
|
|
;; MagickShearImage slides one edge of an image along the X or Y axis, creating
|
|
;; a parallelogram. An X direction shear slides an edge along the X axis,
|
|
;; while a Y direction shear slides an edge along the Y axis. The amount of
|
|
;; the shear is controlled by a shear angle. For X direction shears, x_shear
|
|
;; is measured relative to the Y axis, and similarly, for Y direction shears
|
|
;; y_shear is measured relative to the X axis. Empty triangles left over from
|
|
;; shearing the image are filled with the background color.
|
|
(defmagick* MagickShearImage :
|
|
_MagickWand (background : _PixelWand)
|
|
(x-shear : _double*) (y-shear : _double*)
|
|
-> _status)
|
|
|
|
;; MagickSolarizeImage applies a special effect to the image, similar to the
|
|
;; effect achieved in a photo darkroom by selectively exposing areas of photo
|
|
;; sensitive paper to light. Threshold ranges from 0 to MaxRGB and is a
|
|
;; measure of the extent of the solarization.
|
|
(defmagick* MagickSolarizeImage :
|
|
_MagickWand (threshold : _double*) -> _status)
|
|
|
|
;; MagickSpliceImage splices a solid color into the image.
|
|
(defmagick* MagickSpliceImage :
|
|
_MagickWand (width : _ulong) (height : _ulong) (x : _long) (y : _long)
|
|
-> _status)
|
|
|
|
;; MagickSpreadImage is a special effects method that randomly displaces each
|
|
;; pixel in a block defined by the radius parameter.
|
|
(defmagick* MagickSpreadImage :
|
|
_MagickWand (radius : _double*) -> _status)
|
|
|
|
;; Use MagickSteganoImage to hide a digital watermark within the image.
|
|
;; Recover the hidden watermark later to prove that the authenticity of an
|
|
;; image. Offset defines the start position within the image to hide the
|
|
;; watermark.
|
|
(defmagick* MagickSteganoImage :
|
|
_MagickWand (watermark : _MagickWand) (offset : _long) -> _MagickWand)
|
|
|
|
;; MagickStereoImage composites two images and produces a single image that is
|
|
;; the composite of a left and right image of a stereo pair.
|
|
(defmagick* MagickStereoImage :
|
|
_MagickWand (offset : _MagickWand) -> _MagickWand)
|
|
|
|
;; MagickStripImage strips an image of all profiles and comments.
|
|
(defmagick* MagickStripImage :
|
|
_MagickWand -> _status)
|
|
|
|
;; MagickSwirlImage swirls the pixels about the center of the image, where
|
|
;; degrees indicates the sweep of the arc through which each pixel is moved.
|
|
;; You get a more dramatic effect as the degrees move from 1 to 360.
|
|
(defmagick* MagickSwirlImage :
|
|
_MagickWand (degrees : _double*) -> _status)
|
|
|
|
;; MagickTextureImage repeatedly tiles the texture image across and down the
|
|
;; image canvas.
|
|
(defmagick* MagickTextureImage :
|
|
_MagickWand (texture : _MagickWand) -> _MagickWand)
|
|
|
|
;; MagickThresholdImage changes the value of individual pixels based on the
|
|
;; intensity of each pixel compared to threshold. The result is a
|
|
;; high-contrast, two color image.
|
|
(defmagick* MagickThresholdImage :
|
|
_MagickWand _double* -> _status)
|
|
|
|
;; MagickThresholdImageChannel changes the value of individual pixel component
|
|
;; based on the intensity of each pixel compared to threshold. The result is a
|
|
;; high-contrast, two color image.
|
|
(defmagick* MagickThresholdImageChannel :
|
|
_MagickWand _ChannelType (threshold : _double*) -> _status)
|
|
|
|
;; MagickTintImage applies a color vector to each pixel in the image. The
|
|
;; length of the vector is 0 for black and white and at its maximum for the
|
|
;; midtones. The vector weighting function is
|
|
;; f(x)=(1-(4.0*((x-0.5)*(x-0.5)))).
|
|
(defmagick* MagickTintImage :
|
|
_MagickWand (tint : _PixelWand) (opacity : _PixelWand) -> _status)
|
|
|
|
;; MagickTransformImage is a convenience method that behaves like
|
|
;; MagickResizeImage or MagickCropImage but accepts scaling and/or cropping
|
|
;; information as a region geometry specification. If the operation fails, the
|
|
;; original image handle is returned.
|
|
(defmagick* MagickTransformImage :
|
|
_MagickWand (crop-geometry : _string) (image-geometry : _string)
|
|
-> _MagickWand)
|
|
|
|
;; MagickTransparentImage changes any pixel that matches color with the color
|
|
;; defined by fill.
|
|
(defmagick* MagickTransparentImage :
|
|
_MagickWand (target : _PixelWand) (opacity : _Quantum) (fuzz : _double*)
|
|
-> _status)
|
|
|
|
;; MagickTrimImage remove edges that are the background color from the image.
|
|
(defmagick* MagickTrimImage :
|
|
_MagickWand (fuzz : _double*) -> _status)
|
|
|
|
;; MagickUnsharpMaskImage sharpens an image. We convolve the image with a
|
|
;; Gaussian operator of the given radius and standard deviation (sigma). For
|
|
;; reasonable results, radius should be larger than sigma. Use a radius of 0
|
|
;; and UnsharpMaskImage selects a suitable radius for you.
|
|
(defmagick* MagickUnsharpMaskImage :
|
|
_MagickWand (radius : _double*) (sigma : _double*)
|
|
(amount-precentage : _double*) (threshold : _double*)
|
|
-> _status)
|
|
|
|
;; MagickWaveImage creates a "ripple" effect in the image by shifting the
|
|
;; pixels vertically along a sine wave whose amplitude and wavelength is
|
|
;; specified by the given parameters.
|
|
(defmagick* MagickWaveImage :
|
|
_MagickWand (amplitude : _double*) (wave-length : _double*) -> _status)
|
|
|
|
;; MagickWhiteThresholdImage is like ThresholdImage but forces all pixels above
|
|
;; the threshold into white while leaving all pixels below the threshold
|
|
;; unchanged.
|
|
(defmagick* MagickWhiteThresholdImage :
|
|
_MagickWand _PixelWand -> _status)
|
|
|
|
;; MagickWriteImage writes an image.
|
|
(defmagick* MagickWriteImage :
|
|
_MagickWand _file -> _status)
|
|
|
|
;; MagickGetImageBlob implements direct to memory image formats. It returns
|
|
;; the image as a blob and its length. The magick member of the Image
|
|
;; structure determines the format of the returned blob (GIF, JPEG, PNG, etc.)
|
|
(defmagick* MagickGetImageBlob :
|
|
_MagickWand (len : (_ptr o _ulong)) -> (_bytes o len))
|
|
|
|
;; MagickWriteImageFile writes an image to an open file descriptor.
|
|
(defmagick* MagickWriteImageFile :
|
|
_MagickWand (FILE* : _pointer) -> _status)
|
|
|
|
;; MagickWriteImages writes an image or image sequence.
|
|
(defmagick* MagickWriteImages :
|
|
_MagickWand _file (adjoin? : _bool) -> _status)
|
|
|
|
;; NewMagickWand returns a wand required for all other methods in the API.
|
|
(defmagick* NewMagickWand :
|
|
-> _MagickWand)
|
|
|
|
;; ===== PixelIterator API ====================================================
|
|
|
|
;; DestroyPixelIterator deallocates resources associated with a PixelIterator.
|
|
(defmagick DestroyPixelIterator :
|
|
_PixelIterator -> _void)
|
|
|
|
;; NewPixelIterator returns a new pixel iterator.
|
|
(defmagick* NewPixelIterator :
|
|
(w : _MagickWand) -> (pi : _PixelIterator)
|
|
-> (begin (set-PixelIterator-width! pi (MagickGetImageWidth w)) pi))
|
|
|
|
;; NewPixelRegionIterator returns a new pixel iterator.
|
|
(defmagick* NewPixelRegionIterator :
|
|
_MagickWand (x : _long) (y : _long) (width : _ulong) (height : _ulong)
|
|
-> (pi : _PixelIterator)
|
|
-> (begin (set-PixelIterator-width! pi width) pi))
|
|
|
|
;; PixelIteratorGetException returns the severity, reason, and description of
|
|
;; any error that occurs when using other methods in this API.
|
|
(defmagick* PixelIteratorGetException :
|
|
_PixelIterator (severity : (_ptr o _MagickExceptionType))
|
|
-> (message : _string)
|
|
-> (unless (eq? severity 'UndefinedException)
|
|
(error 'PixelIterator "(~a) ~a" severity message)))
|
|
|
|
;; PixelGetNextRow returns the next row from the pixel iterator.
|
|
(defmagick* PixelGetNextRow :
|
|
(pi : _PixelIterator) -> (_list o _PixelWand (PixelIterator-width pi)))
|
|
|
|
;; PixelResetIterator resets the pixel iterator. Use it in conjunction with
|
|
;; PixelGetNextPixel to iterate over all the pixels in a pixel container.
|
|
(defmagick* PixelResetIterator :
|
|
_PixelIterator -> _void)
|
|
|
|
;; PixelSetIteratorRow set the pixel iterator row.
|
|
(defmagick* PixelSetIteratorRow :
|
|
(pi : _PixelIterator) (row : _long) -> _status)
|
|
|
|
;; PixelSyncIterator syncs the pixel iterator.
|
|
(defmagick* PixelSyncIterator :
|
|
_PixelIterator -> _status)
|
|
|
|
;; ===== PixelWand API ========================================================
|
|
|
|
;; PixelGetException returns the severity, reason, and description of any error
|
|
;; that occurs when using other methods in this API (as an exception).
|
|
(defmagick* PixelGetException :
|
|
_MagickWand (severity : (_ptr o _MagickExceptionType)) -> (message : _string)
|
|
-> (unless (eq? severity 'UndefinedException)
|
|
(error 'PixelWand "(~a) ~a" severity message)))
|
|
|
|
;; DestroyPixelWand deallocates resources associated with a PixelWand.
|
|
;; Intended for internal use only, must be defined after the above.
|
|
(defmagick DestroyPixelWand :
|
|
_PixelWand -> _void)
|
|
|
|
;; DestroyPixelWands deallocates resources associated with an array of
|
|
;; pixel wands.
|
|
;; * There is no need for this
|
|
|
|
;; NewPixelWand returns a new pixel wand.
|
|
;; Extended: can get a color name to use for the new pixel wand, or an RGB list
|
|
;; (integers or floats determine the method to use for setting the values), or
|
|
;; a CMYK list. (See also the _PixelWand type definition).
|
|
(defmagick* NewPixelWand :
|
|
init-color ::
|
|
-> (p : _PixelWand)
|
|
-> (let ([color (and (pair? init-color) (car init-color))])
|
|
(define (err) (error 'NewPixelWand "bad initial color: ~e" color))
|
|
(cond [(null? init-color)]
|
|
[(string? color) (PixelSetColor p color)]
|
|
[(list? color)
|
|
(let ([len (length color)]
|
|
[ints? (andmap integer? color)]
|
|
[flts? (andmap inexact? color)])
|
|
(if (or ints? flts?)
|
|
(let ([len (if flts? (- len) len)])
|
|
(case len
|
|
[(3) (PixelSetRedQuantum p (car color))
|
|
(PixelSetGreenQuantum p (cadr color))
|
|
(PixelSetBlueQuantum p (caddr color))]
|
|
[(-3) (PixelSetRed p (car color))
|
|
(PixelSetGreen p (cadr color))
|
|
(PixelSetBlue p (caddr color))]
|
|
[(4) (PixelSetCyanQuantum p (car color))
|
|
(PixelSetMagentaQuantum p (cadr color))
|
|
(PixelSetYellowQuantum p (caddr color))
|
|
(PixelSetBlackQuantum p (cadddr color))]
|
|
[(-4) (PixelSetCyan p (car color))
|
|
(PixelSetMagenta p (cadr color))
|
|
(PixelSetYellow p (caddr color))
|
|
(PixelSetBlack p (cadddr color))]
|
|
[else (err)]))
|
|
(err)))]
|
|
[else (err)])
|
|
p))
|
|
|
|
;; NewPixelWands returns an array of pixel wands.
|
|
;; * There is no need for this
|
|
|
|
;; PixelGetBlack returns the normalized black color of the pixel wand.
|
|
(defmagick* PixelGetBlack :
|
|
_PixelWand -> _double*)
|
|
|
|
;; PixelGetBlackQuantum returns the black color of the pixel wand. The color
|
|
;; is in the range of [0..MaxRGB].
|
|
(defmagick* PixelGetBlackQuantum :
|
|
_PixelWand -> _Quantum)
|
|
|
|
;; PixelGetBlue returns the normalized blue color of the pixel wand.
|
|
(defmagick* PixelGetBlue :
|
|
_PixelWand -> _double*)
|
|
|
|
;; PixelGetBlueQuantum returns the blue color of the pixel wand. The color is
|
|
;; in the range of [0..MaxRGB].
|
|
(defmagick* PixelGetBlueQuantum :
|
|
_PixelWand -> _Quantum)
|
|
|
|
;; PixelGetColorAsString gets the color of the pixel wand.
|
|
(defmagick* PixelGetColorAsString :
|
|
_PixelWand -> _string)
|
|
|
|
;; PixelGetColorCount returns the color count associated with this color.
|
|
(defmagick* PixelGetColorCount :
|
|
_PixelWand -> _ulong)
|
|
|
|
;; PixelGetCyan returns the normalized cyan color of the pixel wand.
|
|
(defmagick* PixelGetCyan :
|
|
_PixelWand -> _double*)
|
|
|
|
;; PixelGetCyanQuantum returns the cyan color of the pixel wand. The color is
|
|
;; in the range of [0..MaxRGB].
|
|
(defmagick* PixelGetCyanQuantum :
|
|
_PixelWand -> _Quantum)
|
|
|
|
;; PixelGetGreen returns the normalized green color of the pixel wand.
|
|
(defmagick* PixelGetGreen :
|
|
_PixelWand -> _double*)
|
|
|
|
;; PixelGetGreenQuantum returns the green color of the pixel wand. The color
|
|
;; is in the range of [0..MaxRGB].
|
|
(defmagick* PixelGetGreenQuantum :
|
|
_PixelWand -> _Quantum)
|
|
|
|
;; PixelGetIndex returns the colormap index from the pixel wand.
|
|
(defmagick* PixelGetIndex :
|
|
_PixelWand -> _IndexPacket)
|
|
|
|
;; PixelGetMagenta returns the normalized magenta color of the pixel wand.
|
|
(defmagick* PixelGetMagenta :
|
|
_PixelWand -> _double*)
|
|
|
|
;; PixelGetMagentaQuantum returns the magenta color of the pixel wand. The
|
|
;; color is in the range of [0..MaxRGB].
|
|
(defmagick* PixelGetMagentaQuantum :
|
|
_PixelWand -> _Quantum)
|
|
|
|
;; PixelGetOpacity returns the normalized opacity color of the pixel wand.
|
|
(defmagick* PixelGetOpacity :
|
|
_PixelWand -> _double*)
|
|
|
|
;; PixelGetOpacityQuantum returns the opacity color of the pixel wand. The
|
|
;; color is in the range of [0..MaxRGB].
|
|
(defmagick* PixelGetOpacityQuantum :
|
|
_PixelWand -> _Quantum)
|
|
|
|
;; PixelGetQuantumColor gets the color of the pixel wand.
|
|
(defmagick* PixelGetQuantumColor :
|
|
_PixelWand (color : _PixelPacket = (NewPixelPacket)) -> _void
|
|
-> color)
|
|
|
|
;; PixelGetRed returns the normalized red color of the pixel wand.
|
|
(defmagick* PixelGetRed :
|
|
_PixelWand -> _double*)
|
|
|
|
;; PixelGetRedQuantum returns the red color of the pixel wand. The color is in
|
|
;; the range of [0..MaxRGB].
|
|
(defmagick* PixelGetRedQuantum :
|
|
_PixelWand -> _Quantum)
|
|
|
|
;; PixelGetYellow returns the normalized yellow color of the pixel wand.
|
|
(defmagick* PixelGetYellow :
|
|
_PixelWand -> _double*)
|
|
|
|
;; PixelGetYellowQuantum returns the yellow color of the pixel wand. The color
|
|
;; is in the range of [0..MaxRGB].
|
|
(defmagick* PixelGetYellowQuantum :
|
|
_PixelWand -> _Quantum)
|
|
|
|
;; PixelSetBlack sets the normalized black color of the pixel wand.
|
|
(defmagick* PixelSetBlack :
|
|
_PixelWand (black : _double*) -> _void)
|
|
|
|
;; PixelSetBlackQuantum sets the black color of the pixel wand. The color must
|
|
;; be in the range of [0..MaxRGB].
|
|
(defmagick* PixelSetBlackQuantum :
|
|
_PixelWand (black : _Quantum) -> _void)
|
|
|
|
;; PixelSetBlue sets the normalized blue color of the pixel wand.
|
|
(defmagick* PixelSetBlue :
|
|
_PixelWand (blue : _double*) -> _void)
|
|
|
|
;; PixelSetBlueQuantum sets the blue color of the pixel wand. The color must
|
|
;; be in the range of [0..MaxRGB].
|
|
(defmagick* PixelSetBlueQuantum :
|
|
_PixelWand (blue : _Quantum) -> _void)
|
|
|
|
;; PixelSetColor sets the color of the pixel wand with a string (e.g. "blue",
|
|
;; "#0000ff", "rgb(0,0,255)", "cmyk(100,100,100,10)", etc.).
|
|
(defmagick* PixelSetColor :
|
|
_PixelWand (color : _string) -> _status)
|
|
|
|
;; PixelSetColorCount sets the color count of the pixel wand.
|
|
(defmagick* PixelSetColorCount :
|
|
_PixelWand (count : _ulong) -> _void)
|
|
|
|
;; PixelSetCyan sets the normalized cyan color of the pixel wand.
|
|
(defmagick* PixelSetCyan :
|
|
_PixelWand (cyan : _double*) -> _void)
|
|
|
|
;; PixelSetCyanQuantum sets the cyan color of the pixel wand. The color must
|
|
;; be in the range of [0..MaxRGB].
|
|
(defmagick* PixelSetCyanQuantum :
|
|
_PixelWand (cyan : _Quantum) -> _void)
|
|
|
|
;; PixelSetGreen sets the normalized green color of the pixel wand.
|
|
(defmagick* PixelSetGreen :
|
|
_PixelWand (green : _double*) -> _void)
|
|
|
|
;; PixelSetGreenQuantum sets the green color of the pixel wand. The color must
|
|
;; be in the range of [0..MaxRGB].
|
|
(defmagick* PixelSetGreenQuantum :
|
|
_PixelWand (green : _Quantum) -> _void)
|
|
|
|
;; PixelSetIndex sets the colormap index of the pixel wand.
|
|
(defmagick* PixelSetIndex :
|
|
_PixelWand _IndexPacket -> _void)
|
|
|
|
;; PixelSetMagenta sets the normalized magenta color of the pixel wand.
|
|
(defmagick* PixelSetMagenta :
|
|
_PixelWand (magenta : _double*) -> _void)
|
|
|
|
;; PixelSetMagentaQuantum sets the magenta color of the pixel wand. The color
|
|
;; must be in the range of [0..MaxRGB].
|
|
(defmagick* PixelSetMagentaQuantum :
|
|
_PixelWand (magenta : _Quantum) -> _void)
|
|
|
|
;; PixelSetOpacity sets the normalized opacity color of the pixel wand.
|
|
(defmagick* PixelSetOpacity :
|
|
_PixelWand (opacity : _double*) -> _void)
|
|
|
|
;; PixelSetOpacityQuantum sets the opacity color of the pixel wand. The color
|
|
;; must be in the range of [0..MaxRGB].
|
|
(defmagick* PixelSetOpacityQuantum :
|
|
_PixelWand (opacity : _Quantum) -> _void)
|
|
|
|
;; PixelSetQuantumColor sets the color of the pixel wand.
|
|
(defmagick* PixelSetQuantumColor :
|
|
_PixelWand _PixelPacket -> _void)
|
|
|
|
;; PixelSetRed sets the normalized red color of the pixel wand.
|
|
(defmagick* PixelSetRed :
|
|
_PixelWand (red : _double*) -> _void)
|
|
|
|
;; PixelSetRedQuantum sets the red color of the pixel wand. The color must be
|
|
;; in the range of [0..MaxRGB].
|
|
(defmagick* PixelSetRedQuantum :
|
|
_PixelWand (red : _Quantum) -> _void)
|
|
|
|
;; PixelSetYellow sets the normalized yellow color of the pixel wand.
|
|
(defmagick* PixelSetYellow :
|
|
_PixelWand (yellow : _double*) -> _void)
|
|
|
|
;; PixelSetYellowQuantum sets the yellow color of the pixel wand. The color
|
|
;; must be in the range of [0..MaxRGB].
|
|
(defmagick* PixelSetYellowQuantum :
|
|
_PixelWand (yellow : _Quantum) -> _void)
|
|
|
|
;; ===== DrawingWand API ======================================================
|
|
|
|
;; DrawGetException returns the severity, reason, and description of any error
|
|
;; that occurs when using other methods in this API.
|
|
(defmagick* DrawGetException :
|
|
_DrawingWand (severity : (_ptr o _MagickExceptionType))
|
|
-> (message : _string)
|
|
-> (unless (eq? severity 'UndefinedException)
|
|
(error 'DrawingWand "(~a) ~a" severity message)))
|
|
|
|
;; DestroyDrawingWand frees all resources associated with the drawing wand.
|
|
;; Once the drawing wand has been freed, it should not be used any further
|
|
;; unless it re-allocated.
|
|
(defmagick DestroyDrawingWand :
|
|
_DrawingWand -> _void)
|
|
|
|
;; DrawAnnotation draws text on the image.
|
|
(defmagick* DrawAnnotation :
|
|
_DrawingWand (x : _double*) (y : _double*) (text : _string) -> _void)
|
|
|
|
;; DrawAffine adjusts the current affine transformation matrix with the
|
|
;; specified affine transformation matrix. Note that the current affine
|
|
;; transform is adjusted rather than replaced.
|
|
(defmagick* DrawAffine :
|
|
_DrawingWand _AffineMatrix -> _void)
|
|
|
|
;; DrawAllocateWand allocates an initial drawing wand which is an opaque handle
|
|
;; required by the remaining drawing methods.
|
|
(defmagick* DrawAllocateWand :
|
|
_DrawInfo _Image -> _DrawingWand)
|
|
|
|
;; DrawArc draws an arc falling within a specified bounding rectangle on the
|
|
;; image.
|
|
(defmagick* DrawArc :
|
|
_DrawingWand
|
|
(x1 : _double*) (y1 : _double*) (x2 : _double*) (y2 : _double*)
|
|
(deg1 : _double*) (deg2 : _double*)
|
|
-> _void)
|
|
|
|
;; DrawBezier draws a bezier curve through a set of points on the image.
|
|
(defmagick* DrawBezier :
|
|
(d points) ::
|
|
(d : _DrawingWand) (_ulong = (length points)) (points : _Points) -> _void)
|
|
|
|
;; DrawCircle draws a circle on the image.
|
|
(defmagick* DrawCircle :
|
|
_DrawingWand
|
|
(x : _double*) (y : _double*)
|
|
(perimeter-x : _double*) (perimeter-y : _double*)
|
|
-> _void)
|
|
|
|
;; DrawGetClipPath obtains the current clipping path ID. The value returned
|
|
;; must be deallocated by the user when it is no longer needed.
|
|
(defmagick* DrawGetClipPath :
|
|
_DrawingWand -> _string)
|
|
|
|
;; DrawSetClipPath associates a named clipping path with the image. Only the
|
|
;; areas drawn on by the clipping path will be modified as long as it remains
|
|
;; in effect.
|
|
(defmagick* DrawSetClipPath :
|
|
_DrawingWand (clip_path : _string) -> _void)
|
|
|
|
;; DrawGetClipRule returns the current polygon fill rule to be used by the
|
|
;; clipping path.
|
|
(defmagick* DrawGetClipRule :
|
|
_DrawingWand -> _FillRule)
|
|
|
|
;; DrawSetClipRule set the polygon fill rule to be used by the clipping path.
|
|
(defmagick* DrawSetClipRule :
|
|
_DrawingWand _FillRule -> _void)
|
|
|
|
;; DrawGetClipUnits returns the interpretation of clip path units.
|
|
(defmagick* DrawGetClipUnits :
|
|
_DrawingWand -> _ClipPathUnits)
|
|
|
|
;; DrawSetClipUnits sets the interpretation of clip path units.
|
|
(defmagick* DrawSetClipUnits :
|
|
_DrawingWand _ClipPathUnits -> _void)
|
|
|
|
;; DrawColor draws color on image using the current fill color, starting at
|
|
;; specified position, and using specified paint method. The available paint
|
|
;; methods are:
|
|
;; PointMethod: Recolors the target pixel
|
|
;; ReplaceMethod: Recolor any pixel that matches the target pixel.
|
|
;; FloodfillMethod: Recolors target pixels and matching neighbors.
|
|
;; FillToBorderMethod: Recolor target pixels and neighbors not matching
|
|
;; border color.
|
|
;; ResetMethod: Recolor all pixels.
|
|
(defmagick* DrawColor :
|
|
_DrawingWand (x : _double*) (y : _double*) _PaintMethod -> _void)
|
|
|
|
;; DrawComment adds a comment to a vector output stream.
|
|
(defmagick* DrawComment :
|
|
_DrawingWand (comment : _string) -> _void)
|
|
|
|
;; DrawEllipse draws an ellipse on the image.
|
|
(defmagick* DrawEllipse :
|
|
_DrawingWand
|
|
(x : _double*) (y : _double*)
|
|
(radius-x : _double*) (radius-y : _double*)
|
|
(start-deg : _double*) (end-deg : _double*)
|
|
-> _void)
|
|
|
|
;; DrawGetFillColor returns the fill color used for drawing filled objects.
|
|
(defmagick* DrawGetFillColor :
|
|
_DrawingWand (c : _PixelWand = (NewPixelWand)) -> _void -> c)
|
|
|
|
;; DrawSetFillColor sets the fill color to be used for drawing filled objects.
|
|
(defmagick* DrawSetFillColor :
|
|
_DrawingWand _PixelWand -> _void)
|
|
|
|
;; DrawSetFillPatternURL sets the URL to use as a fill pattern for filling
|
|
;; objects. Only local URLs ("#identifier") are supported at this time. These
|
|
;; local URLs are normally created by defining a named fill pattern with
|
|
;; DrawPushPattern/DrawPopPattern.
|
|
(defmagick* DrawSetFillPatternURL :
|
|
_DrawingWand (fill-url : _string) -> _void)
|
|
|
|
;; DrawGetFillOpacity returns the opacity used when drawing using the fill
|
|
;; color or fill texture. Fully opaque is 1.0.
|
|
(defmagick* DrawGetFillOpacity :
|
|
_DrawingWand -> _double*)
|
|
|
|
;; DrawSetFillOpacity sets the opacity to use when drawing using the fill color
|
|
;; or fill texture. Fully opaque is 1.0.
|
|
(defmagick* DrawSetFillOpacity :
|
|
_DrawingWand (fill-opacity : _double*) -> _void)
|
|
|
|
;; DrawGetFillRule returns the fill rule used while drawing polygons.
|
|
(defmagick* DrawGetFillRule :
|
|
_DrawingWand -> _FillRule)
|
|
|
|
;; DrawSetFillRule sets the fill rule to use while drawing polygons.
|
|
(defmagick* DrawSetFillRule :
|
|
_DrawingWand _FillRule -> _void)
|
|
|
|
;; DrawGetFont returns a null-terminaged string specifying the font used when
|
|
;; annotating with text.
|
|
(defmagick* DrawGetFont :
|
|
_DrawingWand -> _string)
|
|
|
|
;; DrawSetFont sets the fully-sepecified font to use when annotating with text.
|
|
(defmagick* DrawSetFont :
|
|
_DrawingWand (font-name : _string) -> _void)
|
|
|
|
;; DrawGetFontFamily returns the font family to use when annotating with text.
|
|
(defmagick* DrawGetFontFamily :
|
|
_DrawingWand -> _string)
|
|
|
|
;; DrawSetFontFamily sets the font family to use when annotating with text.
|
|
(defmagick* DrawSetFontFamily :
|
|
_DrawingWand (font-family : _string) -> _void)
|
|
|
|
;; DrawGetFontSize returns the font pointsize used when annotating with text.
|
|
(defmagick* DrawGetFontSize :
|
|
_DrawingWand -> _double*)
|
|
|
|
;; DrawSetFontSize sets the font pointsize to use when annotating with text.
|
|
(defmagick* DrawSetFontSize :
|
|
_DrawingWand (pointsize : _double*) -> _void)
|
|
|
|
;; DrawGetFontStretch returns the font stretch used when annotating with text.
|
|
(defmagick* DrawGetFontStretch :
|
|
_DrawingWand -> _StretchType)
|
|
|
|
;; DrawSetFontStretch sets the font stretch to use when annotating with text.
|
|
;; The AnyStretch enumeration acts as a wild-card "don't care" option.
|
|
(defmagick* DrawSetFontStretch :
|
|
_DrawingWand _StretchType -> _void)
|
|
|
|
;; DrawGetFontStyle returns the font style used when annotating with text.
|
|
(defmagick* DrawGetFontStyle :
|
|
_DrawingWand -> _StyleType)
|
|
|
|
;; DrawSetFontStyle sets the font style to use when annotating with text. The
|
|
;; AnyStyle enumeration acts as a wild-card "don't care" option.
|
|
(defmagick* DrawSetFontStyle :
|
|
_DrawingWand _StyleType -> _void)
|
|
|
|
;; DrawGetFontWeight returns the font weight used when annotating with text.
|
|
(defmagick* DrawGetFontWeight :
|
|
_DrawingWand -> _ulong)
|
|
|
|
;; DrawSetFontWeight sets the font weight to use when annotating with text.
|
|
(defmagick* DrawSetFontWeight :
|
|
_DrawingWand (font-weight : _ulong) -> _void)
|
|
|
|
;; DrawGetGravity returns the text placement gravity used when annotating with
|
|
;; text.
|
|
(defmagick* DrawGetGravity :
|
|
_DrawingWand -> _GravityType)
|
|
|
|
;; DrawSetGravity sets the text placement gravity to use when annotating with
|
|
;; text.
|
|
(defmagick* DrawSetGravity :
|
|
_DrawingWand _GravityType -> _void)
|
|
|
|
;; DrawComposite composites an image onto the current image, using the
|
|
;; specified composition operator, specified position, and at the specified
|
|
;; size.
|
|
(defmagick* DrawComposite :
|
|
_DrawingWand _CompositeOperator
|
|
(x : _double*) (y : _double*) (width : _double*) (height : _double*) _Image
|
|
-> _void)
|
|
|
|
;; DrawLine draws a line on the image using the current stroke color, stroke
|
|
;; opacity, and stroke width.
|
|
(defmagick* DrawLine :
|
|
_DrawingWand (x1 : _double*) (y1 : _double*) (x2 : _double*) (y2 : _double*)
|
|
-> _void)
|
|
|
|
;; DrawMatte paints on the image's opacity channel in order to set effected
|
|
;; pixels to transparent. The available paint methods are:
|
|
;; PointMethod: Select the target pixel
|
|
;; ReplaceMethod: Select any pixel that matches the target pixel.
|
|
;; FloodfillMethod: Select the target pixel and matching neighbors.
|
|
;; FillToBorderMethod: Select the target pixel and neighbors not matching
|
|
;; border color.
|
|
;; ResetMethod: Select all pixels.
|
|
(defmagick* DrawMatte :
|
|
_DrawingWand (x : _double*) (y : _double*) _PaintMethod -> _void)
|
|
|
|
;; DrawPathClose adds a path element to the current path which closes the
|
|
;; current subpath by drawing a straight line from the current point to the
|
|
;; current subpath's most recent starting point (usually, the most recent
|
|
;; moveto point).
|
|
(defmagick* DrawPathClose :
|
|
_DrawingWand -> _void)
|
|
|
|
;; DrawPathCurveToAbsolute draws a cubic Bezier curve from the current point to
|
|
;; (x,y) using (x1,y1) as the control point at the beginning of the curve and
|
|
;; (x2,y2) as the control point at the end of the curve using absolute
|
|
;; coordinates. At the end of the command, the new current point becomes the
|
|
;; final (x,y) coordinate pair used in the polybezier.
|
|
(defmagick* DrawPathCurveToAbsolute :
|
|
_DrawingWand
|
|
(x1 : _double*) (y1 : _double*) (x2 : _double*) (y2 : _double*)
|
|
(x : _double*) (y : _double*)
|
|
-> _void)
|
|
|
|
;; DrawPathCurveToRelative draws a cubic Bezier curve from the current point to
|
|
;; (x,y) using (x1,y1) as the control point at the beginning of the curve and
|
|
;; (x2,y2) as the control point at the end of the curve using relative
|
|
;; coordinates. At the end of the command, the new current point becomes the
|
|
;; final (x,y) coordinate pair used in the polybezier.
|
|
(defmagick* DrawPathCurveToRelative :
|
|
_DrawingWand
|
|
(x1 : _double*) (y1 : _double*) (x2 : _double*) (y2 : _double*)
|
|
(x : _double*) (y : _double*)
|
|
-> _void)
|
|
|
|
;; DrawPathCurveToQuadraticBezierAbsolute draws a quadratic Bezier curve from
|
|
;; the current point to (x,y) using (x1,y1) as the control point using absolute
|
|
;; coordinates. At the end of the command, the new current point becomes the
|
|
;; final (x,y) coordinate pair used in the polybezier.
|
|
(defmagick* DrawPathCurveToQuadraticBezierAbsolute :
|
|
_DrawingWand (x1 : _double*) (y1 : _double*) (x : _double*) (y : _double*)
|
|
-> _void)
|
|
|
|
;; DrawPathCurveToQuadraticBezierRelative draws a quadratic Bezier curve from
|
|
;; the current point to (x,y) using (x1,y1) as the control point using relative
|
|
;; coordinates. At the end of the command, the new current point becomes the
|
|
;; final (x,y) coordinate pair used in the polybezier.
|
|
(defmagick* DrawPathCurveToQuadraticBezierRelative :
|
|
_DrawingWand (x1 : _double*) (y1 : _double*) (x : _double*) (y : _double*)
|
|
-> _void)
|
|
|
|
;; DrawPathCurveToQuadraticBezierSmoothAbsolute draws a quadratic Bezier curve
|
|
;; (using absolute coordinates) from the current point to (x,y). The control
|
|
;; point is assumed to be the reflection of the control point on the previous
|
|
;; command relative to the current point. (If there is no previous command or
|
|
;; if the previous command was not a DrawPathCurveToQuadraticBezierAbsolute,
|
|
;; DrawPathCurveToQuadraticBezierRelative,
|
|
;; DrawPathCurveToQuadraticBezierSmoothAbsolut or
|
|
;; DrawPathCurveToQuadraticBezierSmoothRelative, assume the control point is
|
|
;; coincident with the current point.). At the end of the command, the new
|
|
;; current point becomes the final (x,y) coordinate pair used in the
|
|
;; polybezier.
|
|
(defmagick* DrawPathCurveToQuadraticBezierSmoothAbsolute :
|
|
_DrawingWand (x : _double*) (y : _double*) -> _void)
|
|
|
|
;; DrawPathCurveToQuadraticBezierSmoothAbsolute draws a quadratic Bezier curve
|
|
;; (using relative coordinates) from the current point to (x,y). The control
|
|
;; point is assumed to be the reflection of the control point on the previous
|
|
;; command relative to the current point. (If there is no previous command or
|
|
;; if the previous command was not a DrawPathCurveToQuadraticBezierAbsolute,
|
|
;; DrawPathCurveToQuadraticBezierRelative,
|
|
;; DrawPathCurveToQuadraticBezierSmoothAbsolut or
|
|
;; DrawPathCurveToQuadraticBezierSmoothRelative, assume the control point is
|
|
;; coincident with the current point.). At the end of the command, the new
|
|
;; current point becomes the final (x,y) coordinate pair used in the
|
|
;; polybezier.
|
|
(defmagick* DrawPathCurveToQuadraticBezierSmoothRelative :
|
|
_DrawingWand (x : _double*) (y : _double*) -> _void)
|
|
|
|
;; DrawPathCurveToSmoothAbsolute draws a cubic Bezier curve from the current
|
|
;; point to (x,y) using absolute coordinates. The first control point is
|
|
;; assumed to be the reflection of the second control point on the previous
|
|
;; command relative to the current point. (If there is no previous command or
|
|
;; if the previous command was not an DrawPathCurveToAbsolute,
|
|
;; DrawPathCurveToRelative, DrawPathCurveToSmoothAbsolute or
|
|
;; DrawPathCurveToSmoothRelative, assume the first control point is coincident
|
|
;; with the current point.) (x2,y2) is the second control point (i.e., the
|
|
;; control point at the end of the curve). At the end of the command, the new
|
|
;; current point becomes the final (x,y) coordinate pair used in the
|
|
;; polybezier.
|
|
(defmagick* DrawPathCurveToSmoothAbsolute :
|
|
_DrawingWand (x2 : _double*) (y2 : _double*) (x : _double*) (y : _double*)
|
|
-> _void)
|
|
|
|
;; DrawPathCurveToSmoothRelative draws a cubic Bezier curve from the current
|
|
;; point to (x,y) using relative coordinates. The first control point is
|
|
;; assumed to be the reflection of the second control point on the previous
|
|
;; command relative to the current point. (If there is no previous command or
|
|
;; if the previous command was not an DrawPathCurveToAbsolute,
|
|
;; DrawPathCurveToRelative, DrawPathCurveToSmoothAbsolute or
|
|
;; DrawPathCurveToSmoothRelative, assume the first control point is coincident
|
|
;; with the current point.) (x2,y2) is the second control point (i.e., the
|
|
;; control point at the end of the curve). At the end of the command, the new
|
|
;; current point becomes the final (x,y) coordinate pair used in the
|
|
;; polybezier.
|
|
(defmagick* DrawPathCurveToSmoothRelative :
|
|
_DrawingWand (x2 : _double*) (y2 : _double*) (x : _double*) (y : _double*)
|
|
-> _void)
|
|
|
|
;; DrawPathEllipticArcAbsolute draws an elliptical arc from the current point
|
|
;; to (x, y) using absolute coordinates. The size and orientation of the
|
|
;; ellipse are defined by two radii (rx, ry) and an xAxisRotation, which
|
|
;; indicates how the ellipse as a whole is rotated relative to the current
|
|
;; coordinate system. The center (cx, cy) of the ellipse is calculated
|
|
;; automatically to satisfy the constraints imposed by the other parameters.
|
|
;; largeArcFlag and sweepFlag contribute to the automatic calculations and help
|
|
;; determine how the arc is drawn. If largeArcFlag is true then draw the
|
|
;; larger of the available arcs. If sweepFlag is true, then draw the arc
|
|
;; matching a clock-wise rotation.
|
|
(defmagick* DrawPathEllipticArcAbsolute :
|
|
_DrawingWand (rx : _double*) (ry : _double*)
|
|
(x-axis-rotation : _double*) (large-arc-flag? : _bool) (sweep-flag? : _bool)
|
|
(x : _double*) (y : _double*)
|
|
-> _void)
|
|
|
|
;; DrawPathEllipticArcRelative draws an elliptical arc from the current point
|
|
;; to (x, y) using relative coordinates. The size and orientation of the
|
|
;; ellipse are defined by two radii (rx, ry) and an xAxisRotation, which
|
|
;; indicates how the ellipse as a whole is rotated relative to the current
|
|
;; coordinate system. The center (cx, cy) of the ellipse is calculated
|
|
;; automatically to satisfy the constraints imposed by the other parameters.
|
|
;; largeArcFlag and sweepFlag contribute to the automatic calculations and help
|
|
;; determine how the arc is drawn. If largeArcFlag is true then draw the
|
|
;; larger of the available arcs. If sweepFlag is true, then draw the arc
|
|
;; matching a clock-wise rotation.
|
|
(defmagick* DrawPathEllipticArcRelative :
|
|
_DrawingWand (rx : _double*) (ry : _double*)
|
|
(x-axis-rotation : _double*) (large-arc-flag? : _bool) (sweep-flag? : _bool)
|
|
(x : _double*) (y : _double*)
|
|
-> _void)
|
|
|
|
;; DrawPathFinish terminates the current path.
|
|
(defmagick* DrawPathFinish :
|
|
_DrawingWand -> _void)
|
|
|
|
;; DrawPathLineToAbsolute draws a line path from the current point to the given
|
|
;; coordinate using absolute coordinates. The coordinate then becomes the new
|
|
;; current point.
|
|
(defmagick* DrawPathLineToAbsolute :
|
|
_DrawingWand (x : _double*) (y : _double*) -> _void)
|
|
|
|
;; DrawPathLineToRelative draws a line path from the current point to the given
|
|
;; coordinate using relative coordinates. The coordinate then becomes the new
|
|
;; current point.
|
|
(defmagick* DrawPathLineToRelative :
|
|
_DrawingWand (x : _double*) (y : _double*) -> _void)
|
|
|
|
;; DrawPathLineToHorizontalAbsolute draws a horizontal line path from the
|
|
;; current point to the target point using absolute coordinates. The target
|
|
;; point then becomes the new current point.
|
|
(defmagick* DrawPathLineToHorizontalAbsolute :
|
|
_DrawingWand (x : _double*) -> _void)
|
|
|
|
;; DrawPathLineToHorizontalRelative draws a horizontal line path from the
|
|
;; current point to the target point using relative coordinates. The target
|
|
;; point then becomes the new current point.
|
|
(defmagick* DrawPathLineToHorizontalRelative :
|
|
_DrawingWand (x : _double*) -> _void)
|
|
|
|
;; DrawPathLineToVerticalAbsolute draws a vertical line path from the current
|
|
;; point to the target point using absolute coordinates. The target point then
|
|
;; becomes the new current point.
|
|
(defmagick* DrawPathLineToVerticalAbsolute :
|
|
_DrawingWand (y : _double*) -> _void)
|
|
|
|
;; DrawPathLineToVerticalRelative draws a vertical line path from the current
|
|
;; point to the target point using relative coordinates. The target point then
|
|
;; becomes the new current point.
|
|
(defmagick* DrawPathLineToVerticalRelative :
|
|
_DrawingWand (y : _double*) -> _void)
|
|
|
|
;; DrawPathMoveToAbsolute starts a new sub-path at the given coordinate using
|
|
;; absolute coordinates. The current point then becomes the specified
|
|
;; coordinate.
|
|
(defmagick* DrawPathMoveToAbsolute :
|
|
_DrawingWand (x : _double*) (y : _double*) -> _void)
|
|
|
|
;; DrawPathMoveToRelative starts a new sub-path at the given coordinate using
|
|
;; relative coordinates. The current point then becomes the specified
|
|
;; coordinate.
|
|
(defmagick* DrawPathMoveToRelative :
|
|
_DrawingWand (x : _double*) (y : _double*) -> _void)
|
|
|
|
;; DrawPathStart declares the start of a path drawing list which is terminated
|
|
;; by a matching DrawPathFinish command. All other DrawPath commands must be
|
|
;; enclosed between a DrawPathStart and a DrawPathFinish command. This is
|
|
;; because path drawing commands are subordinate commands and they do not
|
|
;; function by themselves.
|
|
(defmagick* DrawPathStart :
|
|
_DrawingWand -> _void)
|
|
|
|
;; PeekDrawingWand returns the current drawing wand.
|
|
(defmagick* PeekDrawingWand :
|
|
_DrawingWand -> _DrawInfo)
|
|
|
|
;; DrawPoint draws a point using the current stroke color and stroke thickness
|
|
;; at the specified coordinates.
|
|
(defmagick* DrawPoint :
|
|
_DrawingWand (x : _double*) (y : _double*) -> _void)
|
|
|
|
;; DrawPolygon draws a polygon using the current stroke, stroke width, and fill
|
|
;; color or texture, using the specified array of coordinates.
|
|
(defmagick* DrawPolygon :
|
|
(d points) ::
|
|
(d : _DrawingWand) (_ulong = (length points)) (points : _Points) -> _void)
|
|
|
|
;; DrawPolyline draws a polyline using the current stroke, stroke width, and
|
|
;; fill color or texture, using the specified array of coordinates.
|
|
(defmagick* DrawPolyline :
|
|
(d points) ::
|
|
(d : _DrawingWand) (_ulong = (length points)) (points : _Points) -> _void)
|
|
|
|
;; DrawPopClipPath terminates a clip path definition.
|
|
(defmagick* DrawPopClipPath :
|
|
_DrawingWand -> _void)
|
|
|
|
;; DrawPopDefs terminates a definition list.
|
|
(defmagick* DrawPopDefs :
|
|
_DrawingWand -> _void)
|
|
|
|
;; PopDrawingWand destroys the current drawing wand and returns to the
|
|
;; previously pushed drawing wand. Multiple drawing wands may exist. It is an
|
|
;; error to attempt to pop more drawing wands than have been pushed, and it is
|
|
;; proper form to pop all drawing wands which have been pushed.
|
|
(defmagick* PopDrawingWand :
|
|
_DrawingWand -> _void)
|
|
|
|
;; DrawPopPattern terminates a pattern definition.
|
|
(defmagick* DrawPopPattern :
|
|
_DrawingWand -> _void)
|
|
|
|
;; DrawPushClipPath starts a clip path definition which is comprized of any
|
|
;; number of drawing commands and terminated by a DrawPopClipPath command.
|
|
(defmagick* DrawPushClipPath :
|
|
_DrawingWand (clip-path-id : _string) -> _void)
|
|
|
|
;; DrawPushDefs indicates that commands up to a terminating DrawPopDefs command
|
|
;; create named elements (e.g. clip-paths, textures, etc.) which may safely be
|
|
;; processed earlier for the sake of efficiency.
|
|
(defmagick* DrawPushDefs :
|
|
_DrawingWand -> _void)
|
|
|
|
;; PushDrawingWand clones the current drawing wand to create a new
|
|
;; drawing wand. The original drawing drawing wand(s) may be returned to by
|
|
;; invoking PopDrawingWand. The drawing wands are stored on a drawing wand
|
|
;; stack. For every Pop there must have already been an equivalent Push.
|
|
(defmagick* PushDrawingWand :
|
|
_DrawingWand -> _void)
|
|
|
|
;; DrawPushPattern indicates that subsequent commands up to a DrawPopPattern
|
|
;; command comprise the definition of a named pattern. The pattern space is
|
|
;; assigned top left corner coordinates, a width and height, and becomes its
|
|
;; own drawing space. Anything which can be drawn may be used in a pattern
|
|
;; definition. Named patterns may be used as stroke or brush definitions.
|
|
(defmagick* DrawPushPattern :
|
|
_DrawingWand (pattern-id : _string)
|
|
(x : _double*) (y : _double*) (width : _double*) (height : _double*)
|
|
-> _void)
|
|
|
|
;; DrawRectangle draws a rectangle given two coordinates and using the current
|
|
;; stroke, stroke width, and fill settings.
|
|
(defmagick* DrawRectangle :
|
|
_DrawingWand (x1 : _double*) (y1 : _double*) (x2 : _double*) (y2 : _double*)
|
|
-> _void)
|
|
|
|
;; DrawRender renders all preceding drawing commands onto the image.
|
|
(defmagick* DrawRender :
|
|
_DrawingWand -> _status)
|
|
|
|
;; DrawRotate applies the specified rotation to the current coordinate space.
|
|
(defmagick* DrawRotate :
|
|
_DrawingWand (degrees : _double*) -> _void)
|
|
|
|
;; DrawRoundRectangle draws a rounted rectangle given two coordinates, x & y
|
|
;; corner radiuses and using the current stroke, stroke width, and fill
|
|
;; settings.
|
|
(defmagick* DrawRoundRectangle :
|
|
_DrawingWand
|
|
(x1 : _double*) (y1 : _double*) (x2 : _double*) (y2 : _double*)
|
|
(rx : _double*) (ry : _double*)
|
|
-> _void)
|
|
|
|
;; DrawScale adjusts the scaling factor to apply in the horizontal and vertical
|
|
;; directions to the current coordinate space.
|
|
(defmagick* DrawScale :
|
|
_DrawingWand (horizontal-scale : _double*) (vertical-scale : _double*)
|
|
-> _void)
|
|
|
|
;; DrawSkewX skews the current coordinate system in the horizontal direction.
|
|
(defmagick* DrawSkewX :
|
|
_DrawingWand (degrees : _double*) -> _void)
|
|
|
|
;; DrawSkewY skews the current coordinate system in the vertical direction.
|
|
(defmagick* DrawSkewY :
|
|
_DrawingWand (degrees : _double*) -> _void)
|
|
|
|
;; DrawGetStrokeColor returns the color used for stroking object outlines.
|
|
(defmagick* DrawGetStrokeColor :
|
|
_DrawingWand (c : _PixelWand = (NewPixelWand)) -> _void -> c)
|
|
|
|
;; DrawSetStrokeColor sets the color used for stroking object outlines.
|
|
(defmagick* DrawSetStrokeColor :
|
|
_DrawingWand _PixelWand -> _void)
|
|
|
|
;; DrawSetStrokePatternURL sets the pattern used for stroking object outlines.
|
|
(defmagick* DrawSetStrokePatternURL :
|
|
_DrawingWand (stroke-url : _string) -> _void)
|
|
|
|
;; DrawGetStrokeAntialias returns the current stroke antialias setting.
|
|
;; Stroked outlines are antialiased by default. When antialiasing is disabled
|
|
;; stroked pixels are thresholded to determine if the stroke color or
|
|
;; underlying canvas color should be used.
|
|
(defmagick* DrawGetStrokeAntialias :
|
|
_DrawingWand -> _bool)
|
|
|
|
;; DrawSetStrokeAntialias controls whether stroked outlines are antialiased.
|
|
;; Stroked outlines are antialiased by default. When antialiasing is disabled
|
|
;; stroked pixels are thresholded to determine if the stroke color or
|
|
;; underlying canvas color should be used.
|
|
(defmagick* DrawSetStrokeAntialias :
|
|
_DrawingWand (stroke-antialias? : _bool) -> _void)
|
|
|
|
;; DrawGetStrokeDashArray returns an array representing the pattern of dashes
|
|
;; and gaps used to stroke paths (see DrawSetStrokeDashArray).
|
|
(defmagick* DrawGetStrokeDashArray :
|
|
_DrawingWand (len : (_ptr o _ulong)) -> (_list o _double* len))
|
|
|
|
;; DrawSetStrokeDashArray specifies the pattern of dashes and gaps used to
|
|
;; stroke paths. The strokeDashArray represents an array of numbers that
|
|
;; specify the lengths of alternating dashes and gaps in pixels. If an odd
|
|
;; number of values is provided, then the list of values is repeated to yield
|
|
;; an even number of values. To remove an existing dash array, pass a zero
|
|
;; number_elements argument and null dash_array. A typical strokeDashArray_
|
|
;; array might contain the members 5 3 2.
|
|
(defmagick* DrawSetStrokeDashArray :
|
|
(d dash-list) ::
|
|
;; the function seem to always expect a 0.0-terminated vector
|
|
(dash-list : _? = (append dash-list '(0.0)))
|
|
(d : _DrawingWand)
|
|
(_ulong = (length dash-list)) (dash-list : (_list i _double*))
|
|
-> _void)
|
|
|
|
;; DrawGetStrokeDashOffset returns the offset into the dash pattern to start
|
|
;; the dash.
|
|
(defmagick* DrawGetStrokeDashOffset :
|
|
_DrawingWand -> _double*)
|
|
|
|
;; DrawSetStrokeDashOffset specifies the offset into the dash pattern to start
|
|
;; the dash.
|
|
(defmagick* DrawSetStrokeDashOffset :
|
|
_DrawingWand (dash-offset : _double*) -> _void)
|
|
|
|
;; DrawGetStrokeLineCap returns the shape to be used at the end of open
|
|
;; subpaths when they are stroked. Values of LineCap are UndefinedCap,
|
|
;; ButtCap, RoundCap, and SquareCap.
|
|
(defmagick* DrawGetStrokeLineCap :
|
|
_DrawingWand -> _LineCap)
|
|
|
|
;; DrawSetStrokeLineCap specifies the shape to be used at the end of open
|
|
;; subpaths when they are stroked. Values of LineCap are UndefinedCap,
|
|
;; ButtCap, RoundCap, and SquareCap.
|
|
(defmagick* DrawSetStrokeLineCap :
|
|
_DrawingWand _LineCap -> _void)
|
|
|
|
;; DrawGetStrokeLineJoin returns the shape to be used at the corners of paths
|
|
;; (or other vector shapes) when they are stroked. Values of LineJoin are
|
|
;; UndefinedJoin, MiterJoin, RoundJoin, and BevelJoin.
|
|
(defmagick* DrawGetStrokeLineJoin :
|
|
_DrawingWand -> _LineJoin)
|
|
|
|
;; DrawSetStrokeLineJoin specifies the shape to be used at the corners of paths
|
|
;; (or other vector shapes) when they are stroked. Values of LineJoin are
|
|
;; UndefinedJoin, MiterJoin, RoundJoin, and BevelJoin.
|
|
(defmagick* DrawSetStrokeLineJoin :
|
|
_DrawingWand _LineJoin -> _void)
|
|
|
|
;; DrawGetStrokeMiterLimit returns the miter limit. When two line segments
|
|
;; meet at a sharp angle and miter joins have been specified for 'lineJoin', it
|
|
;; is possible for the miter to extend far beyond the thickness of the line
|
|
;; stroking the path. The miterLimit' imposes a limit on the ratio of the
|
|
;; miter length to the 'lineWidth'.
|
|
(defmagick* DrawGetStrokeMiterLimit :
|
|
_DrawingWand -> _ulong)
|
|
|
|
;; DrawSetStrokeMiterLimit specifies the miter limit. When two line segments
|
|
;; meet at a sharp angle and miter joins have been specified for 'lineJoin', it
|
|
;; is possible for the miter to extend far beyond the thickness of the line
|
|
;; stroking the path. The miterLimit' imposes a limit on the ratio of the
|
|
;; miter length to the 'lineWidth'.
|
|
(defmagick* DrawSetStrokeMiterLimit :
|
|
_DrawingWand (miterlimit : _ulong) -> _void)
|
|
|
|
;; DrawGetStrokeOpacity returns the opacity of stroked object outlines.
|
|
(defmagick* DrawGetStrokeOpacity :
|
|
_DrawingWand -> _double*)
|
|
|
|
;; DrawSetStrokeOpacity specifies the opacity of stroked object outlines.
|
|
(defmagick* DrawSetStrokeOpacity :
|
|
_DrawingWand (stroke-opacity : _double*) -> _void)
|
|
|
|
;; DrawGetStrokeWidth returns the width of the stroke used to draw object
|
|
;; outlines.
|
|
(defmagick* DrawGetStrokeWidth :
|
|
_DrawingWand -> _double*)
|
|
|
|
;; DrawSetStrokeWidth sets the width of the stroke used to draw object
|
|
;; outlines.
|
|
(defmagick* DrawSetStrokeWidth :
|
|
_DrawingWand (stroke-width : _double*) -> _void)
|
|
|
|
;; DrawGetTextAntialias returns the current text antialias setting, which
|
|
;; determines whether text is antialiased. Text is antialiased by default.
|
|
(defmagick* DrawGetTextAntialias :
|
|
_DrawingWand -> _bool)
|
|
|
|
;; DrawSetTextAntialias controls whether text is antialiased. Text is
|
|
;; antialiased by default.
|
|
(defmagick* DrawSetTextAntialias :
|
|
_DrawingWand (text-antialias? : _bool) -> _void)
|
|
|
|
;; DrawGetTextDecoration returns the decoration applied when annotating with
|
|
;; text.
|
|
(defmagick* DrawGetTextDecoration :
|
|
_DrawingWand -> _DecorationType)
|
|
|
|
;; DrawSetTextDecoration specifies a decoration to be applied when annotating
|
|
;; with text.
|
|
(defmagick* DrawSetTextDecoration :
|
|
_DrawingWand _DecorationType -> _void)
|
|
|
|
;; DrawGetTextEncoding returns a null-terminated string which specifies the
|
|
;; code set used for text annotations.
|
|
(defmagick* DrawGetTextEncoding :
|
|
_DrawingWand -> _string)
|
|
|
|
;; DrawSetTextEncoding specifies specifies the code set to use for text
|
|
;; annotations. The only character encoding which may be specified at this
|
|
;; time is "UTF-8" for representing Unicode as a sequence of bytes. Specify an
|
|
;; empty string to set text encoding to the system's default. Successful text
|
|
;; annotation using Unicode may require fonts designed to support Unicode.
|
|
(defmagick* DrawSetTextEncoding :
|
|
_DrawingWand (encoding : _string) -> _void)
|
|
|
|
;; DrawGetTextUnderColor returns the color of a background rectangle to place
|
|
;; under text annotations.
|
|
(defmagick* DrawGetTextUnderColor :
|
|
_DrawingWand (c : _PixelWand = (NewPixelWand)) -> _void -> c)
|
|
|
|
;; DrawSetTextUnderColor specifies the color of a background rectangle to place
|
|
;; under text annotations.
|
|
(defmagick* DrawSetTextUnderColor :
|
|
_DrawingWand _PixelWand -> _void)
|
|
|
|
;; DrawTranslate applies a translation to the current coordinate system which
|
|
;; moves the coordinate system origin to the specified coordinate.
|
|
(defmagick* DrawTranslate :
|
|
_DrawingWand (x : _double*) (y : _double*) -> _void)
|
|
|
|
;; DrawSetViewbox sets the overall canvas size to be recorded with the drawing
|
|
;; vector data. Usually this will be specified using the same size as the
|
|
;; canvas image. When the vector data is saved to SVG or MVG formats, the
|
|
;; viewbox is use to specify the size of the canvas image that a viewer will
|
|
;; render the vector data on.
|
|
(defmagick* DrawSetViewbox :
|
|
_DrawingWand (x1 : _ulong) (y1 : _ulong) (x2 : _ulong) (y2 : _ulong)
|
|
-> _void)
|
|
|
|
;; NewDrawingWand returns a draw wand required for all other methods in the
|
|
;; API.
|
|
(defmagick* NewDrawingWand :
|
|
-> _DrawingWand)
|
|
|
|
;; ===== Misc APIs ============================================================
|
|
|
|
;; These are not part of the Wand API, but they are used by it so we need
|
|
;; destructor functions when collecting them.
|
|
|
|
;; DestroyImage dereferences an image, deallocating memory associated with the
|
|
;; image if the reference count becomes zero.
|
|
(defmagick DestroyImage :
|
|
_Image -> _void)
|
|
|
|
(defmagick DestroyDrawInfo :
|
|
_DrawInfo -> _void)
|