API Reference

Contents

Blob Class

class pgmagick.Blob(*args)[source]
base64((Blob)arg1, (str)arg2) → None :
C++ signature :
void base64(Magick::Blob {lvalue},std::string)

base64( (Blob)arg1) -> str :

C++ signature :
std::string base64(Magick::Blob {lvalue})
data

get_blob_data( (Blob)arg1) -> str :

C++ signature :
std::string get_blob_data(Magick::Blob)
length((Blob)arg1) → int :
C++ signature :
unsigned int length(Magick::Blob {lvalue})
update((Blob)arg1, (str)arg2) → None :
C++ signature :
void update(Magick::Blob {lvalue},std::string)
updateNoCopy((Blob)arg1, (object)arg2, (int)arg3[, (Allocator)arg4]) → None :
C++ signature :
void updateNoCopy(Magick::Blob {lvalue},void*,unsigned int [,Magick::Blob::Allocator])

Color Class

class pgmagick.Color[source]
alpha((Color)arg1, (float)arg2) → None :
C++ signature :
void alpha(Magick::Color {lvalue},double)

alpha( (Color)arg1) -> float :

C++ signature :
double alpha(Magick::Color {lvalue})
alphaQuantum((Color)arg1, (int)arg2) → None :
C++ signature :
void alphaQuantum(Magick::Color {lvalue},unsigned char)

alphaQuantum( (Color)arg1) -> int :

C++ signature :
unsigned char alphaQuantum(Magick::Color {lvalue})
blueQuantum((Color)arg1, (int)arg2) → None :
C++ signature :
void blueQuantum(Magick::Color {lvalue},unsigned char)

blueQuantum( (Color)arg1) -> int :

C++ signature :
unsigned char blueQuantum(Magick::Color {lvalue})
greenQuantum((Color)arg1, (int)arg2) → None :
C++ signature :
void greenQuantum(Magick::Color {lvalue},unsigned char)

greenQuantum( (Color)arg1) -> int :

C++ signature :
unsigned char greenQuantum(Magick::Color {lvalue})
intensity((Color)arg1) → float :
C++ signature :
double intensity(Magick::Color {lvalue})
isValid((Color)arg1, (bool)arg2) → None :
C++ signature :
void isValid(Magick::Color {lvalue},bool)

isValid( (Color)arg1) -> bool :

C++ signature :
bool isValid(Magick::Color {lvalue})
redQuantum((Color)arg1, (int)arg2) → None :
C++ signature :
void redQuantum(Magick::Color {lvalue},unsigned char)

redQuantum( (Color)arg1) -> int :

C++ signature :
unsigned char redQuantum(Magick::Color {lvalue})
scaleDoubleToQuantum((float)arg1) → int :
C++ signature :
unsigned char scaleDoubleToQuantum(double)
scaleQuantumToDouble((int)arg1) → float :
C++ signature :
double scaleQuantumToDouble(unsigned char)

scaleQuantumToDouble( (float)arg1) -> float :

C++ signature :
double scaleQuantumToDouble(double)
to_Magick_PixelPacket((Color)arg1) → object :
C++ signature :
MagickLib::_PixelPacket to_Magick_PixelPacket(Magick::Color {lvalue})
to_std_string((Color)arg1) → str :
C++ signature :
std::string to_std_string(Magick::Color {lvalue})

ColorGray Class

class pgmagick.ColorGray[source]
shade((ColorGray)arg1) → float :
C++ signature :
double shade(Magick::ColorGray {lvalue})

shade( (ColorGray)arg1, (float)arg2) -> None :

C++ signature :
void shade(Magick::ColorGray {lvalue},double)

ColorHSL Class

class pgmagick.ColorHSL[source]
hue((ColorHSL)arg1) → float :
C++ signature :
double hue(Magick::ColorHSL {lvalue})

hue( (ColorHSL)arg1, (float)arg2) -> None :

C++ signature :
void hue(Magick::ColorHSL {lvalue},double)
luminosity((ColorHSL)arg1) → float :
C++ signature :
double luminosity(Magick::ColorHSL {lvalue})

luminosity( (ColorHSL)arg1, (float)arg2) -> None :

C++ signature :
void luminosity(Magick::ColorHSL {lvalue},double)
saturation((ColorHSL)arg1) → float :
C++ signature :
double saturation(Magick::ColorHSL {lvalue})

saturation( (ColorHSL)arg1, (float)arg2) -> None :

C++ signature :
void saturation(Magick::ColorHSL {lvalue},double)

ColorMono Class

class pgmagick.ColorMono[source]
mono((ColorMono)arg1, (bool)arg2) → None :
C++ signature :
void mono(Magick::ColorMono {lvalue},bool)

mono( (ColorMono)arg1) -> bool :

C++ signature :
bool mono(Magick::ColorMono {lvalue})

ColorRGB Class

class pgmagick.ColorRGB[source]
blue((ColorRGB)arg1, (float)arg2) → None :
C++ signature :
void blue(Magick::ColorRGB {lvalue},double)

blue( (ColorRGB)arg1) -> float :

C++ signature :
double blue(Magick::ColorRGB {lvalue})
green((ColorRGB)arg1, (float)arg2) → None :
C++ signature :
void green(Magick::ColorRGB {lvalue},double)

green( (ColorRGB)arg1) -> float :

C++ signature :
double green(Magick::ColorRGB {lvalue})
red((ColorRGB)arg1, (float)arg2) → None :
C++ signature :
void red(Magick::ColorRGB {lvalue},double)

red( (ColorRGB)arg1) -> float :

C++ signature :
double red(Magick::ColorRGB {lvalue})

ColorYUV Class

class pgmagick.ColorYUV[source]
u((ColorYUV)arg1, (float)arg2) → None :
C++ signature :
void u(Magick::ColorYUV {lvalue},double)

u( (ColorYUV)arg1) -> float :

C++ signature :
double u(Magick::ColorYUV {lvalue})
v((ColorYUV)arg1, (float)arg2) → None :
C++ signature :
void v(Magick::ColorYUV {lvalue},double)

v( (ColorYUV)arg1) -> float :

C++ signature :
double v(Magick::ColorYUV {lvalue})
y((ColorYUV)arg1, (float)arg2) → None :
C++ signature :
void y(Magick::ColorYUV {lvalue},double)

y( (ColorYUV)arg1) -> float :

C++ signature :
double y(Magick::ColorYUV {lvalue})

Coordinate Class

class pgmagick.Coordinate[source]
x((Coordinate)arg1, (float)arg2) → None :
C++ signature :
void x(Magick::Coordinate {lvalue},double)

x( (Coordinate)arg1) -> float :

C++ signature :
double x(Magick::Coordinate {lvalue})
y((Coordinate)arg1, (float)arg2) → None :
C++ signature :
void y(Magick::Coordinate {lvalue},double)

y( (Coordinate)arg1) -> float :

C++ signature :
double y(Magick::Coordinate {lvalue})

CoordinateList Class

class pgmagick.CoordinateList[source]
append((CoordinateList)arg1, (Coordinate)arg2) → None :
C++ signature :
void append(std::list<Magick::Coordinate, std::allocator<Magick::Coordinate> > {lvalue},Magick::Coordinate)
count((CoordinateList)arg1) → int :
C++ signature :
unsigned int count(std::list<Magick::Coordinate, std::allocator<Magick::Coordinate> > {lvalue})
pop((CoordinateList)arg1) → None :
C++ signature :
void pop(std::list<Magick::Coordinate, std::allocator<Magick::Coordinate> > {lvalue})
pop_back((CoordinateList)arg1) → None :
C++ signature :
void pop_back(std::list<Magick::Coordinate, std::allocator<Magick::Coordinate> > {lvalue})
push_back((CoordinateList)arg1, (Coordinate)arg2) → None :
C++ signature :
void push_back(std::list<Magick::Coordinate, std::allocator<Magick::Coordinate> > {lvalue},Magick::Coordinate)
remove((CoordinateList)arg1, (Coordinate)arg2) → None :
C++ signature :
void remove(std::list<Magick::Coordinate, std::allocator<Magick::Coordinate> > {lvalue},Magick::Coordinate)
reverse((CoordinateList)arg1) → None :
C++ signature :
void reverse(std::list<Magick::Coordinate, std::allocator<Magick::Coordinate> > {lvalue})

Drawable Class

class pgmagick.Drawable[source]

DrawableAffine Class

class pgmagick.DrawableAffine[source]
rx((DrawableAffine)arg1, (float)arg2) → None :
C++ signature :
void rx(Magick::DrawableAffine {lvalue},double)

rx( (DrawableAffine)arg1) -> float :

C++ signature :
double rx(Magick::DrawableAffine {lvalue})
ry((DrawableAffine)arg1, (float)arg2) → None :
C++ signature :
void ry(Magick::DrawableAffine {lvalue},double)

ry( (DrawableAffine)arg1) -> float :

C++ signature :
double ry(Magick::DrawableAffine {lvalue})
sx((DrawableAffine)arg1, (float)arg2) → None :
C++ signature :
void sx(Magick::DrawableAffine {lvalue},double)

sx( (DrawableAffine)arg1) -> float :

C++ signature :
double sx(Magick::DrawableAffine {lvalue})
sy((DrawableAffine)arg1, (float)arg2) → None :
C++ signature :
void sy(Magick::DrawableAffine {lvalue},double)

sy( (DrawableAffine)arg1) -> float :

C++ signature :
double sy(Magick::DrawableAffine {lvalue})
tx((DrawableAffine)arg1, (float)arg2) → None :
C++ signature :
void tx(Magick::DrawableAffine {lvalue},double)

tx( (DrawableAffine)arg1) -> float :

C++ signature :
double tx(Magick::DrawableAffine {lvalue})
ty((DrawableAffine)arg1, (float)arg2) → None :
C++ signature :
void ty(Magick::DrawableAffine {lvalue},double)

ty( (DrawableAffine)arg1) -> float :

C++ signature :
double ty(Magick::DrawableAffine {lvalue})

DrawableArc Class

class pgmagick.DrawableArc[source]
endDegrees((DrawableArc)arg1, (float)arg2) → None :
C++ signature :
void endDegrees(Magick::DrawableArc {lvalue},double)

endDegrees( (DrawableArc)arg1) -> float :

C++ signature :
double endDegrees(Magick::DrawableArc {lvalue})
endX((DrawableArc)arg1, (float)arg2) → None :
C++ signature :
void endX(Magick::DrawableArc {lvalue},double)

endX( (DrawableArc)arg1) -> float :

C++ signature :
double endX(Magick::DrawableArc {lvalue})
endY((DrawableArc)arg1, (float)arg2) → None :
C++ signature :
void endY(Magick::DrawableArc {lvalue},double)

endY( (DrawableArc)arg1) -> float :

C++ signature :
double endY(Magick::DrawableArc {lvalue})
startDegrees((DrawableArc)arg1, (float)arg2) → None :
C++ signature :
void startDegrees(Magick::DrawableArc {lvalue},double)

startDegrees( (DrawableArc)arg1) -> float :

C++ signature :
double startDegrees(Magick::DrawableArc {lvalue})
startX((DrawableArc)arg1, (float)arg2) → None :
C++ signature :
void startX(Magick::DrawableArc {lvalue},double)

startX( (DrawableArc)arg1) -> float :

C++ signature :
double startX(Magick::DrawableArc {lvalue})
startY((DrawableArc)arg1, (float)arg2) → None :
C++ signature :
void startY(Magick::DrawableArc {lvalue},double)

startY( (DrawableArc)arg1) -> float :

C++ signature :
double startY(Magick::DrawableArc {lvalue})

DrawableBezier Class

class pgmagick.DrawableBezier[source]

DrawableCircle Class

class pgmagick.DrawableCircle[source]
originX((DrawableCircle)arg1, (float)arg2) → None :
C++ signature :
void originX(Magick::DrawableCircle {lvalue},double)

originX( (DrawableCircle)arg1) -> float :

C++ signature :
double originX(Magick::DrawableCircle {lvalue})
originY((DrawableCircle)arg1, (float)arg2) → None :
C++ signature :
void originY(Magick::DrawableCircle {lvalue},double)

originY( (DrawableCircle)arg1) -> float :

C++ signature :
double originY(Magick::DrawableCircle {lvalue})
perimX((DrawableCircle)arg1, (float)arg2) → None :
C++ signature :
void perimX(Magick::DrawableCircle {lvalue},double)

perimX( (DrawableCircle)arg1) -> float :

C++ signature :
double perimX(Magick::DrawableCircle {lvalue})
perimY((DrawableCircle)arg1, (float)arg2) → None :
C++ signature :
void perimY(Magick::DrawableCircle {lvalue},double)

perimY( (DrawableCircle)arg1) -> float :

C++ signature :
double perimY(Magick::DrawableCircle {lvalue})

DrawableClipPath Class

class pgmagick.DrawableClipPath[source]
clip_path((DrawableClipPath)arg1, (str)arg2) → None :
C++ signature :
void clip_path(Magick::DrawableClipPath {lvalue},std::string)

clip_path( (DrawableClipPath)arg1) -> str :

C++ signature :
std::string clip_path(Magick::DrawableClipPath {lvalue})

DrawableColor Class

class pgmagick.DrawableColor[source]
paintMethod((DrawableColor)arg1, (PaintMethod)arg2) → None :
C++ signature :
void paintMethod(Magick::DrawableColor {lvalue},MagickLib::PaintMethod)

paintMethod( (DrawableColor)arg1) -> PaintMethod :

C++ signature :
MagickLib::PaintMethod paintMethod(Magick::DrawableColor {lvalue})
x((DrawableColor)arg1, (float)arg2) → None :
C++ signature :
void x(Magick::DrawableColor {lvalue},double)

x( (DrawableColor)arg1) -> float :

C++ signature :
double x(Magick::DrawableColor {lvalue})
y((DrawableColor)arg1, (float)arg2) → None :
C++ signature :
void y(Magick::DrawableColor {lvalue},double)

y( (DrawableColor)arg1) -> float :

C++ signature :
double y(Magick::DrawableColor {lvalue})

DrawableCompositeImage Class

class pgmagick.DrawableCompositeImage[source]
composition((DrawableCompositeImage)arg1, (CompositeOperator)arg2) → None :
C++ signature :
void composition(Magick::DrawableCompositeImage {lvalue},MagickLib::CompositeOperator)

composition( (DrawableCompositeImage)arg1) -> CompositeOperator :

C++ signature :
MagickLib::CompositeOperator composition(Magick::DrawableCompositeImage {lvalue})
filename((DrawableCompositeImage)arg1, (str)arg2) → None :
C++ signature :
void filename(Magick::DrawableCompositeImage {lvalue},std::string)

filename( (DrawableCompositeImage)arg1) -> str :

C++ signature :
std::string filename(Magick::DrawableCompositeImage {lvalue})
height((DrawableCompositeImage)arg1, (float)arg2) → None :
C++ signature :
void height(Magick::DrawableCompositeImage {lvalue},double)

height( (DrawableCompositeImage)arg1) -> float :

C++ signature :
double height(Magick::DrawableCompositeImage {lvalue})
image((DrawableCompositeImage)arg1, (Image)arg2) → None :
C++ signature :
void image(Magick::DrawableCompositeImage {lvalue},Magick::Image)

image( (DrawableCompositeImage)arg1) -> Image :

C++ signature :
Magick::Image image(Magick::DrawableCompositeImage {lvalue})
magick((DrawableCompositeImage)arg1, (str)arg2) → None :
C++ signature :
void magick(Magick::DrawableCompositeImage {lvalue},std::string)

magick( (DrawableCompositeImage)arg1) -> str :

C++ signature :
std::string magick(Magick::DrawableCompositeImage {lvalue})
width((DrawableCompositeImage)arg1, (float)arg2) → None :
C++ signature :
void width(Magick::DrawableCompositeImage {lvalue},double)

width( (DrawableCompositeImage)arg1) -> float :

C++ signature :
double width(Magick::DrawableCompositeImage {lvalue})
x((DrawableCompositeImage)arg1, (float)arg2) → None :
C++ signature :
void x(Magick::DrawableCompositeImage {lvalue},double)

x( (DrawableCompositeImage)arg1) -> float :

C++ signature :
double x(Magick::DrawableCompositeImage {lvalue})
y((DrawableCompositeImage)arg1, (float)arg2) → None :
C++ signature :
void y(Magick::DrawableCompositeImage {lvalue},double)

y( (DrawableCompositeImage)arg1) -> float :

C++ signature :
double y(Magick::DrawableCompositeImage {lvalue})

DrawableDashArray Class

class pgmagick.DrawableDashArray[source]

DrawableDashOffset Class

class pgmagick.DrawableDashOffset[source]
offset((DrawableDashOffset)arg1, (float)arg2) → None :
C++ signature :
void offset(Magick::DrawableDashOffset {lvalue},double)

offset( (DrawableDashOffset)arg1) -> float :

C++ signature :
double offset(Magick::DrawableDashOffset {lvalue})

DrawableEllipse Class

class pgmagick.DrawableEllipse[source]
arcEnd((DrawableEllipse)arg1, (float)arg2) → None :
C++ signature :
void arcEnd(Magick::DrawableEllipse {lvalue},double)

arcEnd( (DrawableEllipse)arg1) -> float :

C++ signature :
double arcEnd(Magick::DrawableEllipse {lvalue})
arcStart((DrawableEllipse)arg1, (float)arg2) → None :
C++ signature :
void arcStart(Magick::DrawableEllipse {lvalue},double)

arcStart( (DrawableEllipse)arg1) -> float :

C++ signature :
double arcStart(Magick::DrawableEllipse {lvalue})
originX((DrawableEllipse)arg1, (float)arg2) → None :
C++ signature :
void originX(Magick::DrawableEllipse {lvalue},double)

originX( (DrawableEllipse)arg1) -> float :

C++ signature :
double originX(Magick::DrawableEllipse {lvalue})
originY((DrawableEllipse)arg1, (float)arg2) → None :
C++ signature :
void originY(Magick::DrawableEllipse {lvalue},double)

originY( (DrawableEllipse)arg1) -> float :

C++ signature :
double originY(Magick::DrawableEllipse {lvalue})
radiusX((DrawableEllipse)arg1, (float)arg2) → None :
C++ signature :
void radiusX(Magick::DrawableEllipse {lvalue},double)

radiusX( (DrawableEllipse)arg1) -> float :

C++ signature :
double radiusX(Magick::DrawableEllipse {lvalue})
radiusY((DrawableEllipse)arg1, (float)arg2) → None :
C++ signature :
void radiusY(Magick::DrawableEllipse {lvalue},double)

radiusY( (DrawableEllipse)arg1) -> float :

C++ signature :
double radiusY(Magick::DrawableEllipse {lvalue})

DrawableFillColor Class

class pgmagick.DrawableFillColor[source]
color((DrawableFillColor)arg1, (Color)arg2) → None :
C++ signature :
void color(Magick::DrawableFillColor {lvalue},Magick::Color)

color( (DrawableFillColor)arg1) -> Color :

C++ signature :
Magick::Color color(Magick::DrawableFillColor {lvalue})

DrawableFillOpacity Class

class pgmagick.DrawableFillOpacity[source]
opacity((DrawableFillOpacity)arg1, (float)arg2) → None :
C++ signature :
void opacity(Magick::DrawableFillOpacity {lvalue},double)

opacity( (DrawableFillOpacity)arg1) -> float :

C++ signature :
double opacity(Magick::DrawableFillOpacity {lvalue})

DrawableFillRule Class

class pgmagick.DrawableFillRule[source]
fillRule((DrawableFillRule)arg1, (FillRule)arg2) → None :
C++ signature :
void fillRule(Magick::DrawableFillRule {lvalue},MagickLib::FillRule)

fillRule( (DrawableFillRule)arg1) -> FillRule :

C++ signature :
MagickLib::FillRule fillRule(Magick::DrawableFillRule {lvalue})

DrawableFont Class

class pgmagick.DrawableFont[source]
font((DrawableFont)arg1, (str)arg2) → None :
C++ signature :
void font(Magick::DrawableFont {lvalue},std::string)

font( (DrawableFont)arg1) -> str :

C++ signature :
std::string font(Magick::DrawableFont {lvalue})

DrawableGravity Class

class pgmagick.DrawableGravity[source]
gravity((DrawableGravity)arg1, (GravityType)arg2) → None :
C++ signature :
void gravity(Magick::DrawableGravity {lvalue},MagickLib::GravityType)

gravity( (DrawableGravity)arg1) -> GravityType :

C++ signature :
MagickLib::GravityType gravity(Magick::DrawableGravity {lvalue})

DrawableLine Class

class pgmagick.DrawableLine[source]
endX((DrawableLine)arg1, (float)arg2) → None :
C++ signature :
void endX(Magick::DrawableLine {lvalue},double)

endX( (DrawableLine)arg1) -> float :

C++ signature :
double endX(Magick::DrawableLine {lvalue})
endY((DrawableLine)arg1, (float)arg2) → None :
C++ signature :
void endY(Magick::DrawableLine {lvalue},double)

endY( (DrawableLine)arg1) -> float :

C++ signature :
double endY(Magick::DrawableLine {lvalue})
startX((DrawableLine)arg1, (float)arg2) → None :
C++ signature :
void startX(Magick::DrawableLine {lvalue},double)

startX( (DrawableLine)arg1) -> float :

C++ signature :
double startX(Magick::DrawableLine {lvalue})
startY((DrawableLine)arg1, (float)arg2) → None :
C++ signature :
void startY(Magick::DrawableLine {lvalue},double)

startY( (DrawableLine)arg1) -> float :

C++ signature :
double startY(Magick::DrawableLine {lvalue})

DrawableList Class

class pgmagick.DrawableList[source]
append((DrawableList)arg1, (Drawable)arg2) → None :
C++ signature :
void append(std::list<Magick::Drawable, std::allocator<Magick::Drawable> > {lvalue},Magick::Drawable)
count((DrawableList)arg1) → int :
C++ signature :
unsigned int count(std::list<Magick::Drawable, std::allocator<Magick::Drawable> > {lvalue})
pop((DrawableList)arg1) → None :
C++ signature :
void pop(std::list<Magick::Drawable, std::allocator<Magick::Drawable> > {lvalue})
pop_back((DrawableList)arg1) → None :
C++ signature :
void pop_back(std::list<Magick::Drawable, std::allocator<Magick::Drawable> > {lvalue})
push_back((DrawableList)arg1, (Drawable)arg2) → None :
C++ signature :
void push_back(std::list<Magick::Drawable, std::allocator<Magick::Drawable> > {lvalue},Magick::Drawable)
remove((DrawableList)arg1, (Drawable)arg2) → None :
C++ signature :
void remove(std::list<Magick::Drawable, std::allocator<Magick::Drawable> > {lvalue},Magick::Drawable)
reverse((DrawableList)arg1) → None :
C++ signature :
void reverse(std::list<Magick::Drawable, std::allocator<Magick::Drawable> > {lvalue})

DrawableMatte Class

class pgmagick.DrawableMatte[source]
paintMethod((DrawableMatte)arg1, (PaintMethod)arg2) → None :
C++ signature :
void paintMethod(Magick::DrawableMatte {lvalue},MagickLib::PaintMethod)

paintMethod( (DrawableMatte)arg1) -> PaintMethod :

C++ signature :
MagickLib::PaintMethod paintMethod(Magick::DrawableMatte {lvalue})
x((DrawableMatte)arg1, (float)arg2) → None :
C++ signature :
void x(Magick::DrawableMatte {lvalue},double)

x( (DrawableMatte)arg1) -> float :

C++ signature :
double x(Magick::DrawableMatte {lvalue})
y((DrawableMatte)arg1, (float)arg2) → None :
C++ signature :
void y(Magick::DrawableMatte {lvalue},double)

y( (DrawableMatte)arg1) -> float :

C++ signature :
double y(Magick::DrawableMatte {lvalue})

DrawableMiterLimit Class

class pgmagick.DrawableMiterLimit[source]
miterlimit((DrawableMiterLimit)arg1, (int)arg2) → None :
C++ signature :
void miterlimit(Magick::DrawableMiterLimit {lvalue},unsigned int)

miterlimit( (DrawableMiterLimit)arg1) -> int :

C++ signature :
unsigned int miterlimit(Magick::DrawableMiterLimit {lvalue})

DrawablePath Class

class pgmagick.DrawablePath[source]

DrawablePoint Class

class pgmagick.DrawablePoint[source]
x((DrawablePoint)arg1, (float)arg2) → None :
C++ signature :
void x(Magick::DrawablePoint {lvalue},double)

x( (DrawablePoint)arg1) -> float :

C++ signature :
double x(Magick::DrawablePoint {lvalue})
y((DrawablePoint)arg1, (float)arg2) → None :
C++ signature :
void y(Magick::DrawablePoint {lvalue},double)

y( (DrawablePoint)arg1) -> float :

C++ signature :
double y(Magick::DrawablePoint {lvalue})

DrawablePointSize Class

class pgmagick.DrawablePointSize[source]
pointSize((DrawablePointSize)arg1, (float)arg2) → None :
C++ signature :
void pointSize(Magick::DrawablePointSize {lvalue},double)

pointSize( (DrawablePointSize)arg1) -> float :

C++ signature :
double pointSize(Magick::DrawablePointSize {lvalue})

DrawablePolygon Class

class pgmagick.DrawablePolygon[source]

DrawablePolyline Class

class pgmagick.DrawablePolyline[source]

DrawablePopClipPath Class

class pgmagick.DrawablePopClipPath[source]

DrawablePopGraphicContext Class

class pgmagick.DrawablePopGraphicContext[source]

DrawablePopPattern Class

class pgmagick.DrawablePopPattern[source]

DrawablePushClipPath Class

class pgmagick.DrawablePushClipPath[source]

DrawablePushGraphicContext Class

class pgmagick.DrawablePushGraphicContext[source]

DrawablePushPattern Class

class pgmagick.DrawablePushPattern[source]

DrawableRectangle Class

class pgmagick.DrawableRectangle[source]
lowerRightX((DrawableRectangle)arg1, (float)arg2) → None :
C++ signature :
void lowerRightX(Magick::DrawableRectangle {lvalue},double)

lowerRightX( (DrawableRectangle)arg1) -> float :

C++ signature :
double lowerRightX(Magick::DrawableRectangle {lvalue})
lowerRightY((DrawableRectangle)arg1, (float)arg2) → None :
C++ signature :
void lowerRightY(Magick::DrawableRectangle {lvalue},double)

lowerRightY( (DrawableRectangle)arg1) -> float :

C++ signature :
double lowerRightY(Magick::DrawableRectangle {lvalue})
upperLeftX((DrawableRectangle)arg1, (float)arg2) → None :
C++ signature :
void upperLeftX(Magick::DrawableRectangle {lvalue},double)

upperLeftX( (DrawableRectangle)arg1) -> float :

C++ signature :
double upperLeftX(Magick::DrawableRectangle {lvalue})
upperLeftY((DrawableRectangle)arg1, (float)arg2) → None :
C++ signature :
void upperLeftY(Magick::DrawableRectangle {lvalue},double)

upperLeftY( (DrawableRectangle)arg1) -> float :

C++ signature :
double upperLeftY(Magick::DrawableRectangle {lvalue})

DrawableRotation Class

class pgmagick.DrawableRotation[source]
angle((DrawableRotation)arg1, (float)arg2) → None :
C++ signature :
void angle(Magick::DrawableRotation {lvalue},double)

angle( (DrawableRotation)arg1) -> float :

C++ signature :
double angle(Magick::DrawableRotation {lvalue})

DrawableRoundRectangle Class

class pgmagick.DrawableRoundRectangle[source]
centerX((DrawableRoundRectangle)arg1, (float)arg2) → None :
C++ signature :
void centerX(Magick::DrawableRoundRectangle {lvalue},double)

centerX( (DrawableRoundRectangle)arg1) -> float :

C++ signature :
double centerX(Magick::DrawableRoundRectangle {lvalue})
centerY((DrawableRoundRectangle)arg1, (float)arg2) → None :
C++ signature :
void centerY(Magick::DrawableRoundRectangle {lvalue},double)

centerY( (DrawableRoundRectangle)arg1) -> float :

C++ signature :
double centerY(Magick::DrawableRoundRectangle {lvalue})
cornerHeight((DrawableRoundRectangle)arg1, (float)arg2) → None :
C++ signature :
void cornerHeight(Magick::DrawableRoundRectangle {lvalue},double)

cornerHeight( (DrawableRoundRectangle)arg1) -> float :

C++ signature :
double cornerHeight(Magick::DrawableRoundRectangle {lvalue})
cornerWidth((DrawableRoundRectangle)arg1, (float)arg2) → None :
C++ signature :
void cornerWidth(Magick::DrawableRoundRectangle {lvalue},double)

cornerWidth( (DrawableRoundRectangle)arg1) -> float :

C++ signature :
double cornerWidth(Magick::DrawableRoundRectangle {lvalue})
hight((DrawableRoundRectangle)arg1, (float)arg2) → None :
C++ signature :
void hight(Magick::DrawableRoundRectangle {lvalue},double)

hight( (DrawableRoundRectangle)arg1) -> float :

C++ signature :
double hight(Magick::DrawableRoundRectangle {lvalue})
width((DrawableRoundRectangle)arg1, (float)arg2) → None :
C++ signature :
void width(Magick::DrawableRoundRectangle {lvalue},double)

width( (DrawableRoundRectangle)arg1) -> float :

C++ signature :
double width(Magick::DrawableRoundRectangle {lvalue})

DrawableScaling Class

class pgmagick.DrawableScaling[source]
x((DrawableScaling)arg1, (float)arg2) → None :
C++ signature :
void x(Magick::DrawableScaling {lvalue},double)

x( (DrawableScaling)arg1) -> float :

C++ signature :
double x(Magick::DrawableScaling {lvalue})
y((DrawableScaling)arg1, (float)arg2) → None :
C++ signature :
void y(Magick::DrawableScaling {lvalue},double)

y( (DrawableScaling)arg1) -> float :

C++ signature :
double y(Magick::DrawableScaling {lvalue})

DrawableSkewX Class

class pgmagick.DrawableSkewX[source]
angle((DrawableSkewX)arg1, (float)arg2) → None :
C++ signature :
void angle(Magick::DrawableSkewX {lvalue},double)

angle( (DrawableSkewX)arg1) -> float :

C++ signature :
double angle(Magick::DrawableSkewX {lvalue})

DrawableSkewY Class

class pgmagick.DrawableSkewY[source]
angle((DrawableSkewY)arg1, (float)arg2) → None :
C++ signature :
void angle(Magick::DrawableSkewY {lvalue},double)

angle( (DrawableSkewY)arg1) -> float :

C++ signature :
double angle(Magick::DrawableSkewY {lvalue})

DrawableStrokeAntialias Class

class pgmagick.DrawableStrokeAntialias[source]
flag((DrawableStrokeAntialias)arg1, (bool)arg2) → None :
C++ signature :
void flag(Magick::DrawableStrokeAntialias {lvalue},bool)

flag( (DrawableStrokeAntialias)arg1) -> bool :

C++ signature :
bool flag(Magick::DrawableStrokeAntialias {lvalue})

DrawableStrokeColor Class

class pgmagick.DrawableStrokeColor[source]
color((DrawableStrokeColor)arg1, (Color)arg2) → None :
C++ signature :
void color(Magick::DrawableStrokeColor {lvalue},Magick::Color)

color( (DrawableStrokeColor)arg1) -> Color :

C++ signature :
Magick::Color color(Magick::DrawableStrokeColor {lvalue})

DrawableStrokeLineCap Class

class pgmagick.DrawableStrokeLineCap[source]
linecap((DrawableStrokeLineCap)arg1, (LineCap)arg2) → None :
C++ signature :
void linecap(Magick::DrawableStrokeLineCap {lvalue},MagickLib::LineCap)

linecap( (DrawableStrokeLineCap)arg1) -> LineCap :

C++ signature :
MagickLib::LineCap linecap(Magick::DrawableStrokeLineCap {lvalue})

DrawableStrokeLineJoin Class

class pgmagick.DrawableStrokeLineJoin[source]
linejoin((DrawableStrokeLineJoin)arg1, (LineJoin)arg2) → None :
C++ signature :
void linejoin(Magick::DrawableStrokeLineJoin {lvalue},MagickLib::LineJoin)

linejoin( (DrawableStrokeLineJoin)arg1) -> LineJoin :

C++ signature :
MagickLib::LineJoin linejoin(Magick::DrawableStrokeLineJoin {lvalue})

DrawableStrokeOpacity Class

class pgmagick.DrawableStrokeOpacity[source]
opacity((DrawableStrokeOpacity)arg1, (float)arg2) → None :
C++ signature :
void opacity(Magick::DrawableStrokeOpacity {lvalue},double)

opacity( (DrawableStrokeOpacity)arg1) -> float :

C++ signature :
double opacity(Magick::DrawableStrokeOpacity {lvalue})

DrawableStrokeWidth Class

class pgmagick.DrawableStrokeWidth[source]
width((DrawableStrokeWidth)arg1, (float)arg2) → None :
C++ signature :
void width(Magick::DrawableStrokeWidth {lvalue},double)

width( (DrawableStrokeWidth)arg1) -> float :

C++ signature :
double width(Magick::DrawableStrokeWidth {lvalue})

DrawableText Class

class pgmagick.DrawableText[source]
encoding((DrawableText)arg1, (str)arg2) → None :
C++ signature :
void encoding(Magick::DrawableText {lvalue},std::string)
text((DrawableText)arg1, (str)arg2) → None :
C++ signature :
void text(Magick::DrawableText {lvalue},std::string)

text( (DrawableText)arg1) -> str :

C++ signature :
std::string text(Magick::DrawableText {lvalue})
x((DrawableText)arg1, (float)arg2) → None :
C++ signature :
void x(Magick::DrawableText {lvalue},double)

x( (DrawableText)arg1) -> float :

C++ signature :
double x(Magick::DrawableText {lvalue})
y((DrawableText)arg1, (float)arg2) → None :
C++ signature :
void y(Magick::DrawableText {lvalue},double)

y( (DrawableText)arg1) -> float :

C++ signature :
double y(Magick::DrawableText {lvalue})

DrawableTextAntialias Class

class pgmagick.DrawableTextAntialias[source]
flag((DrawableTextAntialias)arg1, (bool)arg2) → None :
C++ signature :
void flag(Magick::DrawableTextAntialias {lvalue},bool)

flag( (DrawableTextAntialias)arg1) -> bool :

C++ signature :
bool flag(Magick::DrawableTextAntialias {lvalue})

DrawableTextDecoration Class

class pgmagick.DrawableTextDecoration[source]
decoration((DrawableTextDecoration)arg1, (DecorationType)arg2) → None :
C++ signature :
void decoration(Magick::DrawableTextDecoration {lvalue},MagickLib::DecorationType)

decoration( (DrawableTextDecoration)arg1) -> DecorationType :

C++ signature :
MagickLib::DecorationType decoration(Magick::DrawableTextDecoration {lvalue})

DrawableTextUnderColor Class

class pgmagick.DrawableTextUnderColor[source]
color((DrawableTextUnderColor)arg1, (Color)arg2) → None :
C++ signature :
void color(Magick::DrawableTextUnderColor {lvalue},Magick::Color)

color( (DrawableTextUnderColor)arg1) -> Color :

C++ signature :
Magick::Color color(Magick::DrawableTextUnderColor {lvalue})

DrawableTranslation Class

class pgmagick.DrawableTranslation[source]
x((DrawableTranslation)arg1, (float)arg2) → None :
C++ signature :
void x(Magick::DrawableTranslation {lvalue},double)

x( (DrawableTranslation)arg1) -> float :

C++ signature :
double x(Magick::DrawableTranslation {lvalue})
y((DrawableTranslation)arg1, (float)arg2) → None :
C++ signature :
void y(Magick::DrawableTranslation {lvalue},double)

y( (DrawableTranslation)arg1) -> float :

C++ signature :
double y(Magick::DrawableTranslation {lvalue})

DrawableViewbox Class

class pgmagick.DrawableViewbox[source]
x1((DrawableViewbox)arg1, (int)arg2) → None :
C++ signature :
void x1(Magick::DrawableViewbox {lvalue},unsigned long)

x1( (DrawableViewbox)arg1) -> int :

C++ signature :
unsigned long x1(Magick::DrawableViewbox {lvalue})
x2((DrawableViewbox)arg1, (int)arg2) → None :
C++ signature :
void x2(Magick::DrawableViewbox {lvalue},unsigned long)

x2( (DrawableViewbox)arg1) -> int :

C++ signature :
unsigned long x2(Magick::DrawableViewbox {lvalue})
y1((DrawableViewbox)arg1, (int)arg2) → None :
C++ signature :
void y1(Magick::DrawableViewbox {lvalue},unsigned long)

y1( (DrawableViewbox)arg1) -> int :

C++ signature :
unsigned long y1(Magick::DrawableViewbox {lvalue})
y2((DrawableViewbox)arg1, (int)arg2) → None :
C++ signature :
void y2(Magick::DrawableViewbox {lvalue},unsigned long)

y2( (DrawableViewbox)arg1) -> int :

C++ signature :
unsigned long y2(Magick::DrawableViewbox {lvalue})

Exception Class

class pgmagick.Exception[source]
what((Exception)arg1) → str :
C++ signature :
char const* what(Magick::Exception {lvalue})

what( (Exception)arg1) -> str :

C++ signature :
char const* what((anonymous namespace)::Magick_Exception_Wrapper {lvalue})

Geometry Class

class pgmagick.Geometry[source]
aspect((Geometry)arg1, (bool)arg2) → None :
C++ signature :
void aspect(Magick::Geometry {lvalue},bool)

aspect( (Geometry)arg1) -> bool :

C++ signature :
bool aspect(Magick::Geometry {lvalue})
greater((Geometry)arg1, (bool)arg2) → None :
C++ signature :
void greater(Magick::Geometry {lvalue},bool)

greater( (Geometry)arg1) -> bool :

C++ signature :
bool greater(Magick::Geometry {lvalue})
height((Geometry)arg1, (int)arg2) → None :
C++ signature :
void height(Magick::Geometry {lvalue},unsigned int)

height( (Geometry)arg1) -> int :

C++ signature :
unsigned int height(Magick::Geometry {lvalue})
isValid((Geometry)arg1, (bool)arg2) → None :
C++ signature :
void isValid(Magick::Geometry {lvalue},bool)

isValid( (Geometry)arg1) -> bool :

C++ signature :
bool isValid(Magick::Geometry {lvalue})
less((Geometry)arg1, (bool)arg2) → None :
C++ signature :
void less(Magick::Geometry {lvalue},bool)

less( (Geometry)arg1) -> bool :

C++ signature :
bool less(Magick::Geometry {lvalue})
percent((Geometry)arg1, (bool)arg2) → None :
C++ signature :
void percent(Magick::Geometry {lvalue},bool)

percent( (Geometry)arg1) -> bool :

C++ signature :
bool percent(Magick::Geometry {lvalue})
to_std_string((Geometry)arg1) → str :
C++ signature :
std::string to_std_string(Magick::Geometry {lvalue})
width((Geometry)arg1, (int)arg2) → None :
C++ signature :
void width(Magick::Geometry {lvalue},unsigned int)

width( (Geometry)arg1) -> int :

C++ signature :
unsigned int width(Magick::Geometry {lvalue})
xNegative((Geometry)arg1, (bool)arg2) → None :
C++ signature :
void xNegative(Magick::Geometry {lvalue},bool)

xNegative( (Geometry)arg1) -> bool :

C++ signature :
bool xNegative(Magick::Geometry {lvalue})
xOff((Geometry)arg1, (int)arg2) → None :
C++ signature :
void xOff(Magick::Geometry {lvalue},unsigned int)

xOff( (Geometry)arg1) -> int :

C++ signature :
unsigned int xOff(Magick::Geometry {lvalue})
yNegative((Geometry)arg1, (bool)arg2) → None :
C++ signature :
void yNegative(Magick::Geometry {lvalue},bool)

yNegative( (Geometry)arg1) -> bool :

C++ signature :
bool yNegative(Magick::Geometry {lvalue})
yOff((Geometry)arg1, (int)arg2) → None :
C++ signature :
void yOff(Magick::Geometry {lvalue},unsigned int)

yOff( (Geometry)arg1) -> int :

C++ signature :
unsigned int yOff(Magick::Geometry {lvalue})

Image Class

class pgmagick.Image[source]
adaptiveThreshold((Image)arg1, (int)arg2, (int)arg3[, (int)arg4]) → None :
C++ signature :
void adaptiveThreshold(Magick::Image {lvalue},unsigned int,unsigned int [,unsigned int])
addNoise((Image)arg1, (NoiseType)arg2) → None :
C++ signature :
void addNoise(Magick::Image {lvalue},MagickLib::NoiseType)
addNoiseChannel((Image)arg1, (ChannelType)arg2, (NoiseType)arg3) → None :
C++ signature :
void addNoiseChannel(Magick::Image {lvalue},MagickLib::ChannelType,MagickLib::NoiseType)
adjoin((Image)arg1, (bool)arg2) → None :
C++ signature :
void adjoin(Magick::Image {lvalue},bool)

adjoin( (Image)arg1) -> bool :

C++ signature :
bool adjoin(Magick::Image {lvalue})
affineTransform((Image)arg1, (DrawableAffine)arg2) → None :
C++ signature :
void affineTransform(Magick::Image {lvalue},Magick::DrawableAffine)
animationDelay((Image)arg1, (int)arg2) → None :
C++ signature :
void animationDelay(Magick::Image {lvalue},unsigned int)

animationDelay( (Image)arg1) -> int :

C++ signature :
unsigned int animationDelay(Magick::Image {lvalue})
animationIterations((Image)arg1, (int)arg2) → None :
C++ signature :
void animationIterations(Magick::Image {lvalue},unsigned int)

animationIterations( (Image)arg1) -> int :

C++ signature :
unsigned int animationIterations(Magick::Image {lvalue})
annotate((Image)arg1, (str)arg2, (Geometry)arg3) → None :
C++ signature :
void annotate(Magick::Image {lvalue},std::string,Magick::Geometry)

annotate( (Image)arg1, (str)arg2, (Geometry)arg3, (GravityType)arg4) -> None :

C++ signature :
void annotate(Magick::Image {lvalue},std::string,Magick::Geometry,MagickLib::GravityType)

annotate( (Image)arg1, (str)arg2, (Geometry)arg3, (GravityType)arg4, (float)arg5) -> None :

C++ signature :
void annotate(Magick::Image {lvalue},std::string,Magick::Geometry,MagickLib::GravityType,double)

annotate( (Image)arg1, (str)arg2, (GravityType)arg3) -> None :

C++ signature :
void annotate(Magick::Image {lvalue},std::string,MagickLib::GravityType)
antiAlias((Image)arg1, (bool)arg2) → None :
C++ signature :
void antiAlias(Magick::Image {lvalue},bool)

antiAlias( (Image)arg1) -> bool :

C++ signature :
bool antiAlias(Magick::Image {lvalue})
attribute((Image)arg1, (str)arg2, (str)arg3) → None :
C++ signature :
void attribute(Magick::Image {lvalue},std::string,std::string)

attribute( (Image)arg1, (str)arg2) -> str :

C++ signature :
std::string attribute(Magick::Image {lvalue},std::string)
backgroundColor((Image)arg1, (Color)arg2) → None :
C++ signature :
void backgroundColor(Magick::Image {lvalue},Magick::Color)

backgroundColor( (Image)arg1) -> Color :

C++ signature :
Magick::Color backgroundColor(Magick::Image {lvalue})
backgroundTexture((Image)arg1, (str)arg2) → None :
C++ signature :
void backgroundTexture(Magick::Image {lvalue},std::string)

backgroundTexture( (Image)arg1) -> str :

C++ signature :
std::string backgroundTexture(Magick::Image {lvalue})
baseColumns((Image)arg1) → int :
C++ signature :
unsigned int baseColumns(Magick::Image {lvalue})
baseFilename((Image)arg1) → str :
C++ signature :
std::string baseFilename(Magick::Image {lvalue})
baseRows((Image)arg1) → int :
C++ signature :
unsigned int baseRows(Magick::Image {lvalue})
blur((Image)arg1[, (float)arg2[, (float)arg3]]) → None :
C++ signature :
void blur(Magick::Image {lvalue} [,double [,double]])
blurChannel((Image)arg1, (ChannelType)arg2[, (float)arg3[, (float)arg4]]) → None :
C++ signature :
void blurChannel(Magick::Image {lvalue},MagickLib::ChannelType [,double [,double]])
border((Image)arg1[, (Geometry)arg2]) → None :
C++ signature :
void border(Magick::Image {lvalue} [,Magick::Geometry])
borderColor((Image)arg1, (Color)arg2) → None :
C++ signature :
void borderColor(Magick::Image {lvalue},Magick::Color)

borderColor( (Image)arg1) -> Color :

C++ signature :
Magick::Color borderColor(Magick::Image {lvalue})
boundingBox((Image)arg1) → Geometry :
C++ signature :
Magick::Geometry boundingBox(Magick::Image {lvalue})
boxColor((Image)arg1, (Color)arg2) → None :
C++ signature :
void boxColor(Magick::Image {lvalue},Magick::Color)

boxColor( (Image)arg1) -> Color :

C++ signature :
Magick::Color boxColor(Magick::Image {lvalue})
cacheThreshold((int)arg1) → None :
C++ signature :
void cacheThreshold(unsigned int)
channel((Image)arg1, (ChannelType)arg2) → None :
C++ signature :
void channel(Magick::Image {lvalue},MagickLib::ChannelType)
channelDepth((Image)arg1, (ChannelType)arg2, (int)arg3) → None :
C++ signature :
void channelDepth(Magick::Image {lvalue},MagickLib::ChannelType,unsigned int)

channelDepth( (Image)arg1, (ChannelType)arg2) -> int :

C++ signature :
unsigned int channelDepth(Magick::Image {lvalue},MagickLib::ChannelType)
charcoal((Image)arg1[, (float)arg2[, (float)arg3]]) → None :
C++ signature :
void charcoal(Magick::Image {lvalue} [,double [,double]])
chop((Image)arg1, (Geometry)arg2) → None :
C++ signature :
void chop(Magick::Image {lvalue},Magick::Geometry)
chromaBluePrimary((Image)arg1, (float)arg2, (float)arg3) → None :
C++ signature :
void chromaBluePrimary(Magick::Image {lvalue},double,double)

chromaBluePrimary( (Image)arg1, (float)arg2, (float)arg3) -> None :

C++ signature :
void chromaBluePrimary(Magick::Image {lvalue},double*,double*)
chromaGreenPrimary((Image)arg1, (float)arg2, (float)arg3) → None :
C++ signature :
void chromaGreenPrimary(Magick::Image {lvalue},double,double)

chromaGreenPrimary( (Image)arg1, (float)arg2, (float)arg3) -> None :

C++ signature :
void chromaGreenPrimary(Magick::Image {lvalue},double*,double*)
chromaRedPrimary((Image)arg1, (float)arg2, (float)arg3) → None :
C++ signature :
void chromaRedPrimary(Magick::Image {lvalue},double,double)

chromaRedPrimary( (Image)arg1, (float)arg2, (float)arg3) -> None :

C++ signature :
void chromaRedPrimary(Magick::Image {lvalue},double*,double*)
chromaWhitePoint((Image)arg1, (float)arg2, (float)arg3) → None :
C++ signature :
void chromaWhitePoint(Magick::Image {lvalue},double,double)

chromaWhitePoint( (Image)arg1, (float)arg2, (float)arg3) -> None :

C++ signature :
void chromaWhitePoint(Magick::Image {lvalue},double*,double*)
classType((Image)arg1, (object)arg2) → None :
C++ signature :
void classType(Magick::Image {lvalue},MagickLib::ClassType)

classType( (Image)arg1) -> object :

C++ signature :
MagickLib::ClassType classType(Magick::Image {lvalue})
clipMask((Image)arg1, (Image)arg2) → None :
C++ signature :
void clipMask(Magick::Image {lvalue},Magick::Image)

clipMask( (Image)arg1) -> Image :

C++ signature :
Magick::Image clipMask(Magick::Image {lvalue})
colorFuzz((Image)arg1, (float)arg2) → None :
C++ signature :
void colorFuzz(Magick::Image {lvalue},double)

colorFuzz( (Image)arg1) -> float :

C++ signature :
double colorFuzz(Magick::Image {lvalue})
colorMap((Image)arg1, (int)arg2, (Color)arg3) → None :
C++ signature :
void colorMap(Magick::Image {lvalue},unsigned int,Magick::Color)

colorMap( (Image)arg1, (int)arg2) -> Color :

C++ signature :
Magick::Color colorMap(Magick::Image {lvalue},unsigned int)
colorMapSize((Image)arg1, (int)arg2) → None :
C++ signature :
void colorMapSize(Magick::Image {lvalue},unsigned int)

colorMapSize( (Image)arg1) -> int :

C++ signature :
unsigned int colorMapSize(Magick::Image {lvalue})
colorSpace((Image)arg1, (ColorspaceType)arg2) → None :
C++ signature :
void colorSpace(Magick::Image {lvalue},MagickLib::ColorspaceType)

colorSpace( (Image)arg1) -> ColorspaceType :

C++ signature :
MagickLib::ColorspaceType colorSpace(Magick::Image {lvalue})
colorize((Image)arg1, (int)arg2, (int)arg3, (int)arg4, (Color)arg5) → None :
C++ signature :
void colorize(Magick::Image {lvalue},unsigned int,unsigned int,unsigned int,Magick::Color)

colorize( (Image)arg1, (int)arg2, (Color)arg3) -> None :

C++ signature :
void colorize(Magick::Image {lvalue},unsigned int,Magick::Color)
columns((Image)arg1) → int :
C++ signature :
unsigned int columns(Magick::Image {lvalue})
comment((Image)arg1, (str)arg2) → None :
C++ signature :
void comment(Magick::Image {lvalue},std::string)

comment( (Image)arg1) -> str :

C++ signature :
std::string comment(Magick::Image {lvalue})
compare((Image)arg1, (Image)arg2) → bool :
C++ signature :
bool compare(Magick::Image {lvalue},Magick::Image)
compose((Image)arg1, (CompositeOperator)arg2) → None :
C++ signature :
void compose(Magick::Image {lvalue},MagickLib::CompositeOperator)

compose( (Image)arg1) -> CompositeOperator :

C++ signature :
MagickLib::CompositeOperator compose(Magick::Image {lvalue})
composite((Image)arg1, (Image)arg2, (int)arg3, (int)arg4[, (CompositeOperator)arg5]) → None :
C++ signature :
void composite(Magick::Image {lvalue},Magick::Image,int,int [,MagickLib::CompositeOperator])

composite( (Image)arg1, (Image)arg2, (Geometry)arg3 [, (CompositeOperator)arg4]) -> None :

C++ signature :
void composite(Magick::Image {lvalue},Magick::Image,Magick::Geometry [,MagickLib::CompositeOperator])

composite( (Image)arg1, (Image)arg2, (GravityType)arg3 [, (CompositeOperator)arg4]) -> None :

C++ signature :
void composite(Magick::Image {lvalue},Magick::Image,MagickLib::GravityType [,MagickLib::CompositeOperator])
compressType((Image)arg1, (CompressionType)arg2) → None :
C++ signature :
void compressType(Magick::Image {lvalue},MagickLib::CompressionType)

compressType( (Image)arg1) -> CompressionType :

C++ signature :
MagickLib::CompressionType compressType(Magick::Image {lvalue})
contrast((Image)arg1, (int)arg2) → None :
C++ signature :
void contrast(Magick::Image {lvalue},unsigned int)
convolve((Image)arg1, (int)arg2, (float)arg3) → None :
C++ signature :
void convolve(Magick::Image {lvalue},unsigned int,double const*)
crop((Image)arg1, (Geometry)arg2) → None :
C++ signature :
void crop(Magick::Image {lvalue},Magick::Geometry)
cycleColormap((Image)arg1, (int)arg2) → None :
C++ signature :
void cycleColormap(Magick::Image {lvalue},int)
debug((Image)arg1, (bool)arg2) → None :
C++ signature :
void debug(Magick::Image {lvalue},bool)

debug( (Image)arg1) -> bool :

C++ signature :
bool debug(Magick::Image {lvalue})
defineSet((Image)arg1, (str)arg2, (str)arg3, (bool)arg4) → None :
C++ signature :
void defineSet(Magick::Image {lvalue},std::string,std::string,bool)

defineSet( (Image)arg1, (str)arg2, (str)arg3) -> bool :

C++ signature :
bool defineSet(Magick::Image {lvalue},std::string,std::string)
defineValue((Image)arg1, (str)arg2, (str)arg3, (str)arg4) → None :
C++ signature :
void defineValue(Magick::Image {lvalue},std::string,std::string,std::string)

defineValue( (Image)arg1, (str)arg2, (str)arg3) -> str :

C++ signature :
std::string defineValue(Magick::Image {lvalue},std::string,std::string)
density((Image)arg1, (Geometry)arg2) → None :
C++ signature :
void density(Magick::Image {lvalue},Magick::Geometry)

density( (Image)arg1) -> Geometry :

C++ signature :
Magick::Geometry density(Magick::Image {lvalue})
depth((Image)arg1, (int)arg2) → None :
C++ signature :
void depth(Magick::Image {lvalue},unsigned int)

depth( (Image)arg1) -> int :

C++ signature :
unsigned int depth(Magick::Image {lvalue})
despeckle((Image)arg1) → None :
C++ signature :
void despeckle(Magick::Image {lvalue})
directory((Image)arg1) → str :
C++ signature :
std::string directory(Magick::Image {lvalue})
display((Image)arg1) → None :
C++ signature :
void display(Magick::Image {lvalue})
draw((Image)arg1, (Drawable)arg2) → None :
C++ signature :
void draw(Magick::Image {lvalue},Magick::Drawable)

draw( (Image)arg1, (DrawableList)arg2) -> None :

C++ signature :
void draw(Magick::Image {lvalue},std::list<Magick::Drawable, std::allocator<Magick::Drawable> >)
edge((Image)arg1[, (float)arg2]) → None :
C++ signature :
void edge(Magick::Image {lvalue} [,double])
emboss((Image)arg1[, (float)arg2[, (float)arg3]]) → None :
C++ signature :
void emboss(Magick::Image {lvalue} [,double [,double]])
endian((Image)arg1, (EndianType)arg2) → None :
C++ signature :
void endian(Magick::Image {lvalue},MagickLib::EndianType)

endian( (Image)arg1) -> EndianType :

C++ signature :
MagickLib::EndianType endian(Magick::Image {lvalue})
enhance((Image)arg1) → None :
C++ signature :
void enhance(Magick::Image {lvalue})
equalize((Image)arg1) → None :
C++ signature :
void equalize(Magick::Image {lvalue})
erase((Image)arg1) → None :
C++ signature :
void erase(Magick::Image {lvalue})
fileName((Image)arg1, (str)arg2) → None :
C++ signature :
void fileName(Magick::Image {lvalue},std::string)

fileName( (Image)arg1) -> str :

C++ signature :
std::string fileName(Magick::Image {lvalue})
fileSize((Image)arg1) → long :
C++ signature :
long long fileSize(Magick::Image {lvalue})
fillColor((Image)arg1, (Color)arg2) → None :
C++ signature :
void fillColor(Magick::Image {lvalue},Magick::Color)

fillColor( (Image)arg1) -> Color :

C++ signature :
Magick::Color fillColor(Magick::Image {lvalue})
fillPattern((Image)arg1, (Image)arg2) → None :
C++ signature :
void fillPattern(Magick::Image {lvalue},Magick::Image)

fillPattern( (Image)arg1) -> Image :

C++ signature :
Magick::Image fillPattern(Magick::Image {lvalue})
fillRule((Image)arg1, (FillRule)arg2) → None :
C++ signature :
void fillRule(Magick::Image {lvalue},MagickLib::FillRule)

fillRule( (Image)arg1) -> FillRule :

C++ signature :
MagickLib::FillRule fillRule(Magick::Image {lvalue})
filterType((Image)arg1, (FilterTypes)arg2) → None :
C++ signature :
void filterType(Magick::Image {lvalue},MagickLib::FilterTypes)
flip((Image)arg1) → None :
C++ signature :
void flip(Magick::Image {lvalue})
floodFillColor((Image)arg1, (Geometry)arg2, (Color)arg3) → None :
C++ signature :
void floodFillColor(Magick::Image {lvalue},Magick::Geometry,Magick::Color)

floodFillColor( (Image)arg1, (Geometry)arg2, (Color)arg3, (Color)arg4) -> None :

C++ signature :
void floodFillColor(Magick::Image {lvalue},Magick::Geometry,Magick::Color,Magick::Color)
floodFillOpacity((Image)arg1, (int)arg2, (int)arg3, (int)arg4, (PaintMethod)arg5) → None :
C++ signature :
void floodFillOpacity(Magick::Image {lvalue},unsigned int,unsigned int,unsigned int,MagickLib::PaintMethod)
floodFillTexture((Image)arg1, (Geometry)arg2, (Image)arg3) → None :
C++ signature :
void floodFillTexture(Magick::Image {lvalue},Magick::Geometry,Magick::Image)

floodFillTexture( (Image)arg1, (Geometry)arg2, (Image)arg3, (Color)arg4) -> None :

C++ signature :
void floodFillTexture(Magick::Image {lvalue},Magick::Geometry,Magick::Image,Magick::Color)
flop((Image)arg1) → None :
C++ signature :
void flop(Magick::Image {lvalue})
font((Image)arg1, (str)arg2) → None :
C++ signature :
void font(Magick::Image {lvalue},std::string)

font( (Image)arg1) -> str :

C++ signature :
std::string font(Magick::Image {lvalue})
fontPointsize((Image)arg1, (float)arg2) → None :
C++ signature :
void fontPointsize(Magick::Image {lvalue},double)

fontPointsize( (Image)arg1) -> float :

C++ signature :
double fontPointsize(Magick::Image {lvalue})
fontTypeMetrics((Image)arg1, (str)arg2, (TypeMetric)arg3) → None :
C++ signature :
void fontTypeMetrics(Magick::Image {lvalue},std::string,Magick::TypeMetric*)
format((Image)arg1) → str :
C++ signature :
std::string format(Magick::Image {lvalue})
frame((Image)arg1[, (Geometry)arg2]) → None :
C++ signature :
void frame(Magick::Image {lvalue} [,Magick::Geometry])

frame( (Image)arg1, (int)arg2, (int)arg3 [, (int)arg4 [, (int)arg5]]) -> None :

C++ signature :
void frame(Magick::Image {lvalue},unsigned int,unsigned int [,int [,int]])
gamma((Image)arg1, (float)arg2) → None :
C++ signature :
void gamma(Magick::Image {lvalue},double)

gamma( (Image)arg1, (float)arg2, (float)arg3, (float)arg4) -> None :

C++ signature :
void gamma(Magick::Image {lvalue},double,double,double)

gamma( (Image)arg1) -> float :

C++ signature :
double gamma(Magick::Image {lvalue})
gaussianBlur((Image)arg1, (float)arg2, (float)arg3) → None :
C++ signature :
void gaussianBlur(Magick::Image {lvalue},double,double)
gaussianBlurChannel((Image)arg1, (ChannelType)arg2, (float)arg3, (float)arg4) → None :
C++ signature :
void gaussianBlurChannel(Magick::Image {lvalue},MagickLib::ChannelType,double,double)
geometry((Image)arg1) → Geometry :
C++ signature :
Magick::Geometry geometry(Magick::Image {lvalue})
gifDisposeMethod((Image)arg1, (int)arg2) → None :
C++ signature :
void gifDisposeMethod(Magick::Image {lvalue},unsigned int)

gifDisposeMethod( (Image)arg1) -> int :

C++ signature :
unsigned int gifDisposeMethod(Magick::Image {lvalue})
haldClut((Image)arg1, (Image)arg2) → None :
C++ signature :
void haldClut(Magick::Image {lvalue},Magick::Image)
iccColorProfile((Image)arg1, (Blob)arg2) → None :
C++ signature :
void iccColorProfile(Magick::Image {lvalue},Magick::Blob)

iccColorProfile( (Image)arg1) -> Blob :

C++ signature :
Magick::Blob iccColorProfile(Magick::Image {lvalue})
implode((Image)arg1, (float)arg2) → None :
C++ signature :
void implode(Magick::Image {lvalue},double)
interlaceType((Image)arg1, (InterlaceType)arg2) → None :
C++ signature :
void interlaceType(Magick::Image {lvalue},MagickLib::InterlaceType)

interlaceType( (Image)arg1) -> InterlaceType :

C++ signature :
MagickLib::InterlaceType interlaceType(Magick::Image {lvalue})
iptcProfile((Image)arg1, (Blob)arg2) → None :
C++ signature :
void iptcProfile(Magick::Image {lvalue},Magick::Blob)

iptcProfile( (Image)arg1) -> Blob :

C++ signature :
Magick::Blob iptcProfile(Magick::Image {lvalue})
isValid((Image)arg1, (bool)arg2) → None :
C++ signature :
void isValid(Magick::Image {lvalue},bool)

isValid( (Image)arg1) -> bool :

C++ signature :
bool isValid(Magick::Image {lvalue})
label((Image)arg1, (str)arg2) → None :
C++ signature :
void label(Magick::Image {lvalue},std::string)

label( (Image)arg1) -> str :

C++ signature :
std::string label(Magick::Image {lvalue})
level((Image)arg1, (float)arg2, (float)arg3, (float)arg4) → None :
C++ signature :
void level(Magick::Image {lvalue},double,double,double)
levelChannel((Image)arg1, (ChannelType)arg2, (float)arg3, (float)arg4, (float)arg5) → None :
C++ signature :
void levelChannel(Magick::Image {lvalue},MagickLib::ChannelType,double,double,double)
lineWidth((Image)arg1, (float)arg2) → None :
C++ signature :
void lineWidth(Magick::Image {lvalue},double)

lineWidth( (Image)arg1) -> float :

C++ signature :
double lineWidth(Magick::Image {lvalue})
magick((Image)arg1, (str)arg2) → None :
C++ signature :
void magick(Magick::Image {lvalue},std::string)

magick( (Image)arg1) -> str :

C++ signature :
std::string magick(Magick::Image {lvalue})
magnify((Image)arg1) → None :
C++ signature :
void magnify(Magick::Image {lvalue})
map((Image)arg1, (Image)arg2[, (bool)arg3]) → None :
C++ signature :
void map(Magick::Image {lvalue},Magick::Image [,bool])
matte((Image)arg1, (bool)arg2) → None :
C++ signature :
void matte(Magick::Image {lvalue},bool)

matte( (Image)arg1) -> bool :

C++ signature :
bool matte(Magick::Image {lvalue})
matteColor((Image)arg1, (Color)arg2) → None :
C++ signature :
void matteColor(Magick::Image {lvalue},Magick::Color)

matteColor( (Image)arg1) -> Color :

C++ signature :
Magick::Color matteColor(Magick::Image {lvalue})
matteFloodfill((Image)arg1, (Color)arg2, (int)arg3, (int)arg4, (int)arg5, (PaintMethod)arg6) → None :
C++ signature :
void matteFloodfill(Magick::Image {lvalue},Magick::Color,unsigned int,int,int,MagickLib::PaintMethod)
meanErrorPerPixel((Image)arg1) → float :
C++ signature :
double meanErrorPerPixel(Magick::Image {lvalue})
medianFilter((Image)arg1[, (float)arg2]) → None :
C++ signature :
void medianFilter(Magick::Image {lvalue} [,double])
minify((Image)arg1) → None :
C++ signature :
void minify(Magick::Image {lvalue})
modifyImage((Image)arg1) → None :
C++ signature :
void modifyImage(Magick::Image {lvalue})
modulate((Image)arg1, (float)arg2, (float)arg3, (float)arg4) → None :
C++ signature :
void modulate(Magick::Image {lvalue},double,double,double)
modulusDepth((Image)arg1, (int)arg2) → None :
C++ signature :
void modulusDepth(Magick::Image {lvalue},unsigned int)

modulusDepth( (Image)arg1) -> int :

C++ signature :
unsigned int modulusDepth(Magick::Image {lvalue})
monochrome((Image)arg1, (bool)arg2) → None :
C++ signature :
void monochrome(Magick::Image {lvalue},bool)

monochrome( (Image)arg1) -> bool :

C++ signature :
bool monochrome(Magick::Image {lvalue})
montageGeometry((Image)arg1) → Geometry :
C++ signature :
Magick::Geometry montageGeometry(Magick::Image {lvalue})
motionBlur((Image)arg1, (float)arg2, (float)arg3, (float)arg4) → None :
C++ signature :
void motionBlur(Magick::Image {lvalue},double,double,double)
negate((Image)arg1[, (bool)arg2]) → None :
C++ signature :
void negate(Magick::Image {lvalue} [,bool])
normalize((Image)arg1) → None :
C++ signature :
void normalize(Magick::Image {lvalue})
normalizedMaxError((Image)arg1) → float :
C++ signature :
double normalizedMaxError(Magick::Image {lvalue})
normalizedMeanError((Image)arg1) → float :
C++ signature :
double normalizedMeanError(Magick::Image {lvalue})
oilPaint((Image)arg1[, (float)arg2]) → None :
C++ signature :
void oilPaint(Magick::Image {lvalue} [,double])
opacity((Image)arg1, (int)arg2) → None :
C++ signature :
void opacity(Magick::Image {lvalue},unsigned int)
opaque((Image)arg1, (Color)arg2, (Color)arg3) → None :
C++ signature :
void opaque(Magick::Image {lvalue},Magick::Color,Magick::Color)
orientation((Image)arg1, (OrientationType)arg2) → None :
C++ signature :
void orientation(Magick::Image {lvalue},MagickLib::OrientationType)

orientation( (Image)arg1) -> OrientationType :

C++ signature :
MagickLib::OrientationType orientation(Magick::Image {lvalue})
page((Image)arg1, (Geometry)arg2) → None :
C++ signature :
void page(Magick::Image {lvalue},Magick::Geometry)

page( (Image)arg1) -> Geometry :

C++ signature :
Magick::Geometry page(Magick::Image {lvalue})
penColor((Image)arg1, (Color)arg2) → None :
C++ signature :
void penColor(Magick::Image {lvalue},Magick::Color)

penColor( (Image)arg1) -> Color :

C++ signature :
Magick::Color penColor(Magick::Image {lvalue})
penTexture((Image)arg1, (Image)arg2) → None :
C++ signature :
void penTexture(Magick::Image {lvalue},Magick::Image)

penTexture( (Image)arg1) -> Image :

C++ signature :
Magick::Image penTexture(Magick::Image {lvalue})
ping((Image)arg1, (str)arg2) → None :
C++ signature :
void ping(Magick::Image {lvalue},std::string)

ping( (Image)arg1, (Blob)arg2) -> None :

C++ signature :
void ping(Magick::Image {lvalue},Magick::Blob)
pixelColor((Image)arg1, (int)arg2, (int)arg3, (Color)arg4) → None :
C++ signature :
void pixelColor(Magick::Image {lvalue},unsigned int,unsigned int,Magick::Color)

pixelColor( (Image)arg1, (int)arg2, (int)arg3) -> Color :

C++ signature :
Magick::Color pixelColor(Magick::Image {lvalue},unsigned int,unsigned int)
process((Image)arg1, (str)arg2, (int)arg3, (object)arg4) → None :
C++ signature :
void process(Magick::Image {lvalue},std::string,int,char**)
profile((Image)arg1, (str)arg2, (Blob)arg3) → None :
C++ signature :
void profile(Magick::Image {lvalue},std::string,Magick::Blob)

profile( (Image)arg1, (str)arg2) -> Blob :

C++ signature :
Magick::Blob profile(Magick::Image {lvalue},std::string)
quality((Image)arg1, (int)arg2) → None :
C++ signature :
void quality(Magick::Image {lvalue},unsigned int)

quality( (Image)arg1) -> int :

C++ signature :
unsigned int quality(Magick::Image {lvalue})
quantize((Image)arg1[, (bool)arg2]) → None :
C++ signature :
void quantize(Magick::Image {lvalue} [,bool])
quantizeColorSpace((Image)arg1, (ColorspaceType)arg2) → None :
C++ signature :
void quantizeColorSpace(Magick::Image {lvalue},MagickLib::ColorspaceType)

quantizeColorSpace( (Image)arg1) -> ColorspaceType :

C++ signature :
MagickLib::ColorspaceType quantizeColorSpace(Magick::Image {lvalue})
quantizeColors((Image)arg1, (int)arg2) → None :
C++ signature :
void quantizeColors(Magick::Image {lvalue},unsigned int)

quantizeColors( (Image)arg1) -> int :

C++ signature :
unsigned int quantizeColors(Magick::Image {lvalue})
quantizeDither((Image)arg1, (bool)arg2) → None :
C++ signature :
void quantizeDither(Magick::Image {lvalue},bool)

quantizeDither( (Image)arg1) -> bool :

C++ signature :
bool quantizeDither(Magick::Image {lvalue})
quantizeTreeDepth((Image)arg1, (int)arg2) → None :
C++ signature :
void quantizeTreeDepth(Magick::Image {lvalue},unsigned int)

quantizeTreeDepth( (Image)arg1) -> int :

C++ signature :
unsigned int quantizeTreeDepth(Magick::Image {lvalue})
quantumOperator((Image)arg1, (ChannelType)arg2, (QuantumOperator)arg3, (int)arg4) → None :
C++ signature :
void quantumOperator(Magick::Image {lvalue},MagickLib::ChannelType,MagickLib::QuantumOperator,unsigned char)

quantumOperator( (Image)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5, (ChannelType)arg6, (QuantumOperator)arg7, (int)arg8) -> None :

C++ signature :
void quantumOperator(Magick::Image {lvalue},int,int,unsigned int,unsigned int,MagickLib::ChannelType,MagickLib::QuantumOperator,unsigned char)
raise((Image)arg1[, (Geometry)arg2[, (bool)arg3]]) → None :
C++ signature :
void raise(Magick::Image {lvalue} [,Magick::Geometry [,bool]])
randomThreshold((Image)arg1, (Geometry)arg2) → None :
C++ signature :
void randomThreshold(Magick::Image {lvalue},Magick::Geometry)
randomThresholdChannel((Image)arg1, (Geometry)arg2, (ChannelType)arg3) → None :
C++ signature :
void randomThresholdChannel(Magick::Image {lvalue},Magick::Geometry,MagickLib::ChannelType)
read((Image)arg1, (str)arg2) → None :
C++ signature :
void read(Magick::Image {lvalue},std::string)

read( (Image)arg1, (Geometry)arg2, (str)arg3) -> None :

C++ signature :
void read(Magick::Image {lvalue},Magick::Geometry,std::string)

read( (Image)arg1, (Blob)arg2) -> None :

C++ signature :
void read(Magick::Image {lvalue},Magick::Blob)

read( (Image)arg1, (Blob)arg2, (Geometry)arg3) -> None :

C++ signature :
void read(Magick::Image {lvalue},Magick::Blob,Magick::Geometry)

read( (Image)arg1, (Blob)arg2, (Geometry)arg3, (int)arg4) -> None :

C++ signature :
void read(Magick::Image {lvalue},Magick::Blob,Magick::Geometry,unsigned int)

read( (Image)arg1, (Blob)arg2, (Geometry)arg3, (int)arg4, (str)arg5) -> None :

C++ signature :
void read(Magick::Image {lvalue},Magick::Blob,Magick::Geometry,unsigned int,std::string)

read( (Image)arg1, (Blob)arg2, (Geometry)arg3, (str)arg4) -> None :

C++ signature :
void read(Magick::Image {lvalue},Magick::Blob,Magick::Geometry,std::string)
readPixels((Image)arg1, (QuantumType)arg2, (int)arg3) → None :
C++ signature :
void readPixels(Magick::Image {lvalue},MagickLib::QuantumType,unsigned char const*)
reduceNoise((Image)arg1) → None :
C++ signature :
void reduceNoise(Magick::Image {lvalue})

reduceNoise( (Image)arg1, (float)arg2) -> None :

C++ signature :
void reduceNoise(Magick::Image {lvalue},double)
registerId((Image)arg1) → int :
C++ signature :
long registerId(Magick::Image {lvalue})
renderingIntent((Image)arg1, (RenderingIntent)arg2) → None :
C++ signature :
void renderingIntent(Magick::Image {lvalue},MagickLib::RenderingIntent)

renderingIntent( (Image)arg1) -> RenderingIntent :

C++ signature :
MagickLib::RenderingIntent renderingIntent(Magick::Image {lvalue})
resolutionUnits((Image)arg1, (ResolutionType)arg2) → None :
C++ signature :
void resolutionUnits(Magick::Image {lvalue},MagickLib::ResolutionType)

resolutionUnits( (Image)arg1) -> ResolutionType :

C++ signature :
MagickLib::ResolutionType resolutionUnits(Magick::Image {lvalue})
roll((Image)arg1, (Geometry)arg2) → None :
C++ signature :
void roll(Magick::Image {lvalue},Magick::Geometry)

roll( (Image)arg1, (int)arg2, (int)arg3) -> None :

C++ signature :
void roll(Magick::Image {lvalue},unsigned int,unsigned int)
rotate((Image)arg1, (float)arg2) → None :
C++ signature :
void rotate(Magick::Image {lvalue},double)
rows((Image)arg1) → int :
C++ signature :
unsigned int rows(Magick::Image {lvalue})
sample((Image)arg1, (Geometry)arg2) → None :
C++ signature :
void sample(Magick::Image {lvalue},Magick::Geometry)
scale((Image)arg1, (Geometry)arg2) → None :
C++ signature :
void scale(Magick::Image {lvalue},Magick::Geometry)
scene((Image)arg1, (int)arg2) → None :
C++ signature :
void scene(Magick::Image {lvalue},unsigned int)

scene( (Image)arg1) -> int :

C++ signature :
unsigned int scene(Magick::Image {lvalue})
segment((Image)arg1[, (float)arg2[, (float)arg3]]) → None :
C++ signature :
void segment(Magick::Image {lvalue} [,double [,double]])
shade((Image)arg1[, (float)arg2[, (float)arg3[, (bool)arg4]]]) → None :
C++ signature :
void shade(Magick::Image {lvalue} [,double [,double [,bool]]])
sharpen((Image)arg1[, (float)arg2[, (float)arg3]]) → None :
C++ signature :
void sharpen(Magick::Image {lvalue} [,double [,double]])
sharpenChannel((Image)arg1, (ChannelType)arg2[, (float)arg3[, (float)arg4]]) → None :
C++ signature :
void sharpenChannel(Magick::Image {lvalue},MagickLib::ChannelType [,double [,double]])
shave((Image)arg1, (Geometry)arg2) → None :
C++ signature :
void shave(Magick::Image {lvalue},Magick::Geometry)
shear((Image)arg1, (float)arg2, (float)arg3) → None :
C++ signature :
void shear(Magick::Image {lvalue},double,double)
signature((Image)arg1[, (bool)arg2]) → str :
C++ signature :
std::string signature(Magick::Image {lvalue} [,bool])
size((Image)arg1, (Geometry)arg2) → None :
C++ signature :
void size(Magick::Image {lvalue},Magick::Geometry)

size( (Image)arg1) -> Geometry :

C++ signature :
Magick::Geometry size(Magick::Image {lvalue})
solarize((Image)arg1[, (float)arg2]) → None :
C++ signature :
void solarize(Magick::Image {lvalue} [,double])
spread((Image)arg1[, (int)arg2]) → None :
C++ signature :
void spread(Magick::Image {lvalue} [,unsigned int])
statistics((Image)arg1, (object)arg2) → None :
C++ signature :
void statistics(Magick::Image {lvalue},MagickLib::_ImageStatistics*)
stegano((Image)arg1, (Image)arg2) → None :
C++ signature :
void stegano(Magick::Image {lvalue},Magick::Image)
stereo((Image)arg1, (Image)arg2) → None :
C++ signature :
void stereo(Magick::Image {lvalue},Magick::Image)
strokeAntiAlias((Image)arg1, (bool)arg2) → None :
C++ signature :
void strokeAntiAlias(Magick::Image {lvalue},bool)

strokeAntiAlias( (Image)arg1) -> bool :

C++ signature :
bool strokeAntiAlias(Magick::Image {lvalue})
strokeColor((Image)arg1, (Color)arg2) → None :
C++ signature :
void strokeColor(Magick::Image {lvalue},Magick::Color)

strokeColor( (Image)arg1) -> Color :

C++ signature :
Magick::Color strokeColor(Magick::Image {lvalue})
strokeDashArray((Image)arg1, (float)arg2) → None :
C++ signature :
void strokeDashArray(Magick::Image {lvalue},double const*)
strokeDashOffset((Image)arg1, (float)arg2) → None :
C++ signature :
void strokeDashOffset(Magick::Image {lvalue},double)

strokeDashOffset( (Image)arg1) -> float :

C++ signature :
double strokeDashOffset(Magick::Image {lvalue})
strokeLineCap((Image)arg1, (LineCap)arg2) → None :
C++ signature :
void strokeLineCap(Magick::Image {lvalue},MagickLib::LineCap)

strokeLineCap( (Image)arg1) -> LineCap :

C++ signature :
MagickLib::LineCap strokeLineCap(Magick::Image {lvalue})
strokeLineJoin((Image)arg1, (LineJoin)arg2) → None :
C++ signature :
void strokeLineJoin(Magick::Image {lvalue},MagickLib::LineJoin)

strokeLineJoin( (Image)arg1) -> LineJoin :

C++ signature :
MagickLib::LineJoin strokeLineJoin(Magick::Image {lvalue})
strokeMiterLimit((Image)arg1, (int)arg2) → None :
C++ signature :
void strokeMiterLimit(Magick::Image {lvalue},unsigned int)

strokeMiterLimit( (Image)arg1) -> int :

C++ signature :
unsigned int strokeMiterLimit(Magick::Image {lvalue})
strokePattern((Image)arg1, (Image)arg2) → None :
C++ signature :
void strokePattern(Magick::Image {lvalue},Magick::Image)

strokePattern( (Image)arg1) -> Image :

C++ signature :
Magick::Image strokePattern(Magick::Image {lvalue})
strokeWidth((Image)arg1, (float)arg2) → None :
C++ signature :
void strokeWidth(Magick::Image {lvalue},double)

strokeWidth( (Image)arg1) -> float :

C++ signature :
double strokeWidth(Magick::Image {lvalue})
subImage((Image)arg1, (int)arg2) → None :
C++ signature :
void subImage(Magick::Image {lvalue},unsigned int)

subImage( (Image)arg1) -> int :

C++ signature :
unsigned int subImage(Magick::Image {lvalue})
subRange((Image)arg1, (int)arg2) → None :
C++ signature :
void subRange(Magick::Image {lvalue},unsigned int)

subRange( (Image)arg1) -> int :

C++ signature :
unsigned int subRange(Magick::Image {lvalue})
swirl((Image)arg1, (float)arg2) → None :
C++ signature :
void swirl(Magick::Image {lvalue},double)
syncPixels((Image)arg1) → None :
C++ signature :
void syncPixels(Magick::Image {lvalue})
textEncoding((Image)arg1, (str)arg2) → None :
C++ signature :
void textEncoding(Magick::Image {lvalue},std::string)

textEncoding( (Image)arg1) -> str :

C++ signature :
std::string textEncoding(Magick::Image {lvalue})
texture((Image)arg1, (Image)arg2) → None :
C++ signature :
void texture(Magick::Image {lvalue},Magick::Image)
threshold((Image)arg1, (float)arg2) → None :
C++ signature :
void threshold(Magick::Image {lvalue},double)
throwImageException((Image)arg1) → None :
C++ signature :
void throwImageException(Magick::Image {lvalue})
tileName((Image)arg1, (str)arg2) → None :
C++ signature :
void tileName(Magick::Image {lvalue},std::string)

tileName( (Image)arg1) -> str :

C++ signature :
std::string tileName(Magick::Image {lvalue})
totalColors((Image)arg1) → int :
C++ signature :
unsigned long totalColors(Magick::Image {lvalue})
transform((Image)arg1, (Geometry)arg2) → None :
C++ signature :
void transform(Magick::Image {lvalue},Magick::Geometry)

transform( (Image)arg1, (Geometry)arg2, (Geometry)arg3) -> None :

C++ signature :
void transform(Magick::Image {lvalue},Magick::Geometry,Magick::Geometry)
transformOrigin((Image)arg1, (float)arg2, (float)arg3) → None :
C++ signature :
void transformOrigin(Magick::Image {lvalue},double,double)
transformReset((Image)arg1) → None :
C++ signature :
void transformReset(Magick::Image {lvalue})
transformRotation((Image)arg1, (float)arg2) → None :
C++ signature :
void transformRotation(Magick::Image {lvalue},double)
transformScale((Image)arg1, (float)arg2, (float)arg3) → None :
C++ signature :
void transformScale(Magick::Image {lvalue},double,double)
transformSkewX((Image)arg1, (float)arg2) → None :
C++ signature :
void transformSkewX(Magick::Image {lvalue},double)
transformSkewY((Image)arg1, (float)arg2) → None :
C++ signature :
void transformSkewY(Magick::Image {lvalue},double)
transparent((Image)arg1, (Color)arg2) → None :
C++ signature :
void transparent(Magick::Image {lvalue},Magick::Color)
trim((Image)arg1) → None :
C++ signature :
void trim(Magick::Image {lvalue})
type((Image)arg1, (ImageType)arg2) → None :
C++ signature :
void type(Magick::Image {lvalue},MagickLib::ImageType)

type( (Image)arg1) -> ImageType :

C++ signature :
MagickLib::ImageType type(Magick::Image {lvalue})
unregisterId((Image)arg1) → None :
C++ signature :
void unregisterId(Magick::Image {lvalue})
unsharpmask((Image)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5) → None :
C++ signature :
void unsharpmask(Magick::Image {lvalue},double,double,double,double)
unsharpmaskChannel((Image)arg1, (ChannelType)arg2, (float)arg3, (float)arg4, (float)arg5, (float)arg6) → None :
C++ signature :
void unsharpmaskChannel(Magick::Image {lvalue},MagickLib::ChannelType,double,double,double,double)
verbose((Image)arg1, (bool)arg2) → None :
C++ signature :
void verbose(Magick::Image {lvalue},bool)

verbose( (Image)arg1) -> bool :

C++ signature :
bool verbose(Magick::Image {lvalue})
view((Image)arg1, (str)arg2) → None :
C++ signature :
void view(Magick::Image {lvalue},std::string)

view( (Image)arg1) -> str :

C++ signature :
std::string view(Magick::Image {lvalue})
wave((Image)arg1[, (float)arg2[, (float)arg3]]) → None :
C++ signature :
void wave(Magick::Image {lvalue} [,double [,double]])
write((Image)arg1, (str)arg2) → None :
C++ signature :
void write(Magick::Image {lvalue},std::string)

write( (Image)arg1, (Blob)arg2) -> None :

C++ signature :
void write(Magick::Image {lvalue},Magick::Blob*)

write( (Image)arg1, (Blob)arg2, (str)arg3) -> None :

C++ signature :
void write(Magick::Image {lvalue},Magick::Blob*,std::string)

write( (Image)arg1, (Blob)arg2, (str)arg3, (int)arg4) -> None :

C++ signature :
void write(Magick::Image {lvalue},Magick::Blob*,std::string,unsigned int)
writePixels((Image)arg1, (QuantumType)arg2, (int)arg3) → None :
C++ signature :
void writePixels(Magick::Image {lvalue},MagickLib::QuantumType,unsigned char*)
x11Display((Image)arg1, (str)arg2) → None :
C++ signature :
void x11Display(Magick::Image {lvalue},std::string)

x11Display( (Image)arg1) -> str :

C++ signature :
std::string x11Display(Magick::Image {lvalue})
xResolution((Image)arg1) → float :
C++ signature :
double xResolution(Magick::Image {lvalue})
yResolution((Image)arg1) → float :
C++ signature :
double yResolution(Magick::Image {lvalue})
zoom((Image)arg1, (Geometry)arg2) → None :
C++ signature :
void zoom(Magick::Image {lvalue},Magick::Geometry)

ImageList Class

class pgmagick.ImageList[source]
animationDelayImages((ImageList)arg1, (int)arg2) → None :
C++ signature :
void animationDelayImages(_ImageList {lvalue},unsigned int)
append((ImageList)arg1, (Image)arg2) → None :
C++ signature :
void append(_ImageList {lvalue},Magick::Image)
appendImages((ImageList)arg1, (Image)arg2) → None :
C++ signature :
void appendImages(_ImageList {lvalue},Magick::Image*)
coalesceImags((ImageList)arg1) → None :
C++ signature :
void coalesceImags(_ImageList {lvalue})
readImages((ImageList)arg1, (str)arg2) → None :
C++ signature :
void readImages(_ImageList {lvalue},std::string)
scaleImages((ImageList)arg1, (Geometry)arg2) → None :
C++ signature :
void scaleImages(_ImageList {lvalue},Magick::Geometry)
writeImages((ImageList)arg1, (str)arg2) → None :
C++ signature :
void writeImages(_ImageList {lvalue},std::string)

Montage Class

class pgmagick.Montage[source]
backgroundColor((Montage)arg1, (Color)arg2) → None :
C++ signature :
void backgroundColor(Magick::Montage {lvalue},Magick::Color)

backgroundColor( (Montage)arg1) -> Color :

C++ signature :
Magick::Color backgroundColor(Magick::Montage {lvalue})
compose((Montage)arg1, (CompositeOperator)arg2) → None :
C++ signature :
void compose(Magick::Montage {lvalue},MagickLib::CompositeOperator)

compose( (Montage)arg1) -> CompositeOperator :

C++ signature :
MagickLib::CompositeOperator compose(Magick::Montage {lvalue})
fileName((Montage)arg1, (str)arg2) → None :
C++ signature :
void fileName(Magick::Montage {lvalue},std::string)

fileName( (Montage)arg1) -> str :

C++ signature :
std::string fileName(Magick::Montage {lvalue})
fillColor((Montage)arg1, (Color)arg2) → None :
C++ signature :
void fillColor(Magick::Montage {lvalue},Magick::Color)

fillColor( (Montage)arg1) -> Color :

C++ signature :
Magick::Color fillColor(Magick::Montage {lvalue})
geometry((Montage)arg1, (Geometry)arg2) → None :
C++ signature :
void geometry(Magick::Montage {lvalue},Magick::Geometry)

geometry( (Montage)arg1) -> Geometry :

C++ signature :
Magick::Geometry geometry(Magick::Montage {lvalue})
gravity((Montage)arg1, (GravityType)arg2) → None :
C++ signature :
void gravity(Magick::Montage {lvalue},MagickLib::GravityType)

gravity( (Montage)arg1) -> GravityType :

C++ signature :
MagickLib::GravityType gravity(Magick::Montage {lvalue})
label((Montage)arg1, (str)arg2) → None :
C++ signature :
void label(Magick::Montage {lvalue},std::string)

label( (Montage)arg1) -> str :

C++ signature :
std::string label(Magick::Montage {lvalue})
penColor((Montage)arg1, (Color)arg2) → None :
C++ signature :
void penColor(Magick::Montage {lvalue},Magick::Color)

penColor( (Montage)arg1) -> Color :

C++ signature :
Magick::Color penColor(Magick::Montage {lvalue})
pointSize((Montage)arg1, (int)arg2) → None :
C++ signature :
void pointSize(Magick::Montage {lvalue},unsigned int)

pointSize( (Montage)arg1) -> int :

C++ signature :
unsigned int pointSize(Magick::Montage {lvalue})
shadow((Montage)arg1, (bool)arg2) → None :
C++ signature :
void shadow(Magick::Montage {lvalue},bool)

shadow( (Montage)arg1) -> bool :

C++ signature :
bool shadow(Magick::Montage {lvalue})
strokeColor((Montage)arg1, (Color)arg2) → None :
C++ signature :
void strokeColor(Magick::Montage {lvalue},Magick::Color)

strokeColor( (Montage)arg1) -> Color :

C++ signature :
Magick::Color strokeColor(Magick::Montage {lvalue})
texture((Montage)arg1, (str)arg2) → None :
C++ signature :
void texture(Magick::Montage {lvalue},std::string)

texture( (Montage)arg1) -> str :

C++ signature :
std::string texture(Magick::Montage {lvalue})
title((Montage)arg1, (str)arg2) → None :
C++ signature :
void title(Magick::Montage {lvalue},std::string)

title( (Montage)arg1) -> str :

C++ signature :
std::string title(Magick::Montage {lvalue})
transparentColor((Montage)arg1, (Color)arg2) → None :
C++ signature :
void transparentColor(Magick::Montage {lvalue},Magick::Color)

transparentColor( (Montage)arg1) -> Color :

C++ signature :
Magick::Color transparentColor(Magick::Montage {lvalue})

MontageFramed Class

class pgmagick.MontageFramed[source]
borderColor((MontageFramed)arg1, (Color)arg2) → None :
C++ signature :
void borderColor(Magick::MontageFramed {lvalue},Magick::Color)

borderColor( (MontageFramed)arg1) -> Color :

C++ signature :
Magick::Color borderColor(Magick::MontageFramed {lvalue})
borderWidth((MontageFramed)arg1, (int)arg2) → None :
C++ signature :
void borderWidth(Magick::MontageFramed {lvalue},unsigned int)

borderWidth( (MontageFramed)arg1) -> int :

C++ signature :
unsigned int borderWidth(Magick::MontageFramed {lvalue})
frameGeometry((MontageFramed)arg1, (Geometry)arg2) → None :
C++ signature :
void frameGeometry(Magick::MontageFramed {lvalue},Magick::Geometry)

frameGeometry( (MontageFramed)arg1) -> Geometry :

C++ signature :
Magick::Geometry frameGeometry(Magick::MontageFramed {lvalue})
matteColor((MontageFramed)arg1, (Color)arg2) → None :
C++ signature :
void matteColor(Magick::MontageFramed {lvalue},Magick::Color)

matteColor( (MontageFramed)arg1) -> Color :

C++ signature :
Magick::Color matteColor(Magick::MontageFramed {lvalue})

PathArcAbs Class

class pgmagick.PathArcAbs[source]

PathArcArgs Class

class pgmagick.PathArcArgs[source]
largeArcFlag((PathArcArgs)arg1, (bool)arg2) → None :
C++ signature :
void largeArcFlag(Magick::PathArcArgs {lvalue},bool)

largeArcFlag( (PathArcArgs)arg1) -> bool :

C++ signature :
bool largeArcFlag(Magick::PathArcArgs {lvalue})
radiusX((PathArcArgs)arg1, (float)arg2) → None :
C++ signature :
void radiusX(Magick::PathArcArgs {lvalue},double)

radiusX( (PathArcArgs)arg1) -> float :

C++ signature :
double radiusX(Magick::PathArcArgs {lvalue})
radiusY((PathArcArgs)arg1, (float)arg2) → None :
C++ signature :
void radiusY(Magick::PathArcArgs {lvalue},double)

radiusY( (PathArcArgs)arg1) -> float :

C++ signature :
double radiusY(Magick::PathArcArgs {lvalue})
sweepFlag((PathArcArgs)arg1, (bool)arg2) → None :
C++ signature :
void sweepFlag(Magick::PathArcArgs {lvalue},bool)

sweepFlag( (PathArcArgs)arg1) -> bool :

C++ signature :
bool sweepFlag(Magick::PathArcArgs {lvalue})
x((PathArcArgs)arg1, (float)arg2) → None :
C++ signature :
void x(Magick::PathArcArgs {lvalue},double)

x( (PathArcArgs)arg1) -> float :

C++ signature :
double x(Magick::PathArcArgs {lvalue})
xAxisRotation((PathArcArgs)arg1, (float)arg2) → None :
C++ signature :
void xAxisRotation(Magick::PathArcArgs {lvalue},double)

xAxisRotation( (PathArcArgs)arg1) -> float :

C++ signature :
double xAxisRotation(Magick::PathArcArgs {lvalue})
y((PathArcArgs)arg1, (float)arg2) → None :
C++ signature :
void y(Magick::PathArcArgs {lvalue},double)

y( (PathArcArgs)arg1) -> float :

C++ signature :
double y(Magick::PathArcArgs {lvalue})

PathArcArgsList Class

class pgmagick.PathArcArgsList[source]
append((PathArcArgsList)arg1, (PathArcArgs)arg2) → None :
C++ signature :
void append(std::list<Magick::PathArcArgs, std::allocator<Magick::PathArcArgs> > {lvalue},Magick::PathArcArgs)
count((PathArcArgsList)arg1) → int :
C++ signature :
unsigned int count(std::list<Magick::PathArcArgs, std::allocator<Magick::PathArcArgs> > {lvalue})
pop((PathArcArgsList)arg1) → None :
C++ signature :
void pop(std::list<Magick::PathArcArgs, std::allocator<Magick::PathArcArgs> > {lvalue})
pop_back((PathArcArgsList)arg1) → None :
C++ signature :
void pop_back(std::list<Magick::PathArcArgs, std::allocator<Magick::PathArcArgs> > {lvalue})
push_back((PathArcArgsList)arg1, (PathArcArgs)arg2) → None :
C++ signature :
void push_back(std::list<Magick::PathArcArgs, std::allocator<Magick::PathArcArgs> > {lvalue},Magick::PathArcArgs)
remove((PathArcArgsList)arg1, (PathArcArgs)arg2) → None :
C++ signature :
void remove(std::list<Magick::PathArcArgs, std::allocator<Magick::PathArcArgs> > {lvalue},Magick::PathArcArgs)
reverse((PathArcArgsList)arg1) → None :
C++ signature :
void reverse(std::list<Magick::PathArcArgs, std::allocator<Magick::PathArcArgs> > {lvalue})

PathArcRel Class

class pgmagick.PathArcRel[source]

PathClosePath Class

class pgmagick.PathClosePath[source]

PathCurveToArgsList Class

class pgmagick.PathCurveToArgsList[source]
append((PathCurveToArgsList)arg1, (PathCurvetoArgs)arg2) → None :
C++ signature :
void append(std::list<Magick::PathCurvetoArgs, std::allocator<Magick::PathCurvetoArgs> > {lvalue},Magick::PathCurvetoArgs)
count((PathCurveToArgsList)arg1) → int :
C++ signature :
unsigned int count(std::list<Magick::PathCurvetoArgs, std::allocator<Magick::PathCurvetoArgs> > {lvalue})
pop((PathCurveToArgsList)arg1) → None :
C++ signature :
void pop(std::list<Magick::PathCurvetoArgs, std::allocator<Magick::PathCurvetoArgs> > {lvalue})
pop_back((PathCurveToArgsList)arg1) → None :
C++ signature :
void pop_back(std::list<Magick::PathCurvetoArgs, std::allocator<Magick::PathCurvetoArgs> > {lvalue})
push_back((PathCurveToArgsList)arg1, (PathCurvetoArgs)arg2) → None :
C++ signature :
void push_back(std::list<Magick::PathCurvetoArgs, std::allocator<Magick::PathCurvetoArgs> > {lvalue},Magick::PathCurvetoArgs)
remove((PathCurveToArgsList)arg1, (PathCurvetoArgs)arg2) → None :
C++ signature :
void remove(std::list<Magick::PathCurvetoArgs, std::allocator<Magick::PathCurvetoArgs> > {lvalue},Magick::PathCurvetoArgs)
reverse((PathCurveToArgsList)arg1) → None :
C++ signature :
void reverse(std::list<Magick::PathCurvetoArgs, std::allocator<Magick::PathCurvetoArgs> > {lvalue})

PathCurvetoAbs Class

class pgmagick.PathCurvetoAbs[source]

PathCurvetoArgs Class

class pgmagick.PathCurvetoArgs[source]
x((PathCurvetoArgs)arg1, (float)arg2) → None :
C++ signature :
void x(Magick::PathCurvetoArgs {lvalue},double)

x( (PathCurvetoArgs)arg1) -> float :

C++ signature :
double x(Magick::PathCurvetoArgs {lvalue})
x1((PathCurvetoArgs)arg1, (float)arg2) → None :
C++ signature :
void x1(Magick::PathCurvetoArgs {lvalue},double)

x1( (PathCurvetoArgs)arg1) -> float :

C++ signature :
double x1(Magick::PathCurvetoArgs {lvalue})
x2((PathCurvetoArgs)arg1, (float)arg2) → None :
C++ signature :
void x2(Magick::PathCurvetoArgs {lvalue},double)

x2( (PathCurvetoArgs)arg1) -> float :

C++ signature :
double x2(Magick::PathCurvetoArgs {lvalue})
y((PathCurvetoArgs)arg1, (float)arg2) → None :
C++ signature :
void y(Magick::PathCurvetoArgs {lvalue},double)

y( (PathCurvetoArgs)arg1) -> float :

C++ signature :
double y(Magick::PathCurvetoArgs {lvalue})
y1((PathCurvetoArgs)arg1, (float)arg2) → None :
C++ signature :
void y1(Magick::PathCurvetoArgs {lvalue},double)

y1( (PathCurvetoArgs)arg1) -> float :

C++ signature :
double y1(Magick::PathCurvetoArgs {lvalue})
y2((PathCurvetoArgs)arg1, (float)arg2) → None :
C++ signature :
void y2(Magick::PathCurvetoArgs {lvalue},double)

y2( (PathCurvetoArgs)arg1) -> float :

C++ signature :
double y2(Magick::PathCurvetoArgs {lvalue})

PathCurvetoRel Class

class pgmagick.PathCurvetoRel[source]

PathLinetoAbs Class

class pgmagick.PathLinetoAbs[source]

PathLinetoHorizontalAbs Class

class pgmagick.PathLinetoHorizontalAbs[source]
x((PathLinetoHorizontalAbs)arg1, (float)arg2) → None :
C++ signature :
void x(Magick::PathLinetoHorizontalAbs {lvalue},double)

x( (PathLinetoHorizontalAbs)arg1) -> float :

C++ signature :
double x(Magick::PathLinetoHorizontalAbs {lvalue})

PathLinetoHorizontalRel Class

class pgmagick.PathLinetoHorizontalRel[source]
x((PathLinetoHorizontalRel)arg1, (float)arg2) → None :
C++ signature :
void x(Magick::PathLinetoHorizontalRel {lvalue},double)

x( (PathLinetoHorizontalRel)arg1) -> float :

C++ signature :
double x(Magick::PathLinetoHorizontalRel {lvalue})

PathLinetoRel Class

class pgmagick.PathLinetoRel[source]

PathLinetoVerticalAbs Class

class pgmagick.PathLinetoVerticalAbs[source]
y((PathLinetoVerticalAbs)arg1, (float)arg2) → None :
C++ signature :
void y(Magick::PathLinetoVerticalAbs {lvalue},double)

y( (PathLinetoVerticalAbs)arg1) -> float :

C++ signature :
double y(Magick::PathLinetoVerticalAbs {lvalue})

PathLinetoVerticalRel Class

class pgmagick.PathLinetoVerticalRel[source]
y((PathLinetoVerticalRel)arg1, (float)arg2) → None :
C++ signature :
void y(Magick::PathLinetoVerticalRel {lvalue},double)

y( (PathLinetoVerticalRel)arg1) -> float :

C++ signature :
double y(Magick::PathLinetoVerticalRel {lvalue})

PathMovetoAbs Class

class pgmagick.PathMovetoAbs[source]

PathMovetoRel Class

class pgmagick.PathMovetoRel[source]

PathQuadraticCurvetoAbs Class

class pgmagick.PathQuadraticCurvetoAbs[source]

PathQuadraticCurvetoArgs Class

class pgmagick.PathQuadraticCurvetoArgs[source]
x((PathQuadraticCurvetoArgs)arg1, (float)arg2) → None :
C++ signature :
void x(Magick::PathQuadraticCurvetoArgs {lvalue},double)

x( (PathQuadraticCurvetoArgs)arg1) -> float :

C++ signature :
double x(Magick::PathQuadraticCurvetoArgs {lvalue})
x1((PathQuadraticCurvetoArgs)arg1, (float)arg2) → None :
C++ signature :
void x1(Magick::PathQuadraticCurvetoArgs {lvalue},double)

x1( (PathQuadraticCurvetoArgs)arg1) -> float :

C++ signature :
double x1(Magick::PathQuadraticCurvetoArgs {lvalue})
y((PathQuadraticCurvetoArgs)arg1, (float)arg2) → None :
C++ signature :
void y(Magick::PathQuadraticCurvetoArgs {lvalue},double)

y( (PathQuadraticCurvetoArgs)arg1) -> float :

C++ signature :
double y(Magick::PathQuadraticCurvetoArgs {lvalue})
y1((PathQuadraticCurvetoArgs)arg1, (float)arg2) → None :
C++ signature :
void y1(Magick::PathQuadraticCurvetoArgs {lvalue},double)

y1( (PathQuadraticCurvetoArgs)arg1) -> float :

C++ signature :
double y1(Magick::PathQuadraticCurvetoArgs {lvalue})

PathQuadraticCurvetoArgsList Class

class pgmagick.PathQuadraticCurvetoArgsList[source]
append((PathQuadraticCurvetoArgsList)arg1, (PathQuadraticCurvetoArgs)arg2) → None :
C++ signature :
void append(std::list<Magick::PathQuadraticCurvetoArgs, std::allocator<Magick::PathQuadraticCurvetoArgs> > {lvalue},Magick::PathQuadraticCurvetoArgs)
count((PathQuadraticCurvetoArgsList)arg1) → int :
C++ signature :
unsigned int count(std::list<Magick::PathQuadraticCurvetoArgs, std::allocator<Magick::PathQuadraticCurvetoArgs> > {lvalue})
pop((PathQuadraticCurvetoArgsList)arg1) → None :
C++ signature :
void pop(std::list<Magick::PathQuadraticCurvetoArgs, std::allocator<Magick::PathQuadraticCurvetoArgs> > {lvalue})
pop_back((PathQuadraticCurvetoArgsList)arg1) → None :
C++ signature :
void pop_back(std::list<Magick::PathQuadraticCurvetoArgs, std::allocator<Magick::PathQuadraticCurvetoArgs> > {lvalue})
push_back((PathQuadraticCurvetoArgsList)arg1, (PathQuadraticCurvetoArgs)arg2) → None :
C++ signature :
void push_back(std::list<Magick::PathQuadraticCurvetoArgs, std::allocator<Magick::PathQuadraticCurvetoArgs> > {lvalue},Magick::PathQuadraticCurvetoArgs)
remove((PathQuadraticCurvetoArgsList)arg1, (PathQuadraticCurvetoArgs)arg2) → None :
C++ signature :
void remove(std::list<Magick::PathQuadraticCurvetoArgs, std::allocator<Magick::PathQuadraticCurvetoArgs> > {lvalue},Magick::PathQuadraticCurvetoArgs)
reverse((PathQuadraticCurvetoArgsList)arg1) → None :
C++ signature :
void reverse(std::list<Magick::PathQuadraticCurvetoArgs, std::allocator<Magick::PathQuadraticCurvetoArgs> > {lvalue})

PathQuadraticCurvetoRel Class

class pgmagick.PathQuadraticCurvetoRel[source]

PathSmoothCurvetoAbs Class

class pgmagick.PathSmoothCurvetoAbs[source]

PathSmoothCurvetoRel Class

class pgmagick.PathSmoothCurvetoRel[source]

PathSmoothQuadraticCurvetoAbs Class

class pgmagick.PathSmoothQuadraticCurvetoAbs[source]

PathSmoothQuadraticCurvetoRel Class

class pgmagick.PathSmoothQuadraticCurvetoRel[source]

Pixels Class

class pgmagick.Pixels[source]
columns((Pixels)arg1) → int :
C++ signature :
unsigned int columns(Magick::Pixels {lvalue})
rows((Pixels)arg1) → int :
C++ signature :
unsigned int rows(Magick::Pixels {lvalue})
sync((Pixels)arg1) → None :
C++ signature :
void sync(Magick::Pixels {lvalue})
x((Pixels)arg1) → int :
C++ signature :
int x(Magick::Pixels {lvalue})
y((Pixels)arg1) → int :
C++ signature :
int y(Magick::Pixels {lvalue})

TypeMetric Class

class pgmagick.TypeMetric[source]
ascent((TypeMetric)arg1) → float :
C++ signature :
double ascent(Magick::TypeMetric {lvalue})
descent((TypeMetric)arg1) → float :
C++ signature :
double descent(Magick::TypeMetric {lvalue})
maxHorizontalAdvance((TypeMetric)arg1) → float :
C++ signature :
double maxHorizontalAdvance(Magick::TypeMetric {lvalue})
textHeight((TypeMetric)arg1) → float :
C++ signature :
double textHeight(Magick::TypeMetric {lvalue})
textWidth((TypeMetric)arg1) → float :
C++ signature :
double textWidth(Magick::TypeMetric {lvalue})

VPath Class

class pgmagick.VPath[source]

VPathList Class

class pgmagick.VPathList[source]
append((VPathList)arg1, (VPath)arg2) → None :
C++ signature :
void append(std::list<Magick::VPath, std::allocator<Magick::VPath> > {lvalue},Magick::VPath)
count((VPathList)arg1) → int :
C++ signature :
unsigned int count(std::list<Magick::VPath, std::allocator<Magick::VPath> > {lvalue})
pop((VPathList)arg1) → None :
C++ signature :
void pop(std::list<Magick::VPath, std::allocator<Magick::VPath> > {lvalue})
pop_back((VPathList)arg1) → None :
C++ signature :
void pop_back(std::list<Magick::VPath, std::allocator<Magick::VPath> > {lvalue})
push_back((VPathList)arg1, (VPath)arg2) → None :
C++ signature :
void push_back(std::list<Magick::VPath, std::allocator<Magick::VPath> > {lvalue},Magick::VPath)
remove((VPathList)arg1, (VPath)arg2) → None :
C++ signature :
void remove(std::list<Magick::VPath, std::allocator<Magick::VPath> > {lvalue},Magick::VPath)
reverse((VPathList)arg1) → None :
C++ signature :
void reverse(std::list<Magick::VPath, std::allocator<Magick::VPath> > {lvalue})

gminfo Class

Table Of Contents

Previous topic

Cookbook

This Page