Magick::Drawable

Contents

Drawable provides a convenient interface for preparing vector, image, or text arguments for the Image::draw() method. Each instance of a Drawable sub-class represents a single drawable object. Drawable objects may be drawn "one-by-one" via multiple invocations of the Image draw() method, or may be drawn "all-at-once" by passing a list of Drawable objects to the Image draw() method. The one-by-one approach is convenient for simple drawings, while the list-based approach is appropriate for drawings which require more sophistication.

The following is an example using the Drawable subclasses with a one-by-one approach to draw the following figure:

Figure showing drawing example 
#include <string>
#include <iostream>
#include <Magick++.h>

using namespace std;
using namespace Magick;

int main(int /*argc*/,char **argv)
{
  try {
    InitializeMagick(*argv);

    // Create base image (white image of 300 by 200 pixels)
    Image image( Geometry(300,200), Color("white") );

    // Set draw options
    image.strokeColor("red"); // Outline color
    image.fillColor("green"); // Fill color
    image.strokeWidth(5);

    // Draw a circle
    image.draw( DrawableCircle(100,100, 50,100) );

    // Draw a rectangle
    image.draw( DrawableRectangle(200,200, 270,170) );

    // Display the result
    image.display( );
  }
  catch( exception &error_ )
    {
      cout << "Caught exception: " << error_.what() << endl;
      return 1;
    }

  return 0;
}

Since Drawable is an object it may be saved in an array or a list for later (perhaps repeated) use. The following example shows how to draw the same figure using the list-based approach:

#include <string>
#include <iostream>
#include <list>
#include <Magick++.h>

using namespace std;
using namespace Magick;

int main(int /*argc*/,char **/*argv*/)
{
  try {

    InitializeMagick(*argv);

    // Create base image (white image of 300 by 200 pixels)
    Image image( Geometry(300,200), Color("white") );

    // Construct drawing list
    std::list<Magick::Drawable> drawList;

    // Add some drawing options to drawing list
    drawList.push_back(DrawableStrokeColor("red")); // Outline color
    drawList.push_back(DrawableStrokeWidth(5)); // Stroke width
    drawList.push_back(DrawableFillColor("green")); // Fill color

    // Add a Circle to drawing list
    drawList.push_back(DrawableCircle(100,100, 50,100));

    // Add a Rectangle to drawing list
    drawList.push_back(DrawableRectangle(200,100, 270,170));

    // Draw everything using completed drawing list
    image.draw(drawList);

    // Display the result
    image.display( );
  }
  catch( exception &error_ )
    {
      cout << "Caught exception: " << error_.what() << endl;
      return 1;
    }

  return 0;
}

Coordinate structure

Drawable depends on the simple Coordinate structure which represents a pair of x,y coodinates. The Coordinate structure is defined as follows:

class Coordinate
{
public:

  // Default Constructor
  Coordinate ( void );

  // Constructor, setting first & second
  Coordinate ( double x_, double y_ );

  // Destructor
  virtual ~Coordinate ();

  // x coordinate member
  void   x ( double x_ );
  double x ( void ) const;

  // y coordinate member
  void   y ( double y_ );
  double y ( void ) const;
};

Drawable classes

Drawable classes represent objects to be drawn on the image.

DrawableAffine

Specify a transformation matrix to adjust scaling, rotation, and translation (coordinate transformation) for subsequently drawn objects in the same or decendent drawing context. The sx_ & sy_ parameters represent the x & y scale factors, the rx_ & ry_ parameters represent the x & y rotation, and the tx_ & ty_ parameters represent the x & y translation:

DrawableAffine ( double sx_, double sy_,
                 double rx_, double ry_,
                 double tx_, double ty_ );

Specify a transformation matrix to adjust scaling, rotation, and translation (coordinate transformation) for subsequently drawn objects in the same or decendent drawing context. Initialized to unity (no effect) affine values. Use class methods (not currently documented but defined in the Drawable.h header file) to adjust individual parameters from their unity values:

DrawableAffine ( void );

DrawableArc

Draw an arc using the stroke color and based on the circle starting at coordinates startX_,`startY_`, and ending with coordinates endX_,`endY_`, and bounded by the rotational arc startDegrees_,`endDegrees_`:

DrawableArc ( double startX_, double startY_,
              double endX_, double endY_,
              double startDegrees_, double endDegrees_ );

DrawableBezier

Draw a bezier curve using the stroke color and based on the coordinates specified by the coordinates_ list:

DrawableBezier ( const CoordinateList &coordinates_ );

DrawableClipPath

Select a drawing clip path matching id_:

DrawableClipPath ( const std::string &id_ );

DrawableCircle

Draw a circle using the stroke color and thickness using specified origin and perimeter coordinates. If a fill color is specified, then the object is filled:

DrawableCircle ( double originX_, double originY_,
                 double perimX_, double perimY_ )

DrawableColor

Color image according to paintMethod. The point method recolors the target pixel. The replace method recolors any pixel that matches the color of the target pixel. Floodfill recolors any pixel that matches the color of the target pixel and is a neighbor, whereas filltoborder recolors any neighbor pixel that is not the border color. Finally, reset recolors all pixels:

DrawableColor ( double x_, double y_,
                PaintMethod paintMethod_ )

DrawableCompositeImage

Composite current image with contents of specified image, at specified coordinates. If the matte attribute is set to true, then the image composition will consider an alpha channel, or transparency, present in the image file so that non-opaque portions allow part (or all) of the composite image to show through:

DrawableCompositeImage ( double x_, double y_,
                         const std::string &filename_ );
DrawableCompositeImage ( double x_, double y_,
                         const Image &image_ );

Composite current image with contents of specified image, rendered with specified width and height, at specified coordinates. If the matte attribute is set to true, then the image composition will consider an alpha channel, or transparency, present in the image file so that non-opaque portions allow part (or all) of the composite image to show through. If the specified width or height is zero, then the image is composited at its natural size, without enlargement or reduction:

DrawableCompositeImage ( double x_, double y_,
                         double width_, double height_,
                         const std::string &filename_ );

DrawableCompositeImage ( double x_, double y_,
                         double width_, double height_,
                         const Image &image_ );

Composite current image with contents of specified image, rendered with specified width and height, using specified composition algorithm, at specified coordinates. If the matte attribute is set to true, then the image composition will consider an alpha channel, or transparency, present in the image file so that non-opaque portions allow part (or all) of the composite image to show through. If the specified width or height is zero, then the image is composited at its natural size, without enlargement or reduction:

DrawableCompositeImage ( double x_, double