API Reference

Contents

Blob Class

class pgmagick.Blob(*args)

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

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

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

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

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

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

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

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

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

DrawableAffine Class

class pgmagick.DrawableAffine

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

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

DrawableCircle Class

class pgmagick.DrawableCircle

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

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

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

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

DrawableDashOffset Class

class pgmagick.DrawableDashOffset

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

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

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

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

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

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

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

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

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

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

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

DrawablePoint Class

class pgmagick.DrawablePoint

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

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

DrawablePolyline Class

class pgmagick.DrawablePolyline

DrawablePopClipPath Class

class pgmagick.DrawablePopClipPath

DrawablePopGraphicContext Class

class pgmagick.DrawablePopGraphicContext

DrawablePopPattern Class

class pgmagick.DrawablePopPattern

DrawablePushClipPath Class

class pgmagick.DrawablePushClipPath

DrawablePushGraphicContext Class

class pgmagick.DrawablePushGraphicContext

DrawablePushPattern Class

class pgmagick.DrawablePushPattern

DrawableRectangle Class

class pgmagick.DrawableRectangle

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

PathArcArgs Class

class pgmagick.PathArcArgs

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

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

PathClosePath Class

class pgmagick.PathClosePath

PathCurveToArgsList Class

class pgmagick.PathCurveToArgsList

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

PathCurvetoArgs Class

class pgmagick.PathCurvetoArgs

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

PathLinetoAbs Class

class pgmagick.PathLinetoAbs

PathLinetoHorizontalAbs Class

class pgmagick.PathLinetoHorizontalAbs

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

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

PathLinetoVerticalAbs Class

class pgmagick.PathLinetoVerticalAbs

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

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

PathMovetoRel Class

class pgmagick.PathMovetoRel

PathQuadraticCurvetoAbs Class

class pgmagick.PathQuadraticCurvetoAbs

PathQuadraticCurvetoArgs Class

class pgmagick.PathQuadraticCurvetoArgs

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

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

PathSmoothCurvetoAbs Class

class pgmagick.PathSmoothCurvetoAbs

PathSmoothCurvetoRel Class

class pgmagick.PathSmoothCurvetoRel

PathSmoothQuadraticCurvetoAbs Class

class pgmagick.PathSmoothQuadraticCurvetoAbs

PathSmoothQuadraticCurvetoRel Class

class pgmagick.PathSmoothQuadraticCurvetoRel

Pixels Class

class pgmagick.Pixels

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

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

VPathList Class

class pgmagick.VPathList

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