PSDriver.h

Go to the documentation of this file.

//# PSDriver.h: Defines PSDriver, a low-level PostScript interface for the DL.
//# Copyright (C) 1999,2000,2001,2002,2003
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//#        Internet email: aips2-request@nrao.edu.
//#        Postal address: AIPS++ Project Office
//#                        National Radio Astronomy Observatory
//#                        520 Edgemont Road
//#                        Charlottesville, VA 22903-2475 USA
//#
//# $Id$

#ifndef TRIALDISPLAY_PSDRIVER_H
#define TRIALDISPLAY_PSDRIVER_H

#include <casa/aips.h>
#include <display/Display/DisplayEnums.h>
#include <casa/BasicSL/String.h>

//# Forward declarations
#include <casa/iosfwd.h>

namespace casa { //# NAMESPACE CASA - BEGIN

// <summary>
// Low level interface between PSPixelCanvas{ColorTable} and PostScript.
// </summary>

// <use visibility=local>

//<a name="Synopsis"></a>
// <synopsis>
// PSDriver takes graphics requests from
// <linkto class="PSPixelCanvas"> PSPixelCanvas </linkto> and
// <linkto class="PSPixelCanvasColorTable"> PSPixelCanvasColorTable </linkto>
// and generates PostScript code. It might be thought of as playing an
// analogous role to what Xlib does for the X11PixelCanvas{ColorTable}.
// It could be used separately, but mostly programers will just
// create a PSDriver object to pass to PSPixelCanvas{ColorTable}.
//
// While there are many constructors, PSDrivers will probably most frequently
// be created using something like:
//
// <srcblock>
//      PSdriver *ps = new PSDriver("filename", PSDriver::LETTER,
//                                  PSDriver::PORTRAIT);
// </srcblock>
//
// If it were desired to use RGB colormode rather than INDEXED,
// the following could be added.
//
//<srcblock>
//      ps->setColorSpace(PSDriver::RGB);
//</srcblock>
//
// PSDriver is logically split into two sections. The 'upper' level
// contains public functions, such as drawLine(). These do various
// amounts of bookkeeping, such as bounding box calculations, then call
// the 'lower' level routines, typically with names starting with emit.
// (eg. emitLine() in this example).
//
// There are many public routines that will rarely be called from outside
// of PSDriver. Typical of these are the various xxxToAscii85 routines
// that are used internally to generate image data.

// </synopsis>
//
// <thrown>
// PSDriver does not currently explicitly throw any exceptions.
// </thrown>
//
//<a name="ToDo"></a>
// <todo>
// <ol>
// <li> EPS support is preliminary.
// <li> Vertical text justification doesn't look correct, presumably because
//      the character's bounding box includes interline space.
// <li> No display list support.
// <li> Clipping support is disabled since it is currently possible to
//      only reduce the size of the clipping path, not replace it.
// <li> Points are drawn as filled circles of fixed size.
// </ol>
// </todo>
//
// Notes:
// <ol>
// <li> It is possible to switch between Index, RGB and HSV modes at will.
// <li> The length of the color table is 4096 entries.
// <li> PostScript doesn't deal with pixels.
// <li> The transform matrix affects virtually everything.
// <li> Font names must be known by the PostScript interpreter.
// </ol>

        class PSDriver {
        public:
                // The various color spaces PSDriver knows about.
                enum ColorSpace { UNKNOWNSPACE=-1, INDEXED, GRAY, RGB, HSV, HSB=HSV};
                // Different line types that can be drawn.
                enum LineStyle { UNKNOWNSTYPE=-1, SOLID, DASHED, DASHDASH};
                // Constants describing the the length of the indexed color table and the number of bits per color component.
                enum {NUMCOLORS = 4096, BITSPERCOMPONENT=12};
                enum Dimension { POINTS, INCHES, MM};
                enum Layout {   PORTRAIT=1, LANDSCAPE=2, EPS=0x4, EPS_PORTRAIT=0x5,
                                EPS_LANDSCAPE=0x6
                            };

//<srcblock>
                //              Options for drawImage.
                // SMOOTH        Pixels are interpolated. Not supported by all
                //              interpreters. Old versions of ghostscript may core
                //              dump if this is selected.
//</srcblock>
                enum ImageOptions { NOIMGOPTS=0, SMOOTH=0x1};

                enum MediaSize {
                    // USERPAGE is used internally. It is not a valid media type.
                    USERPAGE=-1,
                    // The following lists the known media types (paper sizes).
                    LETTER=0, NA_LETTER=LETTER, LEGAL, NA_LEGAL=LEGAL,
                    NA_10X13_ENVELOPE, NA_9X12_ENVELOPE,
                    NA_NUMBER_10_ENVELOPE, NA_7X9_ENVELOPE, NA_9X11_ENVELOPE,
                    NA_10X14_ENVELOPE, NA_6X9_ENVELOPE, NA_10X15_ENVELOPE,
                    A, B, C, D, E,
                    ISO_A0, ISO_A1, ISO_A2, ISO_A3, ISO_A4, A4=ISO_A4, ISO_A5, ISO_A6,
                    ISO_A7, ISO_A8, ISO_A9, ISO_A10, ISO_B0, ISO_B1, ISO_B2, ISO_B3,
                    ISO_B4, ISO_B5, ISO_B6, ISO_B7, ISO_B8, ISO_B9, ISO_B10, ISO_C0,
                    ISO_C1, ISO_C2, ISO_C3, ISO_C4, ISO_C5, ISO_C6, ISO_C7, ISO_C8,
                    ISO_DESIGNATED,
                    JIS_B0, JIS_B1, JIS_B2, JIS_B3, JIS_B4, JIS_B5, JIS_B6, JIS_B7,
                    JIS_B8, JIS_B9, JIS_B10
                };
//
                enum TextAlign {
                    AlignCenter = Display::AlignCenter,
                    AlignLeft = Display::AlignLeft,
                    AlignTop = Display::AlignTop,
                    AlignRight = Display::AlignRight,
                    AlignBottom = Display::AlignBottom,
                    AlignTopLeft = Display::AlignTopLeft,
                    AlignTopRight = Display::AlignTopRight,
                    AlignBottomLeft = Display::AlignBottomLeft,
                    AlignBottomRight = Display::AlignBottomRight
                };

//      PSInfo is used to supply comment fields for the PostScript header
//      and other information that needs to be available when the PSDriver
//      object is created. Its use is optional.
                class PSInfo {
                public:
                        PSInfo();
                        ~PSInfo();
                        void Creator(const char *);
                        void Creator(const String &);
                        const String &Creator()const {
                                return creator_;
                        }
                        void For(const char *);
                        void For(const String &);
                        const String &For()const {
                                return for_;
                        }
                        void Title(const char *);
                        void Title(const String &);
                        const String &Title()const {
                                return title_;
                        }
                        void Comment(const String &);
                        void Comment(const char *);
                        const String &Comment()const {
                                return comment_;
                        }

                        void setMargins(const float lm, const float rm,
                                        const float tm, const float bm,
                                        const Dimension dim= PSDriver::INCHES);
                        // If setMargins has been called, returns True and the
                        // margin values. Otherwise, returns False and does not
                        // change the arguments.
                        Bool getMargins(float &lm, float &rm,
                                        float &tm, float &bm);
                private:
                        String  for_;
                        String  title_;
                        String  creator_;
                        String  comment_;
                        float   lm_, rm_, tm_, bm_;     // Margins.
                        Bool    haveMargins_;           // setMargins has been called.
                };
                // Generic PostScript

        public:
// Arguments to the various constructors:
// <ul>
// <li> out             is an ostream that the PostScript code is written to.
// <li> fname           it the name of the output file to be written to.
// <li> MediaSize       is the paper size. Each paper size has default margins.
// <li> Dimension       is POINTS, INCHES or MM. Describes values of x0,y0,x1,y1.
// <li> x0,y0,x1,y1     are used instead of MediaSize to explicitly give
//                      the lower left and upper right corners of the
//                      drawing surface.
// <li> Layout          is PORTRAIT or LANDSCAPE.
// <li> PSInfo          supplies optional header comments or margins.
//                      Optional argument.
// </ul>
//
                // INDEXED, PORTRAIT to a default file.
                PSDriver();
                PSDriver(ostream &out);
                PSDriver(const char *filename);
                PSDriver(ostream &out, const MediaSize, const Layout=PORTRAIT,
                         PSInfo *info=NULL);
                PSDriver(const String &fname, const MediaSize, const Layout=PORTRAIT,
                         PSInfo *info=NULL);
                PSDriver(const char *fname, const MediaSize, const Layout=PORTRAIT,
                         PSInfo *info=NULL);

                PSDriver(ostream &out, const Dimension dim,
                         const float x0, const float y0,
                         const float x1, const float y1,
                         const Layout=PORTRAIT, PSInfo *info=NULL);
                PSDriver(const String &outname, const Dimension dim,
                         const float x0, const float y0,
                         const float x1, const float y1,
                         const Layout=PORTRAIT, PSInfo *info=NULL);
                PSDriver(const String &outname, const MediaSize,
                         const Dimension dim,
                         const float x0, const float y0,
                         const float x1, const float y1,
                         const Layout=PORTRAIT, PSInfo *info=NULL);
                PSDriver(const char *outname, const Dimension dim,
                         const float x0, const float y0,
                         const float x1, const float y1,
                         const Layout=PORTRAIT, PSInfo *info=NULL);
                ~PSDriver();

//#     ////////////////////////////////////////////////////////////////
//
                // Set/get desired color space. (Default is INDEXED).
//<group>
                void setColorSpace(const ColorSpace);
                inline ColorSpace colorSpace()const {
                        return colorSpace_;
                }
//</group>
                // Set current color used for text and vectors. Only the first
                // argument is used for indexed & gray.
                // For Indexed mode, color should be in the range (0..ncolors-1)
                // where ncolors is the number of colors in the table. color
                // is truncated to an integer.
                // For the others, color should be in the range (0..1).
                void setColor(const float rh, const float gs, const float bv);
                // Set color value for indexed and gray scale modes.
                // If called when not in indexed or gray modes, the same value
                // is used for all three components.
                void setColor(const float color);
                // Color to be used for dashes.
                void setBackgroundColor(const float rh, const float gs,
                                        const float bv, const ColorSpace=RGB);
                // Set color value for indexed and gray scale modes.
                void setBackgroundColor(const float color, const ColorSpace=INDEXED);

                // Change color space then set color.
                void setIndexColor(const float indx);
                void setRGBColor(const float r, const float g, const float b);
                void setHSVColor(const float h, const float s, const float v) {
                        setHSBColor(h, s, v);
                }
                void setHSBColor(const float h, const float s, const float b);

                // Load color tables with contents of a, b & c. Typically, a holds
                // red, b holds green & c holds blue. Values should be in the
                // range (0..1).
                // May be called anytime, but values are only used in INDEXED mode.
                // Start is starting index in the color table. Len is the
                // number of entries to set.
                void storeColors(const int start, const int len,
                                 const float *r, const float *g, const float *b);
                // Scatter load the colortable. Much more effecient if indexes are
                // consecutive.
                void storeColorValues(const int len, const int *indexes,
                                      const float *a, const float *b, const float *c);
                // Store 1 color.
                void storeColor(const int index,
                                const float r, const float g, const float b);
                // Load linear ramps (0..1.0) into the first ncolors entries.
                void setLinearRamps(const int ncolors);
//#     ////////////////////////////////////////////////////////////////
//#     //              Coordinate commands.
                // Current transform matrix is changed by the given values, not
                // replaced.
// <group>
                // Change origin to x/y.
                void translate(const float x, const float y);
                // Change scale by x/y.
                void scale(const float x, const float y);
                // Rotate by # degrees.
                void rotate(const float degrees);
// </group>

                // Set the length of dashes.
                void setDashLength(const float length);
        public:
//#     ////////////////////////////////////////////////////////////////
//<srcblock>
                //                      Draw an Image
                // x0,y0        Image is drawn with lower left corner at x0, y0.
                //              (In current user coordinates).
                // width,height Size of source image in elements.
                // xsize,ysize  Size of output image. (Eg. If current user
                //              coordinates were in inches, a size of 2 would create
                //              a two inch output square regardless of the size of the
                //              input image).
                // data         Data for an image that is width pixels wide by
                //              height pixels high. The actual length of the array
                //              depends on the ColorSpace argument:
                //              INDEXED:        The array contains width*height
                //                              indexes in the range 0.. 2^bpc -1.
                //                              (0..255 or 0..4095).
                //              RGB or HSV:     The array contains width*height
                //                              RGB (HSV) triples in the range
                //                              0..255 for bpc=8 or 0..1023 otherwise.
                //                              The length of the array is
                //                              width*height*3.
                // bpc          Used to determing how data is encoded.
                //              If (0 < bpc <= 8) 8 bit encoding is used.
                //              If bpc > 8, 12 bit encoding is used.
                //              If bpc <= 0, the array is scanned to determine the
                //              encoding method.
                // ColorSpace   Whether image is INDEXED, RGB or HSV.
                // imageopts    Bitwise OR of IMAGEOPTS.
                //               Currently only whether to smooth image.
//</srcblock>

                void drawImage( const float x0, const float y0,
                                const int width, const int height,
                                const float xsize, const float ysize,
                                const uShort *data,
                                const int bpc=0, const ColorSpace=INDEXED,
                                const int imageopts=0);

                // Save/restore graphics state.
//<group>
                void gsave();
                void grestore();
//</group>
//
//<srcblock>
                //                       Graphics
//</srcblock>
//

                void setLineStyle(const LineStyle);
                // w = 1.0 means 0.005".
                void lineWidth(const float w);

                void moveTo(const float x, const float y);
                void lineTo(const float x, const float y, const int stroke=1);

                void drawPolygon(const int len, const float *x, const float *y,
                                 const int fill=0);
                void drawPolyline(const int len, const float *x, const float *y,
                                  const int close=0, const int fill=0);
                void drawLine(  const float x0, const float y0,
                                const float x1, const float y1);
                void drawLines(const int len,   const float *x1, const float *y1,
                               const float *x2, const float *y2);
                void drawRectangle(const float x0, const float y0,
                                   const float x1, const float y1, const int fill=0);
                void drawFilledRectangle(const float x0, const float y0,
                                         const float x1, const float y1);
                void drawPoint( const float x, const float y, const float radius=1.0);
                void drawPoints(const int len, const float *x, const float *y,
                                const float radius=1.0);
                void drawColoredPoints( const int len, const float *x, const float *y,
                                        const float *colors, const float radius=1.0);


//#     ////////////////////////////////////////////////////////////////
//
//<srcblock>
                //                              Text
//</srcblock>
//#

//   Display a line of text. Tabs, newlines, etc. are not handled.
                void drawText(const float x, const float y, const char *str,
                              const TextAlign algn=AlignBottomLeft,
                              const float angle = 0);
//<note role=caution> PSDriver just passes the name to the output file.
//      It can't know whether the font really exists on the output device.
//</note>
                // Set font using current font scaling.
                void setFont(const char *fn);
                // Use font with supplied scaling.
                void findFont(const char *fn, const float scale);

                // Set/Get font scaling used with setFont.
                void setDefaultFontScale(const float scl);
                float getDefaultFontScale()const {
                        return defaultFontSize_;
                }
//
//#     ////////////////////////////////////////////////////////////////
//<srcblock>
                //                              Misc.
//</srcblock>
//
                // Return page size (drawable area - margins).
                // If userCoords is True, values are in current user coordinates.
                // Otherwise, they are in transformed coordinates ( points).
                void pageSize(float &width, float &height,
                              const Bool userCoords=True);

                // Return bounding box.
                // Return is True if a bounding box was declared initially. Otherwise,
                // False and the current value of the bounding box will be returned.
                // If userCoords is True, values are in current user coordinates.
                // Otherwise, transformed coords.
                Bool getBoundingBox( float &x0, float &y0, float &x1, float &y1,
                                     const Bool userCoords=True)const;

                // Returns True if bounding box size was given to the constructor.
                inline Bool haveBoundingBox()const {
                        return haveBoundingBox_;
                }

                // Put a comment in the output file.
                // The comment may include newlines.
//<group>
                void comment(const char *);
                void comment(const String &);
//</group>
                // Push/pop transform matrix.
//<group>
                void pushMatrix();
                void popMatrix();
//</group>
                void newPage();
                // Flush the output.
                void flush();
                // Done. Called by the destructor.
                void finish();
                // Set clipping rectangle.
                // Subsequent calls can only make the clipping rectangle smaller.
                void clipRect(  const float x0, const float y0,
                                const float width, const float height);
        public:
//
//<srcblock>
//              The following, while public, will almost will almost
// never be called from outside of PSDriver.
//</srcblock>

                // Routines to encode non negative binary numbers in ASCII85 format.
                // There will be upto 5/4 as many output characters as input bytes.
                // Returns the number of bytes written to out.

                static int bytesToAscii85(const char *in, const int inlength,
                                          char *out);
                static int uShorts8ToAscii85(const uShort *in,
                                             const int inlength, char *out);


                // Converts in to ASCII85 bytes using only lower 12 bits of each
                // integer. Out must be at least 1.75*inlength rounded up to
                // a multiple of 5 bytes long.
                // ( <1.5bytes/entry>*<inlength entries>*<1.25 expansion>).
                // If inlength is odd, a 0 valued entry will be implicitly added.
                static int uShorts12ToAscii85(const uShort *in,
                                              const int width,
                                              const int height, char *out);

                // Encode data as ASCII85 chars. Function return is an array of
                // chars. (use delete [] to free). outlen is set to the number of
                // bytes in the array.
                // On input, if bpc is 8, data is treated as containing 1 byte per
                // element. If bpc is 12, data is assumed to contain 12 bits/element.
                // If bpc is 0, the array is scanned.
                // On return, bpc is set the the value actually used.
                static char *encodeUShorts(const int width, const int height,
                                           int &bpc, const uShort *data,
                                           int &outlen);

//#     ////////////////////////////////////////////////////////////////
                // Miscellaneous functions to convert between typical scalings.
                static inline float pointsToInches(const float in) {
                        return in/72.0;
                }
                static inline float pointsToMM(const float in) {
                        return in*(25.4/72.0);
                }
                static inline float inchesToPoints(const float in) {
                        return in*72.0;
                }
                static inline float mmToPoints(const float in) {
                        return in*(72./25.4);
                }

                static float toPoints(const float in, const Dimension indem);
                static float fromPoints(const float in, const Dimension indem);
//#     ////////////////////////////////////////////////////////////////

                // Do forward or reverse transformation on a point.
                // If absolute is False, the translations aren't done.
                void toPoints(const float xin, const float yin,
                              float &xout, float &yout,
                              const Bool absolute=True)const {
                        state_.toPoints(xin, yin, xout, yout, absolute);
                }

                void fromPoints(const float xin, const float yin,
                                float &xout, float &yout,
                                const Bool absolute=True)const {
                        state_.fromPoints(xin, yin, xout, yout, absolute);
                }


                // Return a string representation of a dimension.
                static const char *dimensionToString(const PSDriver::Dimension dim);
                const char *dimensionToString()const {
                        return dimensionToString(dimension_);
                }
                Dimension dimension()const {
                        return dimension_;
                }

                // Is the output EPS? Portrait?
//<group>
                Bool isEPS()const {
                        return eps_;
                }
                Bool isPortrait()const {
                        return portrait_;
                }
//</group>

                // The PageInfo struct is used internally to supply descriptions
                // of the various page types.
                typedef struct PageInfo {
                        PSDriver::MediaSize     media;          // A4, LETTER, etc.
                        float                   width;
                        float                   height;
                        float                   lrmargin;
                        float                   tbmargin;
                        PSDriver::Dimension     dimension;      // MM or INCHES.
                        const char                      *name; //"North American letter", etc.
                        const char                      *alias1;        // "NA_LETTER", etc.
                        const char                      *alias2;        // "LETTER", etc.
                } pageinfo_;
                // Given a paper type, return a pointer to its description.
                static const PSDriver::PageInfo *pageInfo(const PSDriver::MediaSize);
                // Return page description for index indx.
                static const PSDriver::PageInfo *getPageInfo(const int indx);
                // Lookup for a page description using the name field.
                static const PSDriver::PageInfo *lookupPageInfo(const char *name);
                static int numPageTypes();                      // # of page types.
        private:
//<srcblock>
                // Similar to the public drawImage but uses a transform matrix instead of
                // position and scaling.
                // imagematrix          6 element array that defines transformation
                //                      from user space to image space:
                //                      m = [ a b c d tx ty ]
                //                       x' = ax + cy + tx
                //                       y' = bx + dy + ty
                //      The transformation is such that [ width 0 0 height 0 0] will
                //      map the image into a unit square which would then be scaled
                //      by the current scale() values.
                //      To invert the image, use: [ width 0 0 -height 0 height].
                //      If imagematrix is NULL, the image will be mapped into the
                //      unit square.
                // bpc is as above.
                // If smooth is 0, no smoothing is done. Otherwise, pixels are
                // interpolated.
                // Caution: This routine bypasses boundary box checks! If
                // BB checks are not important, then this routine could be public.
//</srcblock>
#if 0
                void drawImage(const float imagematrix[6],
                               const int width, const int height,
                               const uShort *data,
                               const int bpc=-1, const ColorSpace cs=INDEXED,
                               const int smooth=0);
#endif
//#     ////////////////////////////////////////////////////////////////
                void newPath();         // These are used internally.
                void stroke();
                void closePath();
//#     ////////////////////////////////////////////////////////////////
                void init(ostream &output, const ColorSpace cs,
                          const PageInfo *, const Layout, PSInfo *);
                void initname(const String &name, const ColorSpace cs,
                              const PageInfo *, const Layout, PSInfo *);
                // Compare x/y to current bounding box. x and y are in current
                // user coordinates unless userCoords is False in which case they
                // have already been transformed.
                void bbCheck(const float x, const float y, const Bool userCoords=True);
                void bbCheck(); // Do bbCheck on current position.

                void setCurrXY( const float x, const float y,
                                const Bool userCoords = True) {
                        state_.setXY(x, y, userCoords);
                }
                void getCurrXY( float &x, float &y, const Bool userCoords=True) {
                        state_.getXY(x, y, userCoords);
                }
        private:
                void startDocument();
                // Code writers.
                void emitHeader();
                void emitProlog();
                void emitTrailer();
                void emitShowPage(const int force=0);
                void emitPageNum();
                void emitSetup();

                void emitColorSpace(const ColorSpace);
                void emitLineStyle(const LineStyle);
                void emitDashLength(const float length);
                void emitLineWidth(const float w);
                void emitMoveTo(const float x, const float y);
                void emitLineTo(const float x, const float y, const int stroke=1);
                void emitPolyline(const int len, const float *x, const float *y,
                                  const int close, const int fill);
                void emitPolygon(const int len, const float *x, const float *y,
                                 const int fill);
                void emitLine(const float x0, const float y0,
                              const float x1, const float y1);
                void emitLines(const int len, const float *x1, const float *y1,
                               const float *x2, const float *y2);
                void emitRectangle(const float x, const float y,
                                   const float width, const float height,
                                   const int fill);
                void emitPoint(const float x, const float y, const float radius=1.0);
                void emitPoints(const int len, const float *x, const float *y,
                                const float radius=1.0);
                // Rotate by degrees.
                void emitRotate(const float degrees);
                // Scale. (new scale = <old scale>*<new scale>.
                void emitScale(const float x, const float y);
                // Change origin.
                void emitTranslate(const float x, const float y);

                void emitFindFont(const char *fn, const float scale);   // Load font.
                // Draw text starting at point x, y.
                // Newlines, tabs, etc. are not handled.
                void emitText(const float x, const float y, const char *str,
                              const TextAlign=AlignBottomLeft,
                              const float angle = 0);
                // Just throw a string on the stack and leave it there.
                void emitString(const char *str);

                // Draw a width x height PS image.
                // matrix               Matrix to convert between user & image space.
                // width, height        size of input image in pixels.
                // bpc                  bits per color component. ( 8 or 12)
                // smooth               0 - no smoothing, 1 - smooth pixels.
                //                      ghostscript may core dump if not 0.
                //  ascii85             data encoded as ASCII85 chars.
                //  len                 length of data array.
                void emitImage( const float matrix[6],
                                const int width, const int height, const int bpc,
                                const int smooth, const char *ascii85, const int len,
                                const ColorSpace=INDEXED);
                // Load color tables with contents of a, b & c. Typically, a holds
                // red, b holds green & c holds blue. Values should be in the
                // range (0..1).
                void emitStoreColors(const int start, const int len,
                                     const float *a, const float *b, const float *c);
                // Load color tables given an array of colors and their corresponding
                // indexes. Much more effecient if indexes are consecutive.
                void emitStoreColorValues(const int len, const int *indexes,
                                          const float *a, const float *b, const float *c);
                // Internal helper function.
                void emitStoreColors(const int color, const int start, const int len,
                                     const float *ary);

                // Load one value into color table.
                void emitStoreColor(const int index,
                                    const float r, const float g, const float b);
                // Set curren`t color.
                void emitSetColor(const ColorSpace cs, const int index);
                void emitSetColor(const ColorSpace cs,
                                  const float a, const float b, const float c);
                // Load color first ncolors entries in the tables with linear
                // ramps scaled 0..1.
                void emitSetLinearRamps(const int ncolors);
                void emitGSave();
                void emitGRestore();
                void emitPushMatrix();
                void emitPopMatrix();
                void emitClipRect(const float x0, const float y0,
                                  const float width, const float height);
                void emitBackgroundColor(const float a, const float b, const float c,
                                         const ColorSpace cs);
                // Write value of bounding box to output.
                void emitBoundingBox();
        private:
                // Holds our copy of the current transformation matrix. Used for
                // bounding box computations.
                class PSState {
                public:
                        PSState();
                        ~PSState();
                        void scale( const float x, const float y);
                        void translate( const float x, const float y);
                        void rotate(const float degrees);
                        // [ x' y' 1 ] = [ x y 1] * CTM
                        inline void toPoints(const float xin, const float yin,
                                             float &xout, float &yout,
                                             const Bool absolute=True)const {
                                xout = (float)(a_*xin + c_*yin);
                                yout = (float)(b_*xin + d_*yin);
                                if(absolute) {
                                        xout += (float)tx_;
                                        yout += (float)ty_;
                                }
                        }

                        // [ x y 1 ] = [ x' y' 1] * inverse(CTM);
                        inline void fromPoints(const float xin, const float yin,
                                               float &xout, float &yout,
                                               const Bool absolute=True)const {
                                xout = (float)(ai_*xin + ci_*yin);
                                yout = (float)(bi_*xin + di_*yin);
                                if(absolute) {
                                        xout += (float)txi_;
                                        yout += (float)tyi_;
                                }
                        }

                        void setIdentity();
                        void operator=(const PSState &);
                        // Set/Get the current position.
                        void setXY(const float x, const float y,
                                   const Bool userCoords=True);
                        void getXY(float &x, float &y, const Bool userCoords=True);
                private:
                        void invert();

                        double  a_, b_, c_, d_, tx_, ty_;       // Forward
                        double  ai_, bi_, ci_, di_, txi_, tyi_; // Inverse
                        float   currX_, currY_;                 // Current x/y in pnts

                };
                void pushState();
                void popState();
                // Length of internal state(transform) stack.
                enum {STATESTACKLENGTH=16};
                int             statestackindex_;
                PSState         state_;
                PSState         statestack_[STATESTACKLENGTH];
                ostream         *out;
                std::fstream    *mystream_;
                ColorSpace      colorSpace_;
                Dimension       dimension_;
                Bool            portrait_;
                Bool            eps_;
                LineStyle       lineStyle_;
                float           defaultFontSize_;
                float           xscale_, yscale_; // Paper size scale.
                // Bounding box in points.
                float           bbx0_, bby0_;
                float           bbx1_, bby1_;
                Bool            boxCheck0_;             // Has anything been checked?
                Bool            haveBoundingBox_;
                Bool            checkBoundingBox_;
                // user coords.
                // Page boundaries in points;
                float           xll_, yll_;
                float           xur_, yur_;

                // Clipping rectangle in points.
                float           clipXll_, clipXur_;
                float           clipYll_, clipYur_;

                unsigned int    pageNum_;               // Current page number.
                int             finished_;              // Set when finished called.
                PSInfo          *info_;
        };


} //# NAMESPACE CASA - END

#endif