lti::epsDraw< T > Class Template Reference

Object for drawing lines and points and geometric objects to an (E)PS file. More...

#include <ltiEpsDraw.h>

Inheritance diagram for lti::epsDraw< T >:

[legend]

Collaboration diagram for lti::epsDraw< T >:

[legend]

List of all members.

Public Types
enum	vAlignType { valignBottom, valignMiddle, valignTop }
enum	alignType { alignLeft, alignCenter, alignRight }
enum	imageCoding { asciiHex, ascii85, runLength, jpeg }
Public Member Functions
	epsDraw (std::ostream &os, const point &drawingArea, bool scale=true, bool eps=true)
	epsDraw (std::ostream &os, bool scale=true, bool eps=true)
	~epsDraw ()
void	setTitle (const std::string &t)
void	setFontSize (int t)
const char *	getTypeName () const
void	setLineWidth (float f)
void	setClip (const trectangle< int > &rc)
void	setSize (const point &dim)
void	setResolution (float r)
void	addComment (const std::string &msg)
point	getCanvasSize ()
void	setTransform (const tpoint< float > &offset=tpoint< float >(0.0f, 0.0f), const tpoint< float > &scale=tpoint< float >(1.0f, 1.0f))
void	setColor (const T &color)
void	setColor (const char *color)
void	setGray (const float k)
void	set (const int x, const int y)
void	set (const point &p)
void	set (const pointList &c, const point &offset=point(0, 0))
template<class U >
void	set (const hPoint2D< U > &p)
void	set (const location &loc, const bool showAngleLine=false)
void	set (const rectLocation &loc, const bool showAngleLine=false)
void	set (const std::list< location > &locs, const bool showAngleLine=false)
void	set (const vector< int > &vct, const bool &forceAxis0=true)
void	drawImage (const image &img, const imageCoding code=ascii85, const point &offset=point(0, 0))
void	drawImage (const channel &img, const imageCoding code=ascii85, const point &offset=point(0, 0), bool blackWhite=false, const float t=0.5)
void	drawImage (const channel8 &img, const imageCoding code=ascii85, const point &offset=point(0, 0), bool blackWhite=false, const int t=128)
void	polygon (const point plist[], int n, bool closed=true, bool filled=false)
void	line (const int fx, const int fy, const int tx, const int ty)
void	line (const point &p1, const point &p2)
void	lineTo (const int x, const int y)
void	lineTo (const point &p)
void	grid (const point &delta, const bool interval=true)
void	verticalLine (const int x, const int y1, const int y2)
void	verticalLine (const point &p1, const point &p2)
void	horizontalLine (const int x1, const int x2, const int y)
void	horizontalLine (const point &p1, const point &p2)
void	box (const int x1, const int y1, const int x2, const int y2, const bool &filled=false)
void	box (const trectangle< int > &r, const bool &filled=false)
void	box (const point &upperLeft, const point &bottomRight, const bool &filled=false)
void	rectangle (const int x1, const int y1, const int x2, const int y2, const bool &filled=false)
void	rectangle (const trectangle< int > &r, const bool &filled=false)
void	rectangle (const point &upperLeft, const point &bottomRight, const bool &filled=false)
void	circle (const point &p1, const int r, const bool &filled=false)
void	circle (const int x, const int y, const int r, const bool &filled=false)
void	ellipse (const point &p1, const int aX, const int aY, const bool &filled=false)
void	ellipse (const point &p1, const int aX, const int aY, const float &angle, const bool &filled=false)
void	arc (const point &p1, const point &pA, const point &pB)
void	number (const int num, const point &p1=point(0, 0))
void	number (const int num, const int x, const int y)
void	text (const std::string txt, const point &pos=point(0, 0), const alignType a=alignLeft, const vAlignType b=valignTop)
void	text (const std::string txt, const int x, const int y, const alignType a, const vAlignType b)
void	text (const std::string txt, const int x, const int y)
void	arrow (const int fx, const int fy, const int tx, const int ty, const float &size=0.2f)
void	arrow (const point &p1, const point &p2, const float &size=0.2f)
void	close ()
virtual void	setLinePattern (const linePattern &pat)
virtual void	setFillPattern (const fillPattern &pat)
Static Public Attributes
static const int	a4Width
static const int	a4Height
static const float	defaultResolution
Protected Member Functions
const std::string &	getLinePatName (const linePattern &c)
const std::string &	getFillPatName (const fillPattern &c)
const std::string &	getColorName (const rgbColor &c)
const std::string &	getColorName (const cmykColor &c)
void	drawSymbol (const int x, const int y)
void	drawSymbol (const int x, const int y, const int width, const char *pT)
Protected Attributes
std::list< std::string >	objects
std::map< rgbColor, std::string >	rgbColorNames
std::map< cmykColor, std::string >	cmykColorNames
std::map< linePattern, std::string, graphicsPattern::less >	linePatternNames
std::map< fillPattern, std::string, graphicsPattern::less >	fillPatternNames

Detailed Description

template<class T>
class lti::epsDraw< T >

Object for drawing lines and points and geometric objects to an (E)PS file.

Example:

if you want to draw some rectanglees, you can create an instance of epsDraw-object this way:

 lti::epsDraw<cmykColor> drawer(std::cout);      // dump EPS to stdout

 drawer.rectangle(10,10,200,200); // draw a large rectangle
 drawer.rectangle(50,50,100,150); // and a smaller one

The natural coordinate system uses points (pt, 1pt=1/72 inch) as basic unit. All values are specified in pt.

Member Enumeration Documentation

template<class T>

enum lti::epsDraw::alignType

This is used for setting the horizontal alignment of text.

Enumerator:

alignLeft	reference point is at the left
alignCenter	reference point is at the left
alignRight	reference point is at the left

template<class T>

enum lti::epsDraw::imageCoding

The encoding used for embedded bitmaps.

Enumerator:

asciiHex	uses ASCII Hex digits (simple, but huge)
ascii85	uses ASCII Hex digits (a little bit more efficient)
runLength	uses runlength compression
jpeg	uses JPEG compression

template<class T>

enum lti::epsDraw::vAlignType

This is used for setting the vertical alignment of text.

Enumerator:

valignBottom	reference point is the bottom line of the text
valignMiddle	reference point is the middle of the text
valignTop	reference point is the top of the text

Constructor & Destructor Documentation

template<class T>

lti::epsDraw< T >::epsDraw	(	std::ostream &	os,
		const point &	drawingArea,
		bool	scale = `true`,
		bool	eps = `true`
	)

Constructor.

It gets a drawing area, the bounding box. The stuff that is drawn is scaled to that area if scale is true. Otherwise, it is simply clipped.

template<class T>

lti::epsDraw< T >::epsDraw	(	std::ostream &	os,
		bool	scale = `true`,
		bool	eps = `true`
	)

Constructor.

It determines the size of the bounding box from the stuff that is being drawn.

template<class T>

lti::epsDraw< T >::~epsDraw ( )

destructor

Member Function Documentation

template<class T>

void lti::epsDraw< T >::addComment ( const std::string & msg )

Adds a comment to the (E)PS file.

template<class T>

void lti::epsDraw< T >::arc	(	const point &	p1,
		const point &	pA,
		const point &	pB
	)			`[virtual]`

draw an arc from 'pA' to 'pB', clockwise around center 'p1'.

Implements lti::drawBase< T >.

template<class T>

void lti::epsDraw< T >::arrow	(	const point &	p1,
		const point &	p2,
		const float &	size = `0.2f`
	)			`[inline, virtual]`

draw an arrow.

arrow tip will be at p2. If size<1.0 then tipsize will be the relative portion of arrow length. If size>1.0 then tipsize will be (int)size, independent of arrow length.

Reimplemented from lti::drawBase< T >.

References lti::epsDraw< T >::arrow(), lti::tpoint< T >::x, and lti::tpoint< T >::y.

template<class T>

void lti::epsDraw< T >::arrow	(	const int	fx,
		const int	fy,
		const int	tx,
		const int	ty,
		const float &	size = `0.2f`
	)			`[virtual]`

draw an arrow.

arrow tip will be at (tx,ty). If size<1.0 then tipsize will be the relative portion of arrow length. If size>1.0 then tipsize will be (int)size, independent of arrow length.

Implements lti::drawBase< T >.

Referenced by lti::epsDraw< T >::arrow().

template<class T>

void lti::epsDraw< T >::box	(	const point &	upperLeft,
		const point &	bottomRight,
		const bool &	filled = `false`
	)			`[inline, virtual]`

draw a box

Deprecated:: use rectangle(point&, point&, const bool&) instead!

See also:: box(int,int,int,int,const bool&)

Reimplemented from lti::drawBase< T >.

References lti::epsDraw< T >::box(), lti::drawBase< T >::filled, lti::tpoint< T >::x, and lti::tpoint< T >::y.

Referenced by lti::epsDraw< T >::box().

template<class T>

void lti::epsDraw< T >::box	(	const trectangle< int > &	r,
		const bool &	filled = `false`
	)			`[inline, virtual]`

draw a box

Deprecated:: use rectangle(rectangle&, const bool&) instead!

See also:: box(int,int,int,int,const bool&)

Reimplemented from lti::drawBase< T >.

References lti::epsDraw< T >::box(), lti::trectangle< T, S >::br, lti::drawBase< T >::filled, lti::trectangle< T, S >::ul, lti::tpoint< T >::x, and lti::tpoint< T >::y.

Referenced by lti::epsDraw< T >::box().

template<class T>

void lti::epsDraw< T >::box	(	const int	x1,
		const int	y1,
		const int	x2,
		const int	y2,
		const bool &	filled = `false`
	)			`[inline, virtual]`

draw a box

Deprecated:: use rectangle(int, int, int, int, const bool&) instead!

Reimplemented from lti::drawBase< T >.

References lti::drawBase< T >::filled, and lti::epsDraw< T >::rectangle().

template<class T>

void lti::epsDraw< T >::circle	(	const int	x,
		const int	y,
		const int	r,
		const bool &	filled = `false`
	)			`[inline]`

draw a circle with circle center '(x,y)' and radius 'r'

References lti::epsDraw< T >::circle(), and lti::drawBase< T >::filled.

template<class T>

void lti::epsDraw< T >::circle	(	const point &	p1,
		const int	r,
		const bool &	filled = `false`
	)			`[virtual]`

draw a circle with circle center 'p1' and radius 'r'

Implements lti::drawBase< T >.

Referenced by lti::epsDraw< T >::circle().

template<class T>

void lti::epsDraw< T >::close ( )

Closes this object.

At this time, all Postscript objects are written to the output stream.

template<class T>

void lti::epsDraw< T >::drawImage	(	const channel8 &	img,
		const imageCoding	code = `ascii85`,
		const point &	offset = `point(0, 0)`,
		bool	blackWhite = `false`,
		const int	t = `128`
	)

Draws an image, using grayscale pixels.

The image is drawn in the coordinate space from (offset.x,offset.y) to (offset.x+img.columns,offset.y+img.rows) If blackWhite is set to true, the resulting image will be pure black-and-white. Which pixel is black is defined by t, all values < t whill appear white, all values > t will appear black.

template<class T>

void lti::epsDraw< T >::drawImage	(	const channel &	img,
		const imageCoding	code = `ascii85`,
		const point &	offset = `point(0,0)`,
		bool	blackWhite = `false`,
		const float	t = `0.5`
	)			`[inline]`

Draws an image, using grayscale pixels.

The image is drawn in the coordinate space from (offset.x,offset.y) to (offset.x+img.columns,offset.y+img.rows) If blackWhite is set to true, the resulting image will be pure black-and-white. Which pixel is black is defined by t, all values < t whill appear white, all values > t will appear black.

References lti::channel8::castFrom(), and lti::epsDraw< T >::drawImage().

template<class T>

void lti::epsDraw< T >::drawImage	(	const image &	img,
		const imageCoding	code = `ascii85`,
		const point &	offset = `point(0, 0)`
	)

Draws an image, using RGB color pixels.

The image is drawn in the coordinate space from (offset.x,offset.y) to (offset.x+img.columns,offset.y+img.rows)

Referenced by lti::epsDraw< T >::drawImage().

template<class T>

void lti::epsDraw< T >::drawSymbol	(	const int	x,
		const int	y,
		const int	w,
		const char *	style
	)			`[protected, virtual]`

Abstract drawing methods for markers.

This methods are needed by the marker methods

Implements lti::drawBase< T >.

template<class T>

void lti::epsDraw< T >::drawSymbol	(	const int	x,
		const int	y
	)			`[protected]`

draws the actual symbol at the actual position actX,actY

template<class T>

void lti::epsDraw< T >::ellipse	(	const point &	p1,
		const int	aX,
		const int	aY,
		const float &	angle,
		const bool &	filled = `false`
	)			`[virtual]`

draw an ellipse with center 'p1' and main axes 'aX' and 'aY'

See also:: ellipse()

Parameters:

	p1	center of the ellipse
	aX	length of the main axis
	aY	length of the secondary axis
	angle	between the main axis and the horizontal axis
	filled	indicates if the ellipse should be draw filled or not

Implements lti::drawBase< T >.

template<class T>

void lti::epsDraw< T >::ellipse	(	const point &	p1,
		const int	aX,
		const int	aY,
		const bool &	filled = `false`
	)			`[virtual]`

draw an ellipse with center 'p1' and main axes 'aX' and 'aY'

Implements lti::drawBase< T >.

template<class T>

point lti::epsDraw< T >::getCanvasSize ( ) [virtual]

returns the size of the drawing area

Implements lti::drawBase< T >.

template<class T>

const std::string& lti::epsDraw< T >::getColorName ( const cmykColor & c ) [protected]

Returns the name of the color c.

This name can be used as PostScript command to switch to the given color. The method will ensure that the PS header contains the required command definition.

template<class T>

const std::string& lti::epsDraw< T >::getColorName ( const rgbColor & c ) [protected]

Returns the name of the color c.

This name can be used as PostScript command to switch to the given color. The method will ensure that the PS header contains the required command definition.

template<class T>

const std::string& lti::epsDraw< T >::getFillPatName ( const fillPattern & c ) [protected]

Returns the name of the given fill pattern.

This name can be used as PostScript command to switch to the given pattern. The method will ensure that the PS header contains the required command definition.

template<class T>

const std::string& lti::epsDraw< T >::getLinePatName ( const linePattern & c ) [protected]

Returns the name of the given line pattern.

This name can be used as PostScript command to switch to the given pattern. The method will ensure that the PS header contains the required command definition.

template<class T>

const char* lti::epsDraw< T >::getTypeName ( ) const [virtual]

get name of this type.

Reimplemented from lti::drawBase< T >.

template<class T>

void lti::epsDraw< T >::grid	(	const point &	delta,
		const bool	interval = `true`
	)			`[virtual]`

Draws a grid in the image.

The interpretation of delta depends on the value of interval. if interval is true, the values are taken as number of pixels between two grid lines in x and y direction. Otherwise, it is used as number of grid lines. For drawing, the alternate color is used.

Implements lti::drawBase< T >.

template<class T>

void lti::epsDraw< T >::horizontalLine	(	const point &	p1,
		const point &	p2
	)			`[inline, virtual]`

Draws a horizontal line from (p1.x,p1.y) to (p2.x,p1.y).

Reimplemented from lti::drawBase< T >.

References lti::epsDraw< T >::horizontalLine(), lti::tpoint< T >::x, and lti::tpoint< T >::y.

template<class T>

void lti::epsDraw< T >::horizontalLine	(	const int	x1,
		const int	x2,
		const int	y
	)			`[virtual]`

Draws a horizontal line from (x1,y) to (x2,y).

Implements lti::drawBase< T >.

Referenced by lti::epsDraw< T >::horizontalLine().

template<class T>

void lti::epsDraw< T >::line	(	const point &	p1,
		const point &	p2
	)			`[inline, virtual]`

Draw a line from the point p to point p2.

The "last point" will be defined with the last "set", "line" or "lineTo" method.

Reimplemented from lti::drawBase< T >.

References lti::epsDraw< T >::line(), lti::tpoint< T >::x, and lti::tpoint< T >::y.

template<class T>

void lti::epsDraw< T >::line	(	const int	fx,
		const int	fy,
		const int	tx,
		const int	ty
	)			`[virtual]`

Draw a line from the point (fx,fy) to point (tx,ty).

The "last point" will be defined with the last "set", "line" or "lineTo" method.

Implements lti::drawBase< T >.

Referenced by lti::epsDraw< T >::line().

template<class T>

void lti::epsDraw< T >::lineTo ( const point & p ) [inline, virtual]

Draw a line from the last point to point p.

The "last point" will be defined with the last "set", "line" or "lineTo" method.

Reimplemented from lti::drawBase< T >.

References lti::epsDraw< T >::lineTo(), lti::tpoint< T >::x, and lti::tpoint< T >::y.

Referenced by lti::epsDraw< T >::lineTo().

template<class T>

void lti::epsDraw< T >::lineTo	(	const int	x,
		const int	y
	)			`[virtual]`

Draw a line from the last point to (x,y).

The "last point" will be defined with the last "set", "line" or "lineTo" method.

Implements lti::drawBase< T >.

template<class T>

void lti::epsDraw< T >::number	(	const int	num,
		const int	x,
		const int	y
	)			`[virtual]`

draw an integer num at position 'x'/'y'.

See also:: text()

Implements lti::drawBase< T >.

template<class T>

void lti::epsDraw< T >::number	(	const int	num,
		const point &	p1 = `point(0, 0)`
	)			`[virtual]`

draw an integer num at position 'p1'.

The alignment is left/bottom.

See also:: text()

Parameters:

	num	the number to be written
	p1	the position where the number will be drawn

Reimplemented from lti::drawBase< T >.

template<class T>

void lti::epsDraw< T >::polygon	(	const point	plist[],
		int	n,
		bool	closed = `true`,
		bool	filled = `false`
	)

Draws a polygon.

template<class T>

void lti::epsDraw< T >::rectangle	(	const point &	upperLeft,
		const point &	bottomRight,
		const bool &	filled = `false`
	)			`[inline, virtual]`

draw a rectangle

Parameters:

	upperLeft	upper left corner of the rectangle
	bottomRight	bottom right corner of the rectangle
	filled	if true rectangle is filled

Reimplemented from lti::drawBase< T >.

References lti::drawBase< T >::filled, lti::epsDraw< T >::rectangle(), lti::tpoint< T >::x, and lti::tpoint< T >::y.

Referenced by lti::epsDraw< T >::rectangle().

template<class T>

void lti::epsDraw< T >::rectangle	(	const trectangle< int > &	r,
		const bool &	filled = `false`
	)			`[inline, virtual]`

draw a rectangle.

the rectangle must contain the upper left and the bottom right point

Parameters:

	r	rectangle to be drawn
	filled	if true rectangle is filled

Reimplemented from lti::drawBase< T >.

References lti::trectangle< T, S >::br, lti::drawBase< T >::filled, lti::epsDraw< T >::rectangle(), lti::trectangle< T, S >::ul, lti::tpoint< T >::x, and lti::tpoint< T >::y.

Referenced by lti::epsDraw< T >::rectangle().

template<class T>

void lti::epsDraw< T >::rectangle	(	const int	x1,
		const int	y1,
		const int	x2,
		const int	y2,
		const bool &	filled = `false`
	)			`[virtual]`

draw a rectangle

Parameters:

	x1	left x-coordinate.
	y1	upper y-coordinate.
	x2	right x-coordinate.
	y2	bottom y-coordinate.
	filled	if true box is filled

Implements lti::drawBase< T >.

Referenced by lti::epsDraw< T >::box().

template<class T>

void lti::epsDraw< T >::set	(	const vector< int > &	vct,
		const bool &	forceAxis0 = `true`
	)

Draw the contents of the vector using the whole image.

Parameters:

	vct	the vector to be shown
	forceAxis0	if true, both axis will be shown, i.e. the value 0 for the vector will be always shown. If false, only the required value-range will be shown

template<class T>

void lti::epsDraw< T >::set	(	const std::list< location > &	locs,
		const bool	showAngleLine = `false`
	)			`[inline, virtual]`

Draws a list of locations.

Reimplemented from lti::drawBase< T >.

References lti::epsDraw< T >::set().

template<class T>

void lti::epsDraw< T >::set	(	const rectLocation &	loc,
		const bool	showAngleLine = `false`
	)			`[inline, virtual]`

Draws a rectLocation.

Parameters:

	loc	location with position, angle and radius
	showAngleLine	if true, a line from the middle point of the location (given by loc.position) with the angle given by loc.angle will be drawn.

Reimplemented from lti::drawBase< T >.

References lti::epsDraw< T >::set().

template<class T>

void lti::epsDraw< T >::set	(	const location &	loc,
		const bool	showAngleLine = `false`
	)			`[inline, virtual]`

Draw a location.

Parameters:

	loc	location with position, angle and radius
	showAngleLine	if true, a line from the middle point of the location (given by loc.position) with the angle given by loc.angle will be drawn.

Reimplemented from lti::drawBase< T >.

References lti::epsDraw< T >::set().

template<class T>

template<class U >

void lti::epsDraw< T >::set ( const hPoint2D< U > & p ) [inline]

Set pixel at p.

If no style is given, the color and symbol type set by the respective methods are used, else the style given as an argument is used.

Parameters:

p

coordinates of the pixel to be set

Reimplemented from lti::drawBase< T >.

template<class T>

void lti::epsDraw< T >::set	(	const pointList &	c,
		const point &	offset = `point(0,0)`
	)			`[inline, virtual]`

Set pixels at all positions in c.

Reimplemented from lti::drawBase< T >.

References lti::epsDraw< T >::set().

template<class T>

void lti::epsDraw< T >::set ( const point & p ) [inline, virtual]

Set pixel at p.

Reimplemented from lti::drawBase< T >.

template<class T>

void lti::epsDraw< T >::set	(	const int	x,
		const int	y
	)			`[virtual]`

Set pixel at x,y.

Parameters:

	x	x-coordinate of the point
	y	y-coordinate of the point

Implements lti::drawBase< T >.

Referenced by lti::epsDraw< T >::set().

template<class T>

void lti::epsDraw< T >::setClip ( const trectangle< int > & rc )

Specifies the clipping rectangle and enables clipping.

If not called, there is no clipping.

template<class T>

void lti::epsDraw< T >::setColor ( const char * color ) [virtual]

Specifies color to be used.

Implements lti::drawBase< T >.

template<class T>

void lti::epsDraw< T >::setColor ( const T & color ) [virtual]

Specifies color to be used.

Implements lti::drawBase< T >.

template<class T>

virtual void lti::epsDraw< T >::setFillPattern ( const fillPattern & pat ) [virtual]

Sets the pattern for filling areas.

All subsequenly filled areas will be filled with the given pattern. The default pattern is a homogenouos fill.

Parameters:

pat

pattern for filling areas.

Reimplemented from lti::drawBase< T >.

template<class T>

void lti::epsDraw< T >::setFontSize ( int t ) [inline]

Set the font size that is used for text.

At present, only a single font size is allowed in each EPS document.

template<class T>

void lti::epsDraw< T >::setGray ( const float k ) [virtual]

Specifies grayscale level to be used (range from 0 to 1) for the next graphics objects.

If you want to specify a gray value, you should always use this method instead of setColor with grey RGB values. The reason for this is a PostScript convention: Most color printers mix colors by subtractive colors. If you specify RGB, you will get black mixed out of the colors of the printer. If you specify the grey value by setGray, you will get simple black ink. (An alternative is to use setColor with cmyk values, setting cmy to zero and k to the gray level.

Implements lti::drawBase< T >.

template<class T>

virtual void lti::epsDraw< T >::setLinePattern ( const linePattern & pat ) [virtual]

Sets the pattern for drawing lines.

All subsequent lines will be drawn in the given pattern. The default is the continuous line.

Parameters:

pat

pattern for drawing lines.

Reimplemented from lti::drawBase< T >.

template<class T>

void lti::epsDraw< T >::setLineWidth ( float f )

Specifies the line width.

Default is 0, which is the thinnest line an output device can generate.

template<class T>

void lti::epsDraw< T >::setResolution ( float r )

Specifies the resolution of the figure.

By default, each pixel is considered an PostScript point (1/72 inch). By setting the, resolution, you can enlarge or shrink the entire EPS figure. This value can be set independently from the remaining parameters, most notably the transform, because it only involves the PostScript coordinate to device coordinate conversion, not the image coordinate to PostScript coordinate conversion.

template<class T>

void lti::epsDraw< T >::setSize ( const point & dim )

Specifies the size of the drawing area in pt.

The complete figure is scaled and moved such that it fits tightly into a box of this size.

template<class T>

void lti::epsDraw< T >::setTitle ( const std::string & t ) [inline]

Set the title of this drawing.

template<class T>

void lti::epsDraw< T >::setTransform	(	const tpoint< float > &	offset = `tpoint< float >(0.0f, 0.0f)`,
		const tpoint< float > &	scale = `tpoint< float >(1.0f, 1.0f)`
	)

Sets the transform for the coordinates.

With this, you override the default transform.

template<class T>

void lti::epsDraw< T >::text	(	const std::string	txt,
		const int	x,
		const int	y
	)			`[inline, virtual]`

Draw the given text at the position upperleft.

Parameters:

	txt	the output text
	x	the x coordinate in the image where the text will be written
	y	the y coordinate in the image where the text will be written

Implements lti::drawBase< T >.

References lti::epsDraw< T >::alignLeft, lti::epsDraw< T >::text(), and lti::epsDraw< T >::valignTop.

template<class T>

void lti::epsDraw< T >::text	(	const std::string	txt,
		const int	x,
		const int	y,
		const alignType	a,
		const vAlignType	b
	)

Draw the given text at the position upperleft.

Parameters:

	txt	the output text
	x	the x coordinate in the image where the text will be written
	y	the y coordinate in the image where the text will be written
	a	the alignType of the horizonal alignment.
	b	the vAlignType of the vertical alignment.

template<class T>

void lti::epsDraw< T >::text	(	const std::string	txt,
		const point &	pos = `point(0,0)`,
		const alignType	a = `alignLeft`,
		const vAlignType	b = `valignTop`
	)			`[inline]`

Draw the given text at the position upperleft.

Parameters:

	txt	the output text
	pos	the position where the text will be written
	a	the alignType of the horizonal alignment.
	b	the vAlignType of the vertical alignment.

Referenced by lti::epsDraw< T >::text().

template<class T>

void lti::epsDraw< T >::verticalLine	(	const point &	p1,
		const point &	p2
	)			`[inline, virtual]`

Draws a vertical line from (p1.x,p1.y) to (p1.x,p2.y).

Reimplemented from lti::drawBase< T >.

References lti::epsDraw< T >::verticalLine(), lti::tpoint< T >::x, and lti::tpoint< T >::y.

template<class T>

void lti::epsDraw< T >::verticalLine	(	const int	x,
		const int	y1,
		const int	y2
	)			`[virtual]`

Draws a vertical line from (x,y1) to (x,y2).

Implements lti::drawBase< T >.

Referenced by lti::epsDraw< T >::verticalLine().

Member Data Documentation

template<class T>

const int lti::epsDraw< T >::a4Height [static]

The height of an ISO A4 sheet in points (1pt = 1/72in).

template<class T>

const int lti::epsDraw< T >::a4Width [static]

The width of an ISO A4 sheet in points (1pt = 1/72in).

template<class T>

std::map<cmykColor,std::string> lti::epsDraw< T >::cmykColorNames [protected]

this is a map from colors to the corresponding postscript command.

template<class T>

const float lti::epsDraw< T >::defaultResolution [static]

The default resolution of the PostScript interpreter.

template<class T>

std::map<fillPattern, std::string, graphicsPattern::less> lti::epsDraw< T >::fillPatternNames [protected]

A map for storing fill pattern definitions.

template<class T>

std::map<linePattern, std::string, graphicsPattern::less> lti::epsDraw< T >::linePatternNames [protected]

A map for storing line pattern definitions.

template<class T>

std::list<std::string> lti::epsDraw< T >::objects [protected]

this is a list of strings that contain the postscript command sequence for a graphical object

template<class T>

std::map<rgbColor,std::string> lti::epsDraw< T >::rgbColorNames [protected]

this is a map from colors to the corresponding postscript command.

The documentation for this class was generated from the following file:

ltiEpsDraw.h

lti::epsDraw< T > Class Template Reference

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

template<class T> class lti::epsDraw< T >

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class T>
class lti::epsDraw< T >