dolt: the drawableObject Library

Wes Huang and Kris Beevers

Rensselaer Polytechnic Institute
Algorithmic Robotics Laboratory

Table of Contents

1. Introduction

• 1.1 Contributors
• 1.2 Feedback
• 1.3 Distribution Policy

2. Installation

• 2.1 Downloading
• 2.2 Compilation
  • 2.2.1 Unix
  • 2.2.2 Microsoft Windows
• 2.3 Writing Programs
  • 2.3.1 Unix
  • 2.3.2 Microsoft Windows

3. Structure

• 3.1 Class Heirarchy

4. Base Classes

• 4.1 drawableObject
• 4.2 drawableLineObject
• 4.3 drawableEnclosedObject

5. Drawable Objects

• 5.1 drawableText
• 5.2 drawableImage

6. Color

7. Output

• 7.1 Scenes
• 7.2 Event Handlers
• 7.3 Zooming, Panning and Point-mapping
• 7.4 GL Output
• 7.5 Requesting Non-GL (Instantaneous) Output
  • 7.5.1 Postscript Output
  • 7.5.2 Screenshots

8. Geometric Representations

• 8.1 CGAL Objects
• 8.2 Ellipse
• 8.3 lineStrip
• 8.4 Rectangle
• 8.5 Square
• 8.6 Arc

9. Example Program

10. Errata/Todo

11. Release History

1. Introduction

dolt makes use of the GLUT OpenGL graphics library and requires the library to be installed. Optionally, it can also be used in conjunction with the Computational Geometry Algorithms Library (CGAL), though CGAL is not required for use of dolt.

Because dolt was created quickly and for specific purposes, there are likely some problems (e.g. bugs, design flaws, etc.) that haven't presented themselves to us. As such, dolt is to be considered a still-developing project.

1.1 Contributors

1.2 Feedback

Before sending bug reports or suggestions, please read this entire document (especially the Errata/Todo Section) and send detailed information about the problem.

1.3 Distribution Policy

2. Installation

2.1 Downloading

• TAR.GZ: dolt-0.96.tgz
• ZIP: dolt-0.96.zip -->

2.2 Compilation

2.2.1 Unix

	$ gunzip dolt-0.95.tar.gz | tar -xf -

	$ make
	$ make cgal     # optional, only if you are using CGAL support
	$ make install

2.2.2 Microsoft Windows

In the win32 subdirectory of the unzipped package is a .dsw (workspace) file. Open this in Visual Studio and compile the 'dolt' project. This should produce the file dolt.lib. Move this file to your Visual Studio library directory. If you wish to compile a version of dolt with CGAL support, do the same for the project called 'dolt_cgal' (which will produce dolt-cgal.lib). Finally, move the files in include to your Visual Studio include directory, in a subdirectory called dolt.

2.3 Writing Programs

2.3.1 Unix

	$ g++ program.cc -I/path/to/dolt/include -L/path/to/dolt/lib \
	 -ldolt -lglut -lGL -lGLU -lX11

2.3.2 Microsoft Windows

3. Structure

• Setting up an output window on screen
• Creating a number of "drawable" 2d geometric objects
• Manipulating rendering of these objects (line styles, fill styles, colors, etc.)
• Automatic mapping of world coordinates to rendering coordinates
• Output to Postscript
• Zooming and panning
• User-definable handlers for keyboard and mouse events
• User-definable idle function for animation

3.1 Class Heirarchy

4. Base Classes

4.1 drawableObject

This is the base class for all objects capable of being rendered (to screen or to Postscript) by dolt. It stores information common to all "drawable objects," specifically color information, and provides a default color for all objects to use. It is an abstract class and cannot be instantiated by itself. drawableObject provides the following public functions:

static inline void setDefaultObjectColor( const Color &c )

	drawableObject::setDefaultColor( Color(1.0,0.0,0.0) );

inline void setColor( const Color &c )

drawablePoint p(0.0,1.0);
p.setColor( Color(1.0,0.0,0.0) );

inline void setAlpha( float a )

drawablePoint p(0.0,1.0);
p.setAlpha( 0.5 ); // 50% transparent

inline const Color & getColor() const

drawablePoint p(0.0,1.0);
Color c = p.getColor();

virtual void drawGL( const Graphics &out ) const

virtual void drawPS( const Graphics &out, psFile &ps,
	const Bbox &bounds, const double &scale ) const

4.2 drawableLineObject

drawableLineObject, derived from drawableObject , should be used to represent any objects that consist only of "line art" (e.g. that are not filled in any way). It stores information about line width and dash patterns (stippling), and a global default line width. An accessory to drawableLineObject is the lineStyle type for describing dash patterns. See the setLineStyle function for more information on this. The drawableLineObject class cannot be directly instantiated; only classes derived from it that provide drawGL and drawPS functions can be instantiated.

drawableLineObject( lineStyle style = SOLID, float lineWidth = defaultWidth )

static inline void setDefaultLineWidth( float width )

	drawableLineObject::setDefaultLineWidth( 1.0 ); // 1 pixel wide

inline void setLineStyle( lineStyle style )

	drawableSegment s( Point(0.0,0.0), Point(1.0,1.0) );
	s.setLineStyle( DASHED ); // 1111111100000000
	s.setLineStyle( 0x0101 ); // 0000000100000001

inline void setLineWidth( float width )

	drawableSegment s( Point(0.0,0.0), Point(1.0,1.0) );
	s.setLineWidth( 3.0 ); // 3 pixels wide

inline lineStyle getLineStyle() const

drawableSegment s( Point(0.0,0.0), Point(1.0,1.0) );
lineStyle ls = p.getLineStyle();

inline float getLineWidth() const

drawableSegment s( Point(0.0,0.0), Point(1.0,1.0) );
float w = p.getLineWidth();

4.3 drawableEnclosedObject

drawableEnclosedObject, derived from drawableLineObject, should be used to represent any objects that are filled in some way (e.g. polygons, circles, etc.) and that might have a border. It stores information about whether or not the object should be filled, whether its border should be drawn, the color of the border, and a global default border width. The drawableEnclosedObject class cannot be directly instantiated; only classes derived from it that provide drawGL and drawPS functions can be instantiated. Note: to set the border width of the enclosed object, the setLineWidth member of the parent class ( drawableLineObject) can be called.

drawableEnclosedObject( bool filled = true,
	lineStyle style = SOLID, float lineWidth = defaultWidth )

static inline void setDefaultBorderColor( const Color &c )

	Color red(1.0,0.0,0.0);
	drawableEnclosedObject::setDefaultBorderColor( red );

static inline void setDefaultLineWidth( float width )

	drawableEnclosedObject::setDefaultLineWidth( 2.0 ); // 2 pixels

inline void setFilled( bool filled )

	drawablePolygon p;
	p.setFilled( false );

inline void setBorderColor( const Color &c )

	drawablePolygon p;
	p.setBorderColor( Color(1.0,0.0,0.0) );

inline bool getFilled() const

	drawablePolygon p;
	bool filled = p.getFilled();

inline const Color & getBorderColor() const

	drawablePolygon p;
	Color c = p.getBorderColor();

5. Drawable Objects

The most important functionality of dolt (and its purpose) is to render 2-dimensional geometric objects to the screen. This is accomplished by providing a set of "drawable" versions of the geometric objects discussed above. The drawable versions inherit methods from both drawableObject and their geometric representation, and thus provide the public interfaces of both. For example, a drawablePoint stores information both about the location of a point and about its color. See the Class Heirarchy for information about which drawable objects inherit what.

The following drawable objects are provided:

• drawablePoint
• drawableSegment
• drawableLineStrip
• drawablePolygon
• drawableEllipse
• drawableCircle
• drawablePoint
• drawableRectangle
• drawableSquare
• drawableArc
• drawableWedge
• drawableText
• drawableImage

	void foo( const Point &point ) { ... }
	void bar( const drawablePoint &dpoint ) { ... }

	Point p(1.0,1.0);
	drawablePoint q(p);

	foo( p ); // ok
	foo( q ); // ok
	foo( drawablePoint(8.0,8.0) ); // ok
	bar( q ); // ok
	bar( p ); // ok
	bar( Point(0.0,0.0) ); // ok

One exception is drawablePolygon, which extends Polygon to allow for holes in the polygon. To insert a hole in a drawablePolygon, use drawablePolygon::addHole; note also that a drawablePolygon can be nonconvex:

void addHole( const Polygon &hole )

	drawablePolygon poly; // create a nonconvex polygon
	poly.push_back( Point(1.0,1.0) );
	poly.push_back( Point(5.0,4.0) );
	poly.push_back( Point(9.0,1.0) );
	poly.push_back( Point(6.0,5.0) );
	poly.push_back( Point(9.0,9.0) );
	poly.push_back( Point(5.0,6.0) );
	poly.push_back( Point(1.0,9.0) );
	poly.push_back( Point(4.0,5.0) );
	
	Polygon hole; // add a square hole in the middle
	hole.push_back( Point(4.5,4.5) );
	hole.push_back( Point(5.5,4.5) );
	hole.push_back( Point(5.5,5.5) );
	hole.push_back( Point(4.5,5.5) );
	poly.addHole( hole );

5.1 drawableText

drawableText is meant to be a (very) simple text-drawing interface that makes use of system-available fonts. It is cross-platform compatible for Win32 and *nix, though the user may have to handle the cross- platform case using preprocessor commands if this compatibility is desired because of the differences in font-naming conventions across platforms.

drawableText( const Point &location, const char *text = "",
    int points = 12, const char *postscriptFont = "Palatino-Roman",
	const char *screenFont = DEFAULTFONT );

	#ifdef _WIN32
		drawableText txt(Point(1.0,1.0),"Test",12,"Helvetica","Helvetica");
	#else
		drawableText txt(Point(1.0,1.0),"Test",12,"Helvetica",
			"-adobe-helvetica-medium-r-normal--12-*-*-*-p-*-iso8859-1");
	#endif

5.2 drawableImage

drawableImage provides an interface for sampled image (bitmap) drawing, loading, saving and manipulation within the drawableObject framework. It can perform its functionality for images with one byte per pixel (grayscale) or three bytes per pixel (RGB). Images are mapped to world coordinates with a bounding box, and thus can be stretched or compressed to fit within the bounding box. Individual pixels or the entire color buffer can be manipulated.

Image drawing to screen is done via a raster operation, which is slower than texture mapping but allows for the use of images of arbitrary size (OpenGL textures must be 2^n x 2^n pixels).

Note that the image is stored as a single buffer of increasing x and y pixel coordinates. The image coordinate frame origin is at the lower left of the image.

drawableImage()
drawableImage( const Bbox &worldLocation )
drawableImage( const Bbox &worldLocation, unsigned int w,
  unsigned int h, bytespp bytes = BPP3 );
drawableImage( const drawableImage &i );

	drawableImage img; // no color buffer created
	drawableImage img2( Bbox(0.0,0.0,10.0,10.0) ); // no color buffer created
	drawableImage img3( Bbox(0.0,0.0,10.0,10.0), 100, 100, BPP3 ); // color buffer created
	drawableImage img4( img3 ); // copies color buffer of img3

inline void setWorldLocation( const Bbox &worldLocation )

	drawableImage img;
	img.setWorldLocation( Bbox(0.0,0.0,10.0,10.0) );

inline unsigned int getWidth() const
inline unsigned int getHeight() const

	drawableImage img( Bbox(), 640, 480 );
	unsigned int w = img.getWidth(); // 640
	unsigned int h = img.getHeight(); // 480

inline unsigned char * getBuffer()

	drawableImage img( Bbox(), 640, 480 );
	unsigned char *buf = img.getBuffer();

void setPixel( unsigned int x, unsigned int y, const unsigned char *col )
const unsigned char * const getPixel( unsigned int x, unsigned int y ) const

	drawableImage img( Bbox(), 640, 480, BPP1 );
	unsigned char pix;
	pix = *img.getPixel( 10, 10 );
	pix = 0xf0;
	img.setPixel( 10, 10, &pix );
	drawableImage img2( Bbox(), 640, 480, BPP3 );
	unsigned char pix2[3], *pix3;
	pix3 = img.getPixel( 10, 10 );
	pix2[0] = pix2[1] = 0xff;
	pix2[2] = 0x00;
	img.setPixel( 10, 10, pix2 ); // set to yellow

bool loadPPM( const char *filename )

	drawableImage img( Bbox(0.0,0.0,10.0,10.0) );
	if( !img.loadPPM( "test.ppm" ) )
		cout << "Error loading test.ppm" << endl;

bool savePPM( const char *filename, bool binaryFile = true ) const

	drawableImage img( Bbox(0.0,0.0,10.0,10.0), 200, 200, BPP3 );
	... // perform operations on the image color buffer
	if( !img.savePPM( "out.ppm", true ) )
		cout << "Error saving out.ppm" << endl;

6. Color

Color provides an interface for all color assignment and use within dolt. It stores red, green, blue and alpha (transparency) values for colors. Additionally, it provides functionality for mapping names (strings) to color values. Note: the default value (if one is never assigned) for a color is white (1.0,1.0,1.0). Also, color names should not begin with any of the digit characters (0-9) or the period character (though this is not enforced).

Color( float r = 1.0, float g = 1.0, float b = 1.0, float a = 1.0 )

	Color red(1.0,0.0,0.0);
	Color yellow(1.0,1.0,0.0);
	Color transparent(1.0,0.0,0.0,0.5); // 50% transparent

Color( const char *name )

	Color red("red");

inline void setRGB( float r, float g, float b )

	Color c;
	c.setRGB( 1.0, 0.0, 0.0 );

inline void setAlpha( float a )

	Color c("red");
	c.setAlpha( 0.5 ); // 50% transparent
	c.setAlpha( 0.0 ); // completely transparent
	c.setAlpha( 1.0 ); // completely opaque

inline float r() const
inline float g() const
inline float b() const
inline float a() const

	Color c("red");
	c.r(); // returns 1.0
	c.g(); // returns 0.0

void nameColor( const char *name )

	Color c(1.0,0.0,0.0);
	c.nameColor( "red" );
	Color x("red"); // x == c

7. Output

The Graphics class provides two important types of functionality. It stores scene information (i.e. all objects to be drawn in any rendering context), and if necessary renders to the screen (using GLUT).

Following are the initializers for the Graphics class:

Graphics()

Graphics( const Bbox &world )

	Graphics g( Bbox(0.0,0.0,10.0,10.0) );

inline void setWorldBounds( const Bbox &world )

	Graphics g;
	g.setWorldBounds( Bbox(0.0,0.0,5.0,5.0) );

7.1 Scenes

In order to add objects to a scene, one must first create an objectList -- which is simply a std::list<drawableObject *> and can be treated as such. So, for example, to create a list of Points to draw to the screen, one could do the following:

	Point a(0.0,0.0);
	Point b(1.0,1.0);
	Point c(2.0,2.0);
	objectList objects;
	objects.push_back( &a );
	objects.push_back( &b );
	objects.push_back( &c );

The list is now ready to be inserted into the scene. This can be done with the addObjectList function (objecLists can be removed with the counterpart delObjectList function).

void addObjectList( const objectList &olist )

	g.addObjectList( objects );

void delObjectList( const objectList &olist )

	g.addObjectList( objects );
	g.delObjectList( objects );

static void setCurrentScene( Graphics &g )

	Graphics g1;
	Graphics g2;
	// g1 is the currently rendering scene
	Graphics::setCurrentScene( g2 );
	// g2 is the currently rendering scene

7.2 Event Handlers

void setKeyboardHandler( void (*kb)( unsigned char key ) )

	void kb( unsigned char key )
	{
		cout << key << " was pressed!" << endl;
	}
	...
	g.setKeyboardHandler( kb );

void setMouseHandler( void (*mouse)( int button, int state, int x, int y ) )

	void mouse( int button, int state, int x, int y ) { ... }
	...
	g.setMouseHandler( mouse );

void setMotionHandler( void (*motion)( int x, int y ) )

	void motion( int x, int y ) { ... }
	...
	g.setMotionHandler( motion );

void setIdleFunction( void (*idle)( void ) )

	void motion( int x, int y ) { ... }
	...
	g.setMotionHandler( motion );

void printControlKeyBindings() const

	cout << "Keyboard Commands:" << endl;
	g.printControlKeyBindings();

Also, a built-in handler for special keyboard events exists, and is used for the control of zooming and panning of the scene. The built in controls are as follows:

• Page Up: zoom closer to the scene
• Shift + Page Up: fast zoom closer to the scene
• Page Down: zoom farther from the scene
• Shift + Page Down: fast zoom farther from the scene
• Left Arrow: pan left
• Shift + Left Arrow: fast pan left
• Right Arrow: pan right
• Shift + Right Arrow: fast pan right
• Up Arrow: pan up
• Shift + Up Arrow: fast pan up
• Down Arrow: pan down
• Shift + Down Arrow: fast pan down

7.3 Zooming, Panning and Point-mapping

void zoom( float newZoom = 1.0 )

	g.zoom(); // original size
	g.zoom( 0.25 ); // 1/4 original size

void pan( float panX, float panY )

	g.pan( 0.05, 0.0 ); // move right 5% of scene x dimension
	g.pan( -0.1, -0.1 ); // move down and left

double findScale( const Bbox &newBounds ) const

	g.setWorldBounds( Bbox(0.0,0.0,10.0,10.0) );
	Bbox newWorld(0.0,0.0,5.0,5.0);
	double scale = g.findScale( newWorld );

Point mapPoint( const Bbox &bounds, const double &scale,
	const Point &p ) const

	g.setWorldBounds( Bbox(0.0,0.0,10.0,10.0) );
	Bbox newWorld(0.0,0.0,5.0,5.0);
	double scale = g.findScale( newWorld );
	Point q = g.mapPoint( newWorld, scale, Point(1.0,1.0) );

void pixelsPerMeter( float &ppmx, float &ppmy ) const

	// for a window of width 640 and height 480 with no zoom
	g.setWorldBounds( Bbox(0.0,0.0,10.0,10.0) );
	g.pixelsPerMeter( ppmx, ppmy );
	// ppmx == 64, ppmy = 48

7.4 GL Output

void initGL( int *argc, char **argv,
	const char *name = 0,
	int winWidth = 750, int winHeight = 0,
	int winPosX = 100, int winPosY = 100 )

	Graphics g;
	g.initGL( &argc, argv, "example", 640, 480 );

static void runEventLoop()

	Graphics g;
	... // set up scene
	g.initGL( &argc, argv, "example", 640, 480 );
	g.runEventLoop();

void setBackgroundColor( const Color &c )

	Graphics g;
	g.setBackgroundColor( Color("black") );

inline int getPixWidth() const
inline int getPixHeight() const

	int w = g.getPixWidth();
	int h = g.getPixHeight();

7.5 Requesting Non-GL (Instantaneous) Output

To set up Postscript output, you must first create a psFile output file. A psFile should be initialized as follows:

	psFile p( "filename.ps" );

	void foo( const psFile &file ) { ... }

	foo( psFile( "filename.ps" ) ); // illegal
	psFile out( "filename.ps" );
	foo( out ); // ok

void writePS( psFile &out,
	const Bbox &bounds = Bbox(0.5,0.5,8.0,10.5) ) const

	Graphics g;
	... // set up scene
	psFile out( "filename.ps" );
	g.writePS( out, Bbox(0.5,0.5,8.0,7.5) );

7.5.2 Screenshots

bool writePPM( const char *filename ) const

	Graphics g;
	... // set up scene
	g.writePPM( "screenshot.ppm" );

8. Geometric Representations

dolt provides a number of geometric objects with interfaces that emulate those of their counterparts in CGAL, and also provides several objects not avaliable with CGAL. As a general rule, all of the accessor functions provided by the CGAL counterparts are implemented, but none of the other functionality exists. As such, the built-in geometric objects are not well-suited to applications that need to do anything with them besides draw.

In order for the provided objects to provide exactly the same interface as CGAL, a number of CGAL typedefs exist (see geometry.h) that create 2-dimensional CGAL types. These should be used when possible if CGAL is being used because the drawable* classes in drawable.h derive from them in order to work with both CGAL and the built-in geometric objects.

8.1 CGAL Objects

• Point: similar to CGAL's Point_2
  • Point( const double &px, const double &py )
  • bool operator==( const Point &p ) const
  • bool operator!=( const Point &p ) const
  • double x() const
  • double y() const
  Additionally, the dolt (non-CGAL) Point class provides a number of operators for convenience. These operators are not supported by CGAL, which makes a distinction between Points and Vectors. These operators are:
  • Point operator+( const Point &p ) const: Point addition
  • Point operator-( const Point &p ) const: Point subtraction
  • Point operator+=( const Point &p ): Unary Point addition
  • Point operator-=( const Point &p ): Unary Point subtraction
  • Point operator-(): Point negation
  • Point rotate( double th ): Point rotation (radians)
  • Point rotate90() const: Return Point rotated 90 degrees
  • double length() const: Distance from (0,0)
  • Point normal() const: Normal of vector represented by Point
  • Point operator*( double s ) const: Scalar multiplication
  • Point operator/( double s ) const: Scalar division
  • Point operator*=( double s ): Unary scalar multiplication
  • Point operator/=( double s ): Unary scalar division
  Finally, several Point utilities are defined:
  • double dot( const Point &p, const Point &q ): Dot product
  • double cross( const Point &p, const Point &q ): Planar cross product (returns magnitude of cross product)
  • std::ostream & operator<<( std::ostream & out, const Point &p ): Output operator
  • Point unitNormal( double th ): Return unit normal in direction th (radians)
• Bbox: similar to CGAL's Bbox_2
  • Bbox( const double &xMin, const double &yMin, const double &xMax, const double &yMax )
  • double xmin() const
  • double ymin() const
  • double xmax() const
  • double ymax() const
• Segment: similar to CGAL's Segment_2
  • Segment( const Point &startPoint, const Point &endPoint )
  • Point start() const
  • Point end() const
• Polygon: similar to CGAL's Polygon_2 with std::vector<Point> as the container
  • Vertex_iterator vertices_begin()
  • Vertex_iterator vertices_end()
  • Edge_const_iterator edges_begin() const
  • Edge_const_iterator edges_end() const
• Circle: similar to CGAL's Circle_2
  • Circle( const Point ¢er, const double &squaredRad )
  • inline Point center() const
  • inline double squared_radius() const

Additionally, several objects not provided by CGAL are available (though primarily only for drawing) with dolt.

8.2 Ellipse

Ellipse( const Point &p, const double &orient,
	const double &majorRadius, const double &minorRadius )

	// ellipse centered at origin, rotated 90 degrees,
	//  with a major radius of 3 and a minor radius of
	//  1.5
	Ellipse e( Point(0.0,0.0), M_PI / 2.0, 3.0, 1.5 );

inline void setPos( const Point &p )
inline void setOrientation( const double &o )
inline void setMajorRadius( const double &r )
inline void setMinorRadius( const double &r )
inline Point getPos() const
inline double getOrientation() const
inline double getMajorRadius() const
inline double getMinorRadius() const

	Ellipse e( Point(0.0,0.0), M_PI / 2.0, 3.0, 1.5 );
	e.setOrientation( 0.0 );
	double orient = e.getOrientation(); // 0.0

8.3 lineStrip

Example:

	// create an upside-down 'v'
	lineStrip s;
	s.push_back( Point(0.0,0.0) );
	s.push_back( Point(1.0,1.0) );
	s.push_back( Point(2.0,0.0) );

8.4 Rectangle

Rectangle( const Point ¢er, const double &width,
	const double &height )

	// rectangle centered at origin with width 3 and
	//  height 1.5
	Rectangle r( 0.0, 3.0, 1.5 );

Rectangle( const Point &lowerLeft, const Point &upperRight )

	Rectangle r( Point(0.0,0.0), Point(3.0,2.0) );

inline Point getMinPoint()
inline Point getMaxPoint()

	Rectangle r( Point(0.0,0.0), Point(3.0,2.0) );
	Point p = r.getMinPoint(); // (0.0, 0.0)

8.5 Square

Square( const Point &lowerLeft, const double &sideLen )

	Square s( Point(0.0,0.0), 3.0 );

8.6 Arc

Arc( const Point ¢er, const double &squaredRad,
	const double &minAngle, const double &maxAngle )

	// an arc through 90 degrees
	Arc a( Point(0.0,0.0), 1.0, 0.0, M_PI / 2.0 );

inline double getMinAngle() const
inline double getMaxAngle() const

	Arc a( Point(0.0,0.0), 1.0, 0.0, M_PI / 2.0 );
	double x = a.getMinAngle(); // x == 0.0

9. Example Program

//
// Test program for dolt
// Creates a variety of drawableObjects and displays them,
//  and demonstrates keyboard handling and multiple scenes
//

#include 	// for screen output
#include 	// for postscript output
#include 		// for M_PI
#ifndef M_PI
  #define M_PI 3.1415926535897932384626433833
#endif

Graphics g, g2;

// keyboard handler for primary scene
void gkeyboard( unsigned char key )
{
  switch( key ) {
  case 'q':
    exit( 0 );  // quit
  case 's':
    Graphics::setCurrentScene( g2 );  // switch scenes
    break;
  case 'p':
    {
      psFile f("test.ps");  // open postscript file
      g.writePS( f );       // write postscript file
    }
    break;
  }
}

// keyboard handler for secondary scene
void g2keyboard( unsigned char key )
{
  switch( key ) {
  case 'q':
    exit( 0 );
  case 's':
    Graphics::setCurrentScene( g );
    break;
  case 'p':
    {
      psFile f("test.ps");
      g2.writePS( f );
    }
    break;
  }
}

int main( int argc, char **argv )
{
  // initialize screen output for both scenes
  g.initGL( &argc, argv, "Test", 640, 640 );
  g2.initGL( &argc, argv, "Test 2", 480, 480 );
  
  // register keyboard callbacks for both scenes
  g.setKeyboardHandler( gkeyboard );
  g2.setKeyboardHandler( g2keyboard );

  // create a drawable point object at (2,2) with a
  //  diameter of 8
  drawablePoint p(2.0,2.0,8.0);

  // create a drawable line segment from (1,1) to (9,1)
  //  with a custom dash pattern
  drawableSegment s( Point(1.0,1.0),Point(9.0,1.0), 0xfcfc );
  // make the segment red
  s.setColor( Color(1.0, 0, 0) );
  
  // create a line strip (a series of vertices)
  drawableLineStrip ls;
  ls.setColor( Color(0, 1.0, 0) ); // green
  ls.push_back( Point(3.0,3.0) );  // first point
  ls.push_back( Point(4.0,3.5) );  // second point
  ls.push_back( Point(3.0,4.0) );  // third point
  
  // create a polygon (solid border, filled, border width of 3)
  drawablePolygon o(SOLID,true,3.0f);
  o.setColor( Color(0, 0, 1.0) ); // blue filling
  o.push_back( Point(7.0,7.0) );  // first point
  o.push_back( Point(9.0,9.0) );  // second point
  o.push_back( Point(9.5,7.0) );  // third point
  o.push_back( Point(8.0,6.5) );  // fourth point

  // create an ellipse centered at (2,8), with an orientation
  //  of -1.2 radians, a major radius of 2.0 and a minor radius
  //  of 1.0
  drawableEllipse e( Point(2.0,8.0),-1.2,2.0,1.0 );
  e.setColor( Color(1.0, 1.0, 0) ); // yellow

  // create a circle centered at (8,2) with a radius of 1.5, a
  //  dashed border, filled, with a border width of 3
  drawableCircle c( Point(8.0,2.0),1.5,DASHED,true,3.0f );
  // set the circle's color to cyan, 50% transparent
  c.setColor( Color(0, 1.0, 1.0, 0.5) );

  // create a rectangle with a lower left corner at (5,5) and an
  //  upper right corner at (7,7), with a solid border, filled,
  //  and a border width of 5
  drawableRectangle r(Point(5.0,5.0),Point(7.0,7.0),SOLID,true,5.0f);
  // set the filling color to 50% gray
  r.setColor( Color("gray50") );
  // set the border color to red
  r.setBorderColor( Color("red") );

  // create a square with a lower left corner at (5.75,5.75)
  //  with a side length of 0.5, a dotted border, filled, and a
  //  border width of 3
  drawableSquare q(Point(5.75,5.75),0.5,DOTTED,true,3.0f);
  q.setColor( Color(0.0,1.0,1.0) ); // cyan

  // create an arc centered at (5,8.5), with a squared radius of
  //  1.0, arcing (counterclockwise) from PI/2 to PI
  drawableArc a(Point(5.0,8.5),1.0,M_PI / 2.0,M_PI,SOLID,3.0f);
  a.setColor( "green" );

  // create a wedge centered at (5,8.5) with a squared radius of
  //  1.0, arcing (counterclockwise) from PI to 2PI
  drawableWedge w(Point(5.0,8.5),1.0,M_PI,M_PI * 2.0,SOLID,true,2.0f);
  w.setColor( "magenta" );

  // some text
#ifdef _WIN32
  drawableText t(Point(3.0,3.0),"Some Text",24,"Palatino-Roman","Helvetica");
#else
  drawableText t(Point(3.0,3.0),"Some Text",24,"Palatino-Roman",
    "-adobe-helvetica-medium-r-normal--24-*-*-*-p-*-iso8859-1");
#endif
  t.setColor( "blue" );

  // create a new objectList so that we can add all of the
  //  objects to the first scene
  objectList olist;
  olist.push_back( &p );  // add point
  olist.push_back( &s );  // add line segment
  olist.push_back( &ls ); // add line strip
  olist.push_back( &o );  // add polygon
  olist.push_back( &e );  // add ellipse
  olist.push_back( &c );  // add circle
  olist.push_back( &r );  // add rectangle
  olist.push_back( &q );  // add square
  olist.push_back( &a );  // add arc
  olist.push_back( &w );  // add wedge
  olist.push_back( &t );  // add text
  g.addObjectList( olist );  // add the objectList to the scene

  // create a new objectList to add objects to the second scene
  objectList olist2;
  olist2.push_back( &r ); // add rectangle
  g2.addObjectList( olist2 ); // add the objectList to the scene

  // run the main event loop, drawing everything on the screen
  g.runEventLoop();
  return 0;
};

10. Errata/Todo

• Provide common font object that works independently of platform, with several commonly used built-in fonts
• Ability to snap zooming and panning to a drawableImage
• Support for concave polygons
• Win32: make debug version of library
• Cleaner way to differentiate between use of CGAL vs. built-in stuff (i.e. USE_CGAL)

11. Release History

• Version 0.95a (9/12/02)
  • Fixed bug in which default arguments to initGL did not produce proper result
• Version 0.95 (8/15/02)
  • Added drawableText and cross-platform font support
  • Added Color input operator for reading from an istream
  • Added a significant number of new default color names
  • Added getColor, getLineStyle, getLineWidth, getFilled, getBorderColor to base drawable{Line,Enclosed}Object classes
  • Added printControlKeyBindings to Graphics
  • Added Shift + <key> for control (zoom/pan) keys for faster zooming and panning
  • Added 'h' default keyboard command that just calls the Graphics::printControlKeyBindings function and prints 'q' (quit) and 'h' (help) command info
  • Implemented drawableImage, with ASCII/binary PPM loading and saving
  • Implemented Graphics::writePPM (screenshot)
  • Added Graphics::pixelsPerMeter (ratio of pixels to world units)
  • Added Graphics::getPix{Width,Height}
  • Ability for drawablePolygon to handle concave polygons (both screen and Postscript output)
  • Added drawablePolygon::addHole; drawablePolygon's can now have holes
• Version 0.94 (7/3/02)
  • Enable RTTI in MSVC++ project
  • Bugfix: drawableArc/Wedge bug in which very small pieces of the arc/wedge were not being drawn
  • Bugfix: reshape bug in which scene was drawn with (0.0,0.0) world coordinates in the lower left corner by default, even if the world bbox had negative minimum coordinates
  • Bugfix: zoom linearly, not on a logarithmic scale; also, do not allow negative zooming (scene inversion) by default
• Version 0.93 (6/19/02)
  • Addition of Point operators in non-CGAL Point implementation
  • Added dolt.h (which just includes all other dolt files for ease)
  • Makefile changes and fixes
  • Changed reshape window functionality to automatically center the scene and keep the same aspect ratio
  • Bugfix: fix zoom and pan so they work!
• Version 0.92 (6/13/02)
  • Bugfix: print %! at beginning of postscript, not %%!
  • Reduced postscript output decimal precision to 1 digit (one tenth of a point)
  • If compiled with CGAL, name library 'libdolt-cgal.a' (Linux) or 'dolt-cgal.lib' (Win32); otherwise, name it 'libdolt.a' (Linux) or 'dolt.lib' (Win32). Do this so both can be installed at once
• Version 0.91 (6/11/02)
  • Added Arc to geometry.h
  • Added drawableArc to drawable.h
  • Added drawableWedge to drawable.h
  • Misc. small bugfixes
• Version 0.9 (5/31/02)
  • Initial release

Copyright (c) 2002 Rensselaer Polytechnic Institute