Initial commit

1 files changed, 1934 insertions, 0 deletions

diff --git a/vendor/x11iraf/cdl/cdl.c b/vendor/x11iraf/cdl/cdl.c
new file mode 100644
index 00000000..306b121b
--- /dev/null
+++ b/vendor/x11iraf/cdl/cdl.c
@@ -0,0 +1,1934 @@
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <math.h>
+#define  CDL_LIBRARY_SOURCE
+#define  CDL_NEED_COLORMAPS
+#include "cdl.h"
+
+
+/*
+ * CDL -- Client Display Library.  This package provides a general interface
+ * for client applications to do IRAF-like image display and interaction.
+ * It is layered upon other interfaces for handling basic display, cursor
+ * and frame buffer operations, and low-level server communications.  
+ *
+ *           cdl = cdl_open  (imtdev)
+ *           cdl_displayPix  (cdl, pix, nx, ny, bitpix, frame, fbconfig, zscale)
+ *           cdl_readCursor  (cdl, sample, &x, &y, &wcs, &key)
+ *            cdl_setCursor  (cdl, x, y, wcs)
+ *           cdl_clearFrame  (cdl)
+ *                cdl_close  (cdl)
+ *
+ *          cdl_displayIRAF  (cdl, fname, band, frame, fbconfig, zscale)
+ *               cdl_isIRAF  (fname)
+ *             cdl_readIRAF  (fname, band, &pix, &nx, &ny, &bitpix, title);
+ *
+ *          cdl_displayFITS  (cdl, fname, frame, fbconfig, zscale)
+ *               cdl_isFITS  (fname)
+ *             cdl_readFITS  (fname, &pix, &nx, &ny, &bitpix, title);
+ *
+ *        cdl_computeZscale  (cdl, pix, nx, ny, bitpix, &z1, &z2)
+ *          cdl_zscaleImage  (cdl, &pix, nx, ny, bitpix, z1, z2)
+ *
+ *             cdl_printPix  (cdl, cmd, pix, nx, ny, annotate)
+ *       cdl_printPixToFile  (cdl, fname, pix, nx, ny, annotate)
+ *
+ *            cdl_readImage  (cdl, &pix, &nx, &ny)
+ *      cdl_readFrameBuffer  (cdl, &pix, &nx, &ny)
+ *        cdl_readSubRaster  (cdl, lx, ly, nx, ny, &pix)
+ *       cdl_writeSubRaster  (cdl, lx, ly, nx, ny, pix)
+ *  
+ *             cdl_selectFB  (cdl, nx, ny, &fb, &fb_w, &fb_h, &nframes, reset)
+ *          cdl_setFBConfig  (cdl, configno)
+ *          cdl_getFBConfig  (cdl, &configno, &w, &h, &nframes)
+ *         cdl_lookupFBSize  (cdl, configno, &w, &h, &nframes)
+ *
+ *         cdl_[set|get]WCS  (cdl, name, title, a, b, c, d, tx, ty, z1, z2, zt)
+ *     cdl_[set|get]Mapping  (cdl, region, sx,sy,snx,sny, dx,dy,dnx,dny, ref)
+ *             cdl_queryMap  (cdl, wcs, region, sx,sy,snx,sny, 
+ *					dx,dy,dnx,dny, objref)
+ *
+ *       cdl_[set|get]Frame  (cdl, frame)
+ *      cdl_[set|get]ZTrans  (cdl, ztrans)
+ *      cdl_[set|get]ZScale  (cdl, z1, z2)
+ *      cdl_[set|get]Sample  (cdl, nsample)
+ * cdl_[set|get]SampleLines  (cdl, nlines)
+ *    cdl_[set|get]Contrast  (cdl, contrast)
+ *        cdl_[set|get]Name  (cdl, imname)
+ *       cdl_[set|get]Title  (cdl, imtitle)
+ *
+ *
+ *   GRAPHICS OVERLAY ROUTINES:
+ *   --------------------------
+ *             cdl_mapFrame  (cdl, frame)
+ *            cdl_markPoint  (cdl, x, y, number, size, type, color)
+ *             cdl_markLine  (cdl, xs, ys, xe, ye, color)
+ *              cdl_markBox  (cdl, lx, ly, ux, uy, fill, color)
+ *         cdl_markPolyline  (cdl, xpts, ypts, npts, color)
+ *          cdl_markPolygon  (cdl, xpts, ypts, npts, fill, color)
+ *           cdl_markCircle  (cdl, x, y, radius, fill, color)
+ *       cdl_markCircAnnuli  (cdl, x, y, radius, nannuli, sep, color)
+ *          cdl_markEllipse  (cdl, x, y, xrad, yrad, ang, fill, color)
+ *      cdl_markEllipAnnuli  (cdl, x, y, xrad, yrad, ang, nannuli, sep, color)
+ *             cdl_markText  (cdl, x, y, str, size, angle, color)
+ *
+ *              cdl_setFont  (cdl, type)
+ *
+ *           cdl_deleteMark  (cdl, x, y)
+ *         cdl_clearOverlay  (cdl)
+ *        cdl_redrawOverlay  (cdl)
+ *
+ *
+ *	Client applications begin with a cdl_open() call to initialize the
+ * interface.  The "imtdev" argument is used to specify a connection at device
+ * open time, or if NULL the procedure will attempt to first connect on a unix
+ * socket or fifo pipe if that fails.  The syntax for the imtdev argument is
+ * as follows:
+ *              	<domain> : <address>
+ *
+ * where <domain> is one of "inet" (internet tcp/ip socket), "unix" (unix
+ * domain socket) or "fifo" (named pipe).   The form of the address depends
+ * upon the domain, see the IMD interface code comments or documentation
+ * for examples.
+ *
+ *	The library assumes a logical coordinate system that has the image or
+ * raster origin in the lower-left corner. All I/O routines should be passed
+ * or will return a pixel pointer set to the LL corner of the raster, all
+ * cursor positions will similarly use this coordinate system.  Initially the
+ * [0,0] origin is defined as the LL of the frame buffer, this will remain
+ * the case until the WCS is redefined either explicitly through a cdl_setWCS()
+ * call or by using one of the high level cdl_display*() procedures to display
+ * an image smaller that the current frame buffer.  Applications wishing to
+ * retain this initial origin or those wanting to explicitly place the image
+ * in the frame buffer should use the cdl_writeSubRaster() for display.  This
+ * is to allow cursor and subraster positions to be specified in image coord-
+ * inates more easily.  Negative positions are allowed and will either refer 
+ * to empty pixels if the frame buffer is larger than the image, or pixels 
+ * outside the frame buffer boundaries.  Raster I/O requests will be clipped
+ * to the frame buffer endpoints, a request completely outside the frame buffer
+ * is an error.
+ *
+ *	The high-level display routines cdl_displayIRAF() and cdl_displayFITS()
+ * can be used to display images directly by name.  A WCS will automatically
+ * be defined for each image after the optional zscaling hass been computed.  
+ * Applications wishing to define their own WCS need to call cdl_setWCS()
+ * after the display call to redefine the default WCS.
+ */
+
+/* Function prototypes */
+#ifdef __STDC__
+#include <stddef.h>
+#endif
+
+#ifdef ANSI_FUNC
+
+void cdl_zscale(uchar *im, int nx, int ny, int bitpix, float *z1, float *z2, float contrast, int opt_size, int len_stdline);
+int  cdl_freeDisplayList(CDLPtr cdl, MarkerPtr head);
+
+extern  char *mktemp(char *template);
+extern  int  system(const char *cmd);
+extern  void bcopy(char *b1, char *b2, int length);
+
+#endif
+
+/* Display list declarations.  We keep a separate list for each frame that
+ * is freed whenever a new image is displayed.  The list is maintained as
+ * a doubly-linked list of Marker structs.
+ */
+extern MarkerPtr  DLHead[MAX_FRAMES];          /* diplay list head     */
+extern MarkerPtr  DLTail[MAX_FRAMES];          /* diplay list tail     */
+
+
+int	cdl_debug = 0;
+
+static void 	cdl_applyZscale(), cdl_flip();
+
+
+/*  CDL_OPEN -- Open and initialize the CDL package.
+ */
+
+#ifdef ANSI_FUNC
+
+CDLPtr 
+cdl_open (
+    char *imtdev                        /* connection device	*/
+)
+#else
+
+CDLPtr
+cdl_open (imtdev)
+char	*imtdev;                        /* connection device	*/
+#endif
+{
+	register int i;
+        CDLPtr  cdl;
+	IMDPtr  imd_open();
+
+	/* If the debug flag isn't set in the code, see if it's set in the
+	 * runtime environment.
+	 */
+	if (cdl_debug == 0) {
+	    if (getenv("CDL_DEBUG") != NULL)
+	        cdl_debug = atoi(getenv("CDL_DEBUG"));
+	    else 
+		cdl_debug = 0;
+	    cdl_setDebug (cdl_debug);
+	}
+
+	if (cdl_debug)
+	    printf ("%s\n[cdl_open] imtdev='%s'\n", CDL_VERSION, 
+		(imtdev ? imtdev : ""));
+
+        /* Allocate the cdl structure. */
+        cdl = (struct CDL *) calloc (1, sizeof (struct CDL));
+
+	/* Open the connection to the server. */
+	cdl->imd = imd_open ((imtdev == NULL) ? getenv("IMTDEV") : imtdev);
+	if (cdl->imd == (IMDPtr) NULL) {
+	    free ((char *)cdl);
+	    return (NULL);
+	}
+
+        /* Initialize the CDL structure. */
+        cdl->frame      = 1;
+        cdl->fbconfig   = 1;
+	cdl->fbwidth    = 512;
+	cdl->fbheight   = 512;
+	cdl->fbnf       = 2;
+	cdl->im_nx      = 512;
+	cdl->im_ny      = 512;
+
+	cdl->contrast   = DEF_CONTRAST;
+	cdl->nsample    = DEF_NSAMPLE;
+	cdl->nsamplines = DEF_NSAMPLINES;
+
+	cdl->font       = F_ROMAN;
+	cdl->textwidth  = 1;
+	cdl->linewidth  = 1;
+	cdl->linestyle  = L_SOLID;
+
+        /* Initialize a WCS. */
+        cdl->a          = 1.0;
+        cdl->b          = 0.0;
+        cdl->c          = 0.0;
+        cdl->d          = -1.0;
+        cdl->tx         = 1.0;                  /* default for 512x512 fb */
+        cdl->ty         = 512.0;                /* default for 512x512 fb */
+        cdl->z1         = 0.0;
+        cdl->z2         = 255.0;
+        cdl->ztrans     = CDL_LINEAR;
+
+        /* Initialize the mapping. */
+        cdl->sx         = 1.0;
+        cdl->sy         = 1.0;
+        cdl->snx        = 512;
+        cdl->sny        = 512;
+        cdl->dx         = 0;
+        cdl->dy         = 0;
+        cdl->dnx        = 511;
+        cdl->dny        = 511;
+
+        cdl->iis_version = cdl->imd->iis_version;
+        cdl->iis_valid   = cdl->imd->iis_valid;
+
+        cdl->imname     = (char *) calloc (SZ_NAME, sizeof(char));
+        cdl->imtitle    = (char *) calloc (SZ_NAME, sizeof(char));
+        cdl->region     = (char *) calloc (SZ_NAME, sizeof(char));
+        cdl->ref        = (char *) calloc (SZ_NAME, sizeof(char));
+
+	/* Initialize the display list. */
+	for (i=0; i < MAX_FRAMES; i++)
+	    DLHead[i] = DLTail[i] = (MarkerPtr) NULL;
+
+        return (cdl);   
+}
+
+
+/*  CDL_DISPLAYPIX -- Display a raw pixel array to the server.  Pixels may
+ *  be larger than 8-bits; they will be scaled for display either through
+ *  a simple minmax scaling to 8-bits if zscale=0, or an optimal Z-transform
+ *  will be computed and used if zscale=1.
+ */
+
+#ifdef ANSI_FUNC
+
+int 
+cdl_displayPix (
+    CDLPtr cdl,                         /* package ptr          */
+    uchar *pix,				/* pixels to display	*/
+    int nx,
+    int ny,				/* image dimensions	*/
+    int bitpix,				/* pixel size		*/
+    int frame,				/* display frame	*/
+    int fbconfig,			/* frame bvuffer config */
+    int zscale				/* do zscale of image?	*/
+)
+#else
+
+int
+cdl_displayPix (cdl, pix, nx, ny, bitpix, frame, fbconfig, zscale)
+CDLPtr  cdl;                            /* package ptr          */
+uchar	*pix;				/* pixels to display	*/
+int	nx, ny;				/* image dimensions	*/
+int	bitpix;				/* pixel size		*/
+int	frame;				/* display frame	*/
+int	fbconfig;			/* frame bvuffer config */
+int	zscale;				/* do zscale of image?	*/
+#endif
+{
+	float	z1 = 0.0, z2 = 0.0;
+        int     fb = fbconfig, w, h, nframes;
+
+	if (cdl_debug)
+	    printf ("[cdl_displayPix] %dx%d-%d frame=%d fb=%d zscale=%d\n",
+		nx, ny, bitpix, frame, fbconfig, zscale);
+
+	/* Sanity check. */
+	if (frame < 1 || frame > MAX_FRAMES) {
+	    perror ("cdl_displayPix: invalid frame number");
+	    return (ERR);
+	}
+
+	if (zscale) {
+	    /* Compute the optimal zscale values. */
+            cdl_computeZscale  (cdl, pix, nx, ny, bitpix, &z1, &z2);
+	    cdl_zscaleImage (cdl, &pix, nx, ny, bitpix, z1, z2);
+	    cdl_setZScale (cdl, z1, z2);
+	    cdl->imd->z1 = z1;
+	    cdl->imd->z2 = z2;
+	}
+
+	/* See if we need to free the display list for the frame. */
+	if (DLHead[frame-1] != (MarkerPtr) NULL)
+	    (void) cdl_freeDisplayList (cdl, DLHead[frame-1]);
+
+        /* Do the frame buffer configuration if needed. */
+        if (fbconfig == FB_AUTO) {
+            cdl_selectFB (cdl, nx, ny, &fb, &w, &h, &nframes, True);
+        } else if (fbconfig != cdl->fbconfig) {
+            cdl_setFBConfig (cdl, fbconfig);
+	    fb = max (1, fbconfig);
+	}
+
+	cdl->frame = frame;
+	cdl->im_nx = nx;
+	cdl->im_ny = ny;
+
+	return (imd_displayImage (cdl->imd, pix, nx, ny, frame, fb, 1));
+}
+
+
+/*  CDL_READCURSOR --  Read the current cursor position.  If sample is defined
+ *  logical cursor position will be sampled and returned immediately, otherwise
+ *  the server will block until a key is hit and we return that value as well.
+ */
+
+#ifdef ANSI_FUNC
+
+char 
+cdl_readCursor (
+    CDLPtr cdl,                         /* package ptr          */
+    int sample,                 	/* wait for keystroke?  */
+    float *x,
+    float *y,                 		/* position (output)	*/
+    int *wcs,				/* WCS			*/
+    char *key                   	/* keystroke (output)	*/
+)
+#else
+
+char
+cdl_readCursor (cdl, sample, x, y, wcs, key)
+CDLPtr  cdl;                            /* package ptr          */
+int     sample;                 	/* wait for keystroke?  */
+float   *x, *y;                 	/* position (output)	*/
+int	*wcs;				/* WCS			*/
+char    *key;                   	/* keystroke (output)	*/
+#endif
+{
+	int status;
+
+	if (cdl_debug)
+	    printf ("[cdl_readCursor]\n");
+
+	status =  imd_readCursor (cdl->imd, sample, x, y, wcs, key);
+	return (*key);
+}
+
+
+/*  CDL_SETCURSOR --  Set the current logical cursor position.  If 'wcs' is
+ *  non-zero the cursor position is assumed to be defined in terms of the
+ *  current image WCS, otherwise it is in frame buffer coordinates.
+ */
+
+#ifdef ANSI_FUNC
+
+int 
+cdl_setCursor (
+    CDLPtr cdl,                         /* package ptr          */
+    int x,
+    int y,                 		/* position 		*/
+    int wcs                   		/* cursor wcs		*/
+)
+#else
+
+int
+cdl_setCursor (cdl, x, y, wcs)
+CDLPtr  cdl;                            /* package ptr          */
+int   	x, y;                 		/* position 		*/
+int     wcs;                   		/* cursor wcs		*/
+#endif
+{
+	if (cdl_debug)
+	    printf ("[cdl_setCursor]  x=%d y=%d wcs=%d\n", x, y, wcs);
+
+	return (imd_setCursor (cdl->imd, x, y, wcs));
+}
+
+
+/*  CDL_SETWCS --  Set the WCS of the screen.  The WCS is passed in a string
+ *  defined as:
+ *              Image_Name_String\n a b c d tx ty z1 z2 zt
+ *  where:
+ *              X' = a*X + c*Y + tx
+ *              Y' = b*X + d*Y + ty
+ *
+ *  z1 is the minimum pixel value, z2 is the maximum pixel value,  zt
+ *  defines the type of transformation to use.
+ */
+
+#ifdef ANSI_FUNC
+
+int cdl_setWCS (
+    CDLPtr cdl,                         /* package ptr          */
+    char *imname,                  	/* name string          */
+    char *imtitle,                 	/* title string         */
+    float a,
+    float b,
+    float c,
+    float d,             		/* WCS values           */
+    float tx,
+    float ty,                 		/* translation          */
+    float z1,
+    float z2,                 		/* zscale values        */
+    int zt                     		/* transformation type  */
+)
+#else
+
+int
+cdl_setWCS (cdl, imname, imtitle, a, b, c, d, tx, ty, z1, z2, zt)
+CDLPtr  cdl;                            /* package ptr          */
+char    *imname;                  	/* name string          */
+char    *imtitle;                 	/* title string         */
+float	 a, b, c, d;             	/* WCS values           */
+float	 tx, ty;                 	/* translation          */
+float	 z1, z2;                 	/* zscale values        */
+int	 zt;                     	/* transformation type  */
+#endif
+{
+	int  status = 0;
+
+
+	if (cdl_debug) {
+	    printf ("[cdl_setWCS] name='%s' title='%s'\n", (imname?imname:""),
+		(imtitle?imtitle:""));
+            printf ("\ta=%g b=%g c=%g d=%g tx=%g ty=%g z1=%g z2=%g zt=%d\n",
+               a, b, c, d, tx, ty, z1, z2, zt);
+        }
+
+	strcpy (cdl->imname, (imname ? imname : ""));
+	strcpy (cdl->imtitle, (imtitle ? imtitle : ""));
+	cdl->a 	    = a;
+	cdl->b 	    = b;
+	cdl->c 	    = c;
+	cdl->d 	    = d;
+	cdl->tx     = tx;
+	cdl->ty     = ty;
+	cdl->z1     = z1;
+	cdl->z2     = z2;
+	cdl->ztrans = zt;
+
+	/* Send the WCS. */
+	status = imd_setWCS (cdl->imd, imname, imtitle, a, b, c, d, tx, ty,
+	    z1, z2, zt);
+
+	/* Invalidate the mapping once it's been sent. */
+	cdl->iis_valid = 0;
+
+	return (status);
+}
+
+
+/*  CDL_GETWCS -- Get the current display frame WCS information.
+ */
+
+#ifdef ANSI_FUNC
+
+int 
+cdl_getWCS (
+    CDLPtr cdl,                         /* package ptr          */
+    char *name,                  	/* name string          */
+    char *title,                 	/* title string         */
+    float *a,
+    float *b,
+    float *c,
+    float *d,         			/* WCS values           */
+    float *tx,
+    float *ty,               		/* translation          */
+    float *z1,
+    float *z2,               		/* zscale values        */
+    int *zt                    		/* transformation type  */
+)
+#else
+
+int
+cdl_getWCS (cdl, name, title, a, b, c, d, tx, ty, z1, z2, zt)
+CDLPtr  cdl;                            /* package ptr          */
+char    *name;                  	/* name string          */
+char    *title;                 	/* title string         */
+float   *a, *b, *c, *d;         	/* WCS values           */
+float   *tx, *ty;               	/* translation          */
+float   *z1, *z2;               	/* zscale values        */
+int     *zt;                    	/* transformation type  */
+#endif
+{
+	int wcs = 0;			/* get the frame WCS	*/
+	int status = imd_getWCS (cdl->imd, wcs, name, title, a, b, c, d,
+	    tx, ty, z1, z2, zt);
+
+	cdl->iis_valid = cdl->imd->iis_valid;
+
+	if (cdl_debug) {
+	    printf ("[cdl_getWCS] name='%s' title='%s'\n", (name ? name : ""),
+		(title ? title : ""));
+            printf ("\ta=%g b=%g c=%g d=%g tx=%g ty=%g z1=%g z2=%g zt=%d\n",
+               *a, *b, *c, *d, *tx, *ty, *z1, *z2, *zt);
+        }
+
+	return (status);
+}
+
+
+/*  CDL_SETMAPPING -- Set the mapping information to be sent with the next
+ *  cdl_setWcs() call.
+ */
+#ifdef ANSI_FUNC
+
+int 
+cdl_setMapping  (
+    CDLPtr  cdl,                        /* package ptr          */
+    char    *region,                  	/* region name 		*/
+    float   sx,				/* source rect		*/
+    float   sy,
+    int	    snx, 			/* source extent	*/
+    int	    sny,
+    int	    dx, 			/* dest rect		*/
+    int	    dy,
+    int	    dnx, 			/* dest extent		*/
+    int	    dny,
+    char    *ref                   	/* reference name	*/
+)
+#else
+
+int 
+cdl_setMapping  (cdl, region, sx,sy,snx,sny, dx,dy,dnx,dny, ref)
+CDLPtr  cdl;                            /* package ptr          */
+char    *region;                  	/* region name 		*/
+float	sx, sy;				/* source rect		*/
+int	snx, sny;			/* source extent	*/
+int	dx, dy;				/* dest rect		*/
+int	dnx, dny;			/* dest extent		*/
+char    *ref;                  		/* reference name	*/
+#endif
+{
+        if (cdl_debug) {
+            printf ("[cdl_setMapping] region='%s' ref='%s'\n",
+		(region ? region : ""), (ref ? ref : ""));
+            printf ("\tsrc = %g,%g,%d,%d   dest = %d,%d,%d,%d\n",
+               sx, sy, snx, sny, dx, dy, dnx, dny);
+        }
+
+        strcpy (cdl->region, (region ? region : ""));
+        strcpy (cdl->ref, (ref ? ref : ""));
+        cdl->sx   = sx;
+        cdl->sy   = sy;
+        cdl->snx  = snx;
+        cdl->sny  = sny;
+        cdl->dx   = dx;
+        cdl->dy   = dy;
+        cdl->dnx  = dnx;
+        cdl->dny  = dny;
+
+        return ((cdl->iis_valid = imd_setMapping (cdl->imd, 
+		region, sx,sy,snx,sny, dx,dy,dnx,dny, ref)));
+}
+
+
+/*  CDL_GETMAPPING --  Get the mapping information returned with the last
+ *  cdl_getWcs() call.
+ */
+#ifdef ANSI_FUNC
+int 
+cdl_getMapping  (
+    CDLPtr  cdl,                        /* package ptr          */
+    char    *region,                  	/* region name 		*/
+    float   *sx,			/* source rect		*/
+    float   *sy,
+    int	    *snx, 			/* source extent	*/
+    int	    *sny,
+    int	    *dx, 			/* dest rect		*/
+    int	    *dy,
+    int	    *dnx, 			/* dest extent		*/
+    int	    *dny,
+    char    *ref                   	/* reference name	*/
+)
+
+#else
+int 
+cdl_getMapping  (cdl, region, sx,sy,snx,sny, dx,dy,dnx,dny, ref)
+CDLPtr  cdl;                            /* package ptr          */
+char    *region;                  	/* region name 		*/
+float	*sx, *sy;			/* source rect		*/
+int	*snx, *sny;			/* source extent	*/
+int	*dx, *dy;			/* dest rect		*/
+int	*dnx, *dny;			/* dest extent		*/
+char    *ref;                  		/* reference name	*/
+#endif
+{
+        int  
+	status = imd_getMapping (cdl->imd, region, 
+			sx,sy,snx,sny, dx,dy,dnx,dny, ref);
+
+        if (cdl_debug) {
+            printf ("[cdl_getMapping] region='%s' ref='%s'\n",
+		(region ? region : ""), (ref ? ref : ""));
+            printf ("\tsrc = %g,%g,%d,%d   dest = %d,%d,%d,%d\n",
+               *sx, *sy, *snx, *sny, *dx, *dy, *dnx, *dny);
+        }
+
+        return (status);
+}
+
+
+/*  CDL_QUERYMAP -- Query a mapping given the wcs number.
+ */
+#ifdef ANSI_FUNC
+
+int 
+cdl_queryMap  (
+    CDLPtr  cdl,                        /* package ptr          */
+    int     wcs,                  	/* requested wcs number	*/
+    char    *region,			/* region name		*/
+    float   *sx,			/* source rect		*/
+    float   *sy,
+    int	    *snx, 			/* source extent	*/
+    int	    *sny,
+    int	    *dx, 			/* dest rect		*/
+    int	    *dy,
+    int	    *dnx, 			/* dest extent		*/
+    int	    *dny,
+    char    *objref                   	/* reference name	*/
+)
+#else
+
+int 
+cdl_queryMap  (cdl, wcs, region, sx,sy,snx,sny, dx,dy,dnx,dny, objref)
+CDLPtr  cdl;                            /* package ptr          */
+int     wcs;                  		/* requested wcs number	*/
+char    *region;                  	/* region name 		*/
+float	*sx, *sy;			/* source rect		*/
+int	*snx, *sny;			/* source extent	*/
+int	*dx, *dy;			/* dest rect		*/
+int	*dnx, *dny;			/* dest extent		*/
+char    *objref;                  	/* reference name	*/
+#endif
+{
+	float a, b, c, d, tx, ty, z1, z2;
+	int   zt;
+	char  name[256], title[256];
+	int   wcs_status = ERR;
+	int   frame = wcs / 100;
+
+
+	if (cdl->iis_version > 0) {
+	    /* Do a WCS query so we get the requested mapping. */
+	    wcs_status = imd_getWCS (cdl->imd, wcs, name, title, 
+		&a, &b, &c, &d, &tx, &ty, &z1, &z2, &zt);
+
+	    /* What we really want is the mapping info for the WCS */
+	    wcs_status = cdl_getMapping (cdl, region, sx,sy,snx,sny,
+		dx,dy,dnx,dny, objref);
+
+	    if (cdl_debug) {
+	        printf ("[cdl_queryMap] wcs=%d name='%s' title='%s'\n",
+		    wcs, (name ? name : ""), (title ? title : ""));
+                printf ("\ta=%g b=%g c=%g d=%g tx=%g ty=%g z1=%g z2=%g zt=%d\n",
+                   a, b, c, d, tx, ty, z1, z2, zt);
+                printf ("\tregion='%s' ref='%s'\n",
+		    (region ? region : ""), (objref ? objref : ""));
+                printf ("\tsrc = %g,%g,%d,%d   dest = %d,%d,%d,%d\n",
+                   sx, sy, snx, sny, dx, dy, dnx, dny);
+            }
+	}
+
+	return (wcs_status);
+}
+
+
+
+/*  CDL_CLEARFRAME -- Erase the current display frame.
+ */
+
+#ifdef ANSI_FUNC
+
+int 
+cdl_clearFrame (
+    CDLPtr cdl                          /* package ptr          */
+)
+#else
+
+int
+cdl_clearFrame (cdl)
+CDLPtr  cdl;                            /* package ptr          */
+#endif
+{
+	if (cdl_debug)
+	    printf ("[cdl_clearFrame]\n");
+
+	return (imd_clearFrame (cdl->imd));
+}
+
+
+/*  CDL_SELECTFB -- Select a frame buffer large enough to contain an image
+ *  of the given size.  Instead of finding jsut the first buffer large
+ *  enough to hold the image look for one with minimal edge space.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_selectFB (
+    CDLPtr cdl,                         /* package ptr          */
+    int nx,
+    int ny,				/* image size		*/
+    int *fb,				/* frame buffer		*/
+    int *w,
+    int *h,				/* frame size		*/
+    int *nf,				/* number of frames	*/
+    int reset				/* reset after select	*/
+)
+#else
+
+void
+cdl_selectFB (cdl, nx, ny, fb, w, h, nf, reset)
+CDLPtr  cdl;                            /* package ptr          */
+int	nx, ny;				/* image size		*/
+int	*fb;				/* frame buffer		*/
+int	*w, *h;				/* frame size		*/
+int	*nf;				/* number of frames	*/
+int	reset;				/* reset after select	*/
+#endif
+{
+	register int i, edges, mintab = -1, tmin = 100000;
+	FBTab 	 tab;
+
+	if (cdl_debug)
+	    printf ("[cdl_selectFb] nx=%d ny=%d  ", nx, ny);
+
+	for (i=0; i < MAX_FBCONFIG; i++) {
+	    tab = *cdl->imd->fbtab[i];
+	    if (tab.width == nx && tab.height == ny) {
+		/* Get an exact match first. */
+	        tab = *cdl->imd->fbtab[i];
+	        goto found;
+
+	    } else if (tab.width >= nx && tab.height >= ny) {
+		/* Look for match with smallest padding. */
+		edges = tab.width - nx + tab.height - ny;
+		if (edges < tmin) {
+		    tmin = edges;
+		    mintab = i;
+		}
+	    }
+	}
+	if (mintab >= 0) {
+	    tab = *cdl->imd->fbtab[mintab];
+	    goto found;
+	}
+
+	/* Couldn't find one, punt and use the default. */
+	fprintf (stderr,
+	    "Warning: cannot find adequate frame buffer, using default.\n");
+	tab = *cdl->imd->fbtab[0];
+found:
+	*fb = tab.config;
+	*w  = tab.width;
+	*h  = tab.height;
+	*nf = tab.nframes;
+	if (reset && cdl->fbconfig != *fb)
+	    cdl_setFBConfig (cdl, *fb);
+
+	if (cdl_debug)
+	    printf ("->  fb=%d w=%d h=%d nf=%d\n", *fb, *w, *h, *nf);
+}
+
+
+/*  CDL_CLOSE -- Close the CDL package descriptor.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_close (
+    CDLPtr cdl                          /* package ptr          */
+)
+#else
+
+void
+cdl_close (cdl)
+CDLPtr  cdl;                            /* package ptr          */
+#endif
+{
+	register int i;
+
+	if (cdl_debug)
+	    printf ("[cdl_close]\n");
+
+	for (i=0; i < MAX_FRAMES; i++)
+	    if (DLHead[i] != (MarkerPtr) NULL)
+	        cdl_freeDisplayList (cdl, DLHead[i]);
+
+	free ((char *) cdl->imname);
+	free ((char *) cdl->imtitle);
+	free ((char *) cdl->region);
+	free ((char *) cdl->ref);
+
+	imd_close (cdl->imd);
+	free ((CDLPtr) cdl);
+}
+
+
+
+/*  CDL_READIMAGE -- Read the currently displayed image and return a pointer to
+ *  the array and it's dimensions.  Since we know where the image was written
+ *  in the frame buffer this is really just a large subregion read.
+ */
+
+#ifdef ANSI_FUNC
+
+int 
+cdl_readImage (
+    CDLPtr cdl,                         /* package ptr          */
+    uchar **pix,                   	/* image pixels (output)*/
+    int *nx,
+    int *ny               		/* dimensions (output)  */
+)
+#else
+
+int
+cdl_readImage (cdl, pix, nx, ny)
+CDLPtr  cdl;                            /* package ptr          */
+uchar   **pix;                   	/* image pixels (output)*/
+int     *nx, *ny;               	/* dimensions (output)  */
+#endif
+{
+	int	status;
+
+	if (*pix == NULL)
+	    *pix = (uchar *) malloc (cdl->im_nx * cdl->im_ny);
+
+	status = imd_readImage (cdl->imd, *pix, nx, ny);
+	if (cdl_debug)
+	    printf ("[cdl_readImage] %dx%d pixels\n", *nx, *ny);
+
+	return (status);
+}
+
+
+/*  CDL_READFRAMEBUFFER -- Read the contents of the entire frame buffer and
+ *  return a pointer to the array and it's dimensions. 
+ */
+
+#ifdef ANSI_FUNC
+
+int 
+cdl_readFrameBuffer (
+    CDLPtr cdl,                         /* package ptr          */
+    uchar **pix,                   	/* image pixels (output)*/
+    int *nx,
+    int *ny               		/* dimensions (output)  */
+)
+#else
+
+int
+cdl_readFrameBuffer (cdl, pix, nx, ny)
+CDLPtr  cdl;                            /* package ptr          */
+uchar   **pix;                   	/* image pixels (output)*/
+int     *nx, *ny;               	/* dimensions (output)  */
+#endif
+{
+	int	status;
+
+	if (*pix == NULL)
+	    *pix = (uchar *) malloc (cdl->fbwidth * cdl->fbheight);
+
+	status =  imd_readFrameBuffer (cdl->imd, *pix, nx, ny);
+	if (cdl_debug)
+	    printf ("[cdl_readFrameBuffer] %dx%d pixels\n", *nx, *ny);
+
+	return (status);
+}
+
+
+/*  CDL_COMPUTEZSCALE -- Compute the optimal z1/z2 values for an array. We
+ *  don't transform the pixels, just compute the values.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_computeZscale (
+    CDLPtr cdl,                         /* package ptr          */
+    uchar *pix,                   	/* data to be sampled   */
+    int nx,
+    int ny,                 		/* image dimensions     */
+    int bitpix,                 	/* bits per pixel       */
+    float *z1,
+    float *z2               		/* min/max zscale values*/
+)
+#else
+
+void
+cdl_computeZscale (cdl, pix, nx, ny, bitpix, z1, z2)
+CDLPtr  cdl;                            /* package ptr          */
+uchar   *pix;                   	/* data to be sampled   */
+int     nx, ny;                 	/* image dimensions     */
+int     bitpix;                 	/* bits per pixel       */
+float   *z1, *z2;               	/* min/max zscale values*/
+#endif
+{
+	register float	np = nx * ny;
+
+        cdl_zscale ((uchar *)pix, 
+	    nx, ny, 
+	    bitpix, 
+	    z1, z2, 
+	    cdl->contrast,
+	    cdl->nsample, 
+	    MAX(2,
+	 	(int)(cdl->nsample / (cdl->nsamplines > 0 ?  
+		    cdl->nsamplines :
+	 	    (int)((float)ny / sqrt(np / (float)cdl->nsample))) )));
+
+	if (cdl_debug)
+	    printf ("[cdl_computeZscale] %dx%d-%d  --> z1=%g z2=%g zt=%d\n",
+		nx, ny, bitpix, *z1, *z2, cdl->ztrans);
+}
+
+
+/*  CDL_ZSCALEIMAGE -- Compute the optimal z1/z2 values for an array and then
+ *  scale the pixels.   We only compute the scale values if they're not input,
+ *  otherwise we used the values passed in.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_zscaleImage (
+    CDLPtr cdl,                         /* package ptr          */
+    uchar **pix,                   	/* data to be sampled   */
+    int nx,
+    int ny,                 		/* image dimensions     */
+    int bitpix,                 	/* bits per pixel       */
+    float z1,
+    float z2               		/* min/max zscale values*/
+)
+#else
+
+void
+cdl_zscaleImage (cdl, pix, nx, ny, bitpix, z1, z2)
+CDLPtr  cdl;                            /* package ptr          */
+uchar   **pix;                   	/* data to be sampled   */
+int     nx, ny;                 	/* image dimensions     */
+int     bitpix;                 	/* bits per pixel       */
+float   z1, z2;               		/* min/max zscale values*/
+#endif
+{
+	if (cdl_debug)
+	    printf ("[cdl_zscaleImage]\n");
+
+        cdl_setZScale (cdl, z1, z2);
+        cdl_applyZscale (cdl, pix, nx, ny, bitpix);
+}
+
+
+/*  CDL_PRINTPIX --  Print the given pixels as EPS to the named command. 
+ *  We assume that the 'cmd' argument is a unix command string that takes
+ *  input from the stdin.
+ */
+
+#ifdef ANSI_FUNC
+
+int 
+cdl_printPix (
+    CDLPtr cdl,                         /* package ptr          */
+    char *cmd,				/* command string	*/
+    uchar *pix,				/* pixel array		*/
+    int nx,
+    int ny,				/* image dimensions	*/
+    int annotate			/* annotate output?	*/
+)
+#else
+
+int
+cdl_printPix (cdl, cmd, pix, nx, ny, annotate)
+CDLPtr  cdl;                            /* package ptr          */
+char	*cmd;				/* command string	*/
+uchar	*pix;				/* pixel array		*/
+int	nx, ny;				/* image dimensions	*/
+int	annotate;			/* annotate output?	*/
+#endif
+{
+	FILE 	*fp;
+        PSImagePtr psim, eps_init();
+	char	tmpfile[SZ_NAME], text[SZ_NAME];
+	extern	char *mktemp();
+	extern  int  system();
+
+	if (cdl_debug)
+	    printf ("[cdl_printPix] cmd='%s' %dx%d  annotate=%d\n",
+		cmd, nx, ny, annotate);
+
+	/* Open the image pointer each time since we assume it's not going to
+	 * happen too often.
+	 */
+	psim = eps_init();
+
+        /* Print to a printer device. */
+        strcpy (tmpfile, "/tmp/cdlXXXXXX");
+        if (mktemp(tmpfile) == (char *)NULL) {
+	    eps_close (psim);
+            return (ERR);
+	}
+
+        if (!(fp = fopen (tmpfile, "w"))) {
+	    eps_close (psim);
+            return (ERR);
+	}
+	psim->annotate = annotate;
+	cdl_flip (pix, nx, ny);
+	eps_setLabel (psim, cdl->imname);
+	eps_setCorners (psim, 0, 0, nx, ny);
+	eps_setColorType (psim, EPS_PSEUDOCOLOR);
+	eps_setCmap (psim, cmap_r, cmap_g, cmap_b, 256);
+        eps_print (psim, fp, pix, nx, ny, 8, 0);
+
+        sprintf (text, "cat %s | %s", tmpfile, (cmd ? cmd : "lpr"));
+        (void)system (text);                /* dispose to printer */
+        unlink (tmpfile);                   /* delete tmp file */
+ 
+	/* Clean up. */
+        fclose (fp);
+	eps_close (psim);
+	return (OK);
+}
+
+
+/*  CDL_PRINTPIXTOFILE -- Print the given pixels as EPS to the named file.
+ */
+
+#ifdef ANSI_FUNC
+
+int 
+cdl_printPixToFile (
+    CDLPtr cdl,                         /* package ptr          */
+    char *fname,			/* filename		*/
+    uchar *pix,				/* pixel array		*/
+    int nx,
+    int ny,				/* image dimensions	*/
+    int annotate			/* annotate output?	*/
+)
+#else
+
+int
+cdl_printPixToFile (cdl, fname, pix, nx, ny, annotate)
+CDLPtr  cdl;                            /* package ptr          */
+char	*fname;				/* filename		*/
+uchar	*pix;				/* pixel array		*/
+int	nx, ny;				/* image dimensions	*/
+int	annotate;			/* annotate output?	*/
+#endif
+{
+	FILE 	*fp;
+        PSImagePtr psim, eps_init();
+
+	if (cdl_debug)
+	    printf ("[cdl_printPixToFile] fname='%s' %dx%d  annotate=%d\n",
+		fname, nx, ny, annotate);
+
+	/* Open the image pointer each time since we assume it's not going to
+	 * happen too often.
+	 */
+	psim = eps_init();
+
+	/* Dump the EPS to the file. */
+        if (access (fname, F_OK) < 0) {
+            if ((fp = fopen (fname, "w"))) {
+		eps_setLabel (psim, cdl->imname);
+		psim->annotate = annotate;
+		cdl_flip (pix, nx, ny);
+		eps_setColorType (psim, EPS_PSEUDOCOLOR);
+		eps_setCmap (psim, cmap_r, cmap_g, cmap_b, 256);
+		eps_setCorners (psim, 0, 0, nx, ny);
+                eps_print (psim, fp, pix, nx, nx, 8, 0);
+                fclose (fp);
+            } else {
+                fprintf (stderr, "Could not open file %s", fname);
+		eps_close (psim);
+	        return (ERR);
+	    }
+	}
+
+	eps_close (psim);
+	return (OK);
+}
+
+
+
+/*  CDL_READSUBRASTER -- Read a rectangular region of the frame buffer.
+ */
+
+#ifdef ANSI_FUNC
+
+int 
+cdl_readSubRaster (
+    CDLPtr cdl,				/* package ptr		*/
+    int lx,
+    int ly,               		/* region corner        */
+    int nx,
+    int ny,                 		/* dimensions           */
+    uchar **pix                   	/* image pixels (output)*/
+)
+#else
+
+int
+cdl_readSubRaster (cdl, lx, ly, nx, ny, pix)
+CDLPtr	cdl;				/* package ptr		*/
+int     lx, ly;               		/* region corner        */
+int     nx, ny;                 	/* dimensions           */
+uchar   **pix;                   	/* image pixels (output)*/
+#endif
+{
+	register int llx, lly;
+
+	if (*pix == NULL)
+	    *pix = (uchar *) malloc (nx * ny);
+
+        llx = lx + (cdl->fbwidth / 2) - (cdl->im_nx / 2);
+        lly = ly + cdl->fbheight - ((cdl->fbheight / 2) + (cdl->im_ny / 2));
+
+	if (cdl_debug)
+	    printf ("[cdl_readSubRaster] %dx%d at [%d,%d] offset [%d,%d]\n",
+		nx, ny, lx, ly, llx, lly);
+
+	return (imd_readSubRaster (cdl->imd, lx, ly, nx, ny, *pix));
+}
+
+
+/*  CDL_WRITESUBRASTER -- Write a rectangular region of the frame buffer.
+ */
+
+#ifdef ANSI_FUNC
+
+int 
+cdl_writeSubRaster (
+    CDLPtr cdl,				/* package ptr		*/
+    int lx,
+    int ly,               		/* region corner        */
+    int nx,
+    int ny,                 		/* dimensions           */
+    uchar *pix                   	/* subraster pixels     */
+)
+#else
+
+int
+cdl_writeSubRaster (cdl, lx, ly, nx, ny, pix)
+CDLPtr	cdl;				/* package ptr		*/
+int     lx, ly;               		/* region corner        */
+int     nx, ny;                 	/* dimensions           */
+uchar   *pix;                   	/* subraster pixels     */
+#endif
+{
+	if (cdl_debug)
+	    printf ("[cdl_writeSubRaster] %dx%d at [%d,%d]\n",
+		nx, ny, lx, ly);
+
+	return (imd_writeSubRaster (cdl->imd, lx, ly, nx, ny, pix));
+}
+
+
+
+/*  CDL_SETFBCONFIG -- Set the frame buffer configuration number.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_setFBConfig (
+    CDLPtr cdl,				/* package ptr		*/
+    int configno			/* fb config number	*/
+)
+#else
+
+void
+cdl_setFBConfig (cdl, configno)
+CDLPtr	cdl;				/* package ptr		*/
+int	configno;			/* fb config number	*/
+#endif
+{
+	int	cfg = max (1, configno);
+
+	if (cdl_debug)
+	    printf ("[cdl_setFBConfig] configno=%d\n", configno);
+
+	cdl->fbconfig = cfg;
+	cdl->fbwidth = cdl->imd->fbtab[cfg-1]->width;
+	cdl->fbheight = cdl->imd->fbtab[cfg-1]->height;
+	cdl->fbnf = cdl->imd->fbtab[cfg-1]->nframes;
+	(void) imd_setFBConfig (cdl->imd, cdl->fbconfig);
+}
+
+
+/*  CDL_GETFBCONFIG -- Get the frame buffer configuration number.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_getFBConfig (
+    CDLPtr cdl,				/* package ptr		*/
+    int *configno,                      /* fb config number     */
+    int *w,
+    int *h,				/* fb frame size	*/
+    int *nframes			/* number of frames	*/
+)
+#else
+
+void
+cdl_getFBConfig (cdl, configno, w, h, nframes)
+CDLPtr	cdl;				/* package ptr		*/
+int     *configno;                      /* fb config number     */
+int	*w, *h;				/* fb frame size	*/
+int	*nframes;			/* number of frames	*/
+#endif
+{
+	*configno = cdl->fbconfig;
+	*w        = cdl->fbwidth;
+	*h        = cdl->fbheight;
+	*nframes  = cdl->fbnf;
+
+	if (cdl_debug)
+	    printf ("[cdl_getFBConfig] configno=%d\n", *configno);
+}
+
+
+/*  CDL_LOOKUPFBSIZE -- Get the frame buffer dimensions given a config number.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_lookupFBSize (
+    CDLPtr cdl,				/* package ptr		*/
+    int configno,                       /* fb config number     */
+    int *w,
+    int *h,				/* fb frame size	*/
+    int *nf				/* number of frames	*/
+)
+#else
+
+void
+cdl_lookupFBSize (cdl, configno, w, h, nf)
+CDLPtr	cdl;				/* package ptr		*/
+int     configno;                       /* fb config number     */
+int	*w, *h;				/* fb frame size	*/
+int	*nf;				/* number of frames	*/
+#endif
+{
+	*w  = cdl->imd->fbtab[configno-1]->width;
+	*h  = cdl->imd->fbtab[configno-1]->height;
+	*nf = cdl->imd->fbtab[configno-1]->nframes;
+
+	if (cdl_debug) {
+	    printf ("[cdl_lookupFBSize] configno=%d size=%dx%d\n", configno,
+		*w, *h);
+	}
+}
+
+
+
+/*  CDL_SETFRAME -- Set the current display frame.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_setFrame (
+    CDLPtr cdl,				/* package ptr		*/
+    int frame				/* frame number		*/
+)
+#else
+
+void
+cdl_setFrame (cdl, frame)
+CDLPtr	cdl;				/* package ptr		*/
+int	frame;				/* frame number		*/
+#endif
+{
+	if (cdl_debug)
+	    printf ("[cdl_setFrame] frame=%d\n", frame);
+
+        /* Sanity check. */
+        if (frame < 1 || frame > MAX_FRAMES) {
+            perror ("cdl_setFrame: invalid frame number - resetting.");
+        }
+
+	cdl->frame = max(1,min(MAX_FRAMES,frame));
+	(void) imd_setFrame (cdl->imd, cdl->frame);
+}
+
+
+/*  CDL_SETZTRANS -- Set the current zscale transform parameters.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_setZTrans (
+    CDLPtr cdl,				/* package ptr		*/
+    int ztrans				/* z-transform type	*/
+)
+#else
+
+void
+cdl_setZTrans (cdl, ztrans)
+CDLPtr	cdl;				/* package ptr		*/
+int	ztrans;				/* z-transform type	*/
+#endif
+{
+	if (cdl_debug)
+	    printf ("[cdl_setZTrans] zt=%d\n", ztrans);
+
+	cdl->ztrans = ztrans;
+}
+
+
+/*  CDL_SETZSCLAE -- Set the current zscale transform parameters.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_setZScale (
+    CDLPtr cdl,				/* package ptr		*/
+    float z1,
+    float z2				/* zscale values	*/
+)
+#else
+
+void
+cdl_setZScale (cdl, z1, z2)
+CDLPtr	cdl;				/* package ptr		*/
+float	z1, z2;				/* zscale values	*/
+#endif
+{
+	if (cdl_debug)
+	    printf ("[cdl_setZScale] z1=%g z2=%g\n", z1, z2);
+
+	cdl->z1 = z1;
+	cdl->z2 = z2;
+	cdl->imd->z1 = z1;
+	cdl->imd->z2 = z2;
+}
+
+
+/*  CDL_SETSAMPLE -- Set the number of zscale sample points to use.
+ */
+
+#define	cdl_setNSamples (cdl, ns)	cdl_setSample(cdl,ns)
+#define	cdl_setSamples (cdl, ns)	cdl_setSample(cdl,ns)
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_setSample (
+    CDLPtr cdl,				/* package ptr		*/
+    int nsample				/* no. of sample pts	*/
+)
+#else
+
+void
+cdl_setSample (cdl, nsample)
+CDLPtr	cdl;				/* package ptr		*/
+int	nsample;			/* no. of sample pts	*/
+#endif
+{
+	if (cdl_debug)
+	    printf ("[cdl_setSample] nsample=%d\n", nsample);
+
+	cdl->nsample = MAX(5,nsample);
+}
+
+
+/*  CDL_SETSAMPLELINES -- Set the number of zscale sample lines to use.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_setSampleLines (
+    CDLPtr cdl,				/* package ptr		*/
+    int nlines				/* no. of sample lines	*/
+)
+#else
+
+void
+cdl_setSampleLines (cdl, nlines)
+CDLPtr	cdl;				/* package ptr		*/
+int	nlines;				/* no. of sample lines	*/
+#endif
+{
+	if (cdl_debug)
+	    printf ("[cdl_setSampleLines] nlines=%d\n", nlines);
+
+	cdl->nsamplines = MAX(1,nlines);
+}
+
+
+/*  CDL_SETCONTRAST -- Set the zscale contrast value.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_setContrast (
+    CDLPtr cdl,				/* package ptr		*/
+    float contrast			/* contrast value	*/
+)
+#else
+
+void
+cdl_setContrast (cdl, contrast)
+CDLPtr	cdl;				/* package ptr		*/
+float	contrast;			/* contrast value	*/
+#endif
+{
+	if (cdl_debug)
+	    printf ("[cdl_setContrast] contrast=%g\n", contrast);
+
+	cdl->contrast = contrast;
+}
+
+
+/*  CDL_SETNAME -- Set the image name for the WCS string.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_setName (
+    CDLPtr cdl,				/* package ptr		*/
+    char *imname			/* image name		*/
+)
+#else
+
+void
+cdl_setName (cdl, imname)
+CDLPtr	cdl;				/* package ptr		*/
+char	*imname;			/* image name		*/
+#endif
+{
+	if (cdl_debug)
+	    printf ("[cdl_setName] name='%s'\n", (imname?imname:""));
+
+	(void) imd_setName(cdl->imd, imname);
+}
+
+
+/*  CDL_SETTITLE -- Set the image title for the WCS string.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_setTitle (
+    CDLPtr cdl,				/* package ptr		*/
+    char *imtitle			/* image title		*/
+)
+#else
+
+void
+cdl_setTitle (cdl, imtitle)
+CDLPtr	cdl;				/* package ptr		*/
+char	*imtitle;			/* image title		*/
+#endif
+{
+	if (cdl_debug)
+	    printf ("[cdl_setTitle] title='%s'\n", (imtitle?imtitle:""));
+
+	(void) imd_setTitle(cdl->imd, imtitle);
+}
+
+
+/*  CDL_GETFRAME -- Get the current display frame.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_getFrame (
+    CDLPtr cdl,				/* package ptr		*/
+    int *frame				/* frame number		*/
+)
+#else
+
+void
+cdl_getFrame (cdl, frame)
+CDLPtr	cdl;				/* package ptr		*/
+int	*frame;				/* frame number		*/
+#endif
+{
+	float 	x, y;
+	int	wcs;
+	char 	key;
+
+	(void) imd_readCursor (cdl->imd, 1, &x, &y, &wcs, &key);
+	*frame = (int) (wcs / 100);
+
+	if (*frame == 0)
+	    *frame = cdl->frame;
+
+	if (cdl_debug)
+	    printf ("[cdl_getFrame] frame=%d\n", *frame);
+}
+
+
+/*  CDL_GETZTRANS -- Get the current zscale transform parameters.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_getZTrans (
+    CDLPtr cdl,				/* package ptr		*/
+    int *ztrans                         /* z-transform type     */
+)
+#else
+
+void
+cdl_getZTrans (cdl, ztrans)
+CDLPtr	cdl;				/* package ptr		*/
+int     *ztrans;                        /* z-transform type     */
+#endif
+{
+	*ztrans = cdl->ztrans;
+
+	if (cdl_debug)
+	    printf ("[cdl_getZTrans] zt=%d\n", *ztrans);
+}
+
+
+/*  CDL_GETZTRANS -- Get the current zscale transform parameters.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_getZScale (
+    CDLPtr cdl,				/* package ptr		*/
+    float *z1,
+    float *z2                       	/* zscale values        */
+)
+#else
+
+void
+cdl_getZScale (cdl, z1, z2)
+CDLPtr	cdl;				/* package ptr		*/
+float   *z1, *z2;                       /* zscale values        */
+#endif
+{
+	*z1	= cdl->z1;
+	*z2	= cdl->z2;
+
+	if (cdl_debug)
+	    printf ("[cdl_getZScale] z1=%g z2=%g\n", *z1, *z2);
+}
+
+
+/*  CDL_GETSAMPLE -- Get the number of zscale sample points to use.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_getSample (
+    CDLPtr cdl,				/* package ptr		*/
+    int *nsample                       	/* no. of sample pts    */
+)
+#else
+
+void
+cdl_getSample (cdl, nsample)
+CDLPtr	cdl;				/* package ptr		*/
+int     *nsample;                       /* no. of sample pts    */
+#endif
+{
+	*nsample = cdl->nsample;
+
+	if (cdl_debug)
+	    printf ("[cdl_getSample] nsample=%d\n", *nsample);
+}
+
+
+/*  CDL_GETSAMPLELINES -- Get the number of zscale sample lines to use.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_getSampleLines (
+    CDLPtr cdl,				/* package ptr		*/
+    int *nlines                        	/* no. of sample lines  */
+)
+#else
+
+void
+cdl_getSampleLines (cdl, nlines)
+CDLPtr	cdl;				/* package ptr		*/
+int     *nlines;                        /* no. of sample lines  */
+#endif
+{
+	*nlines = cdl->nsamplines;
+
+	if (cdl_debug)
+	    printf ("[cdl_getSampleLines] nlines=%d\n", *nlines);
+}
+
+
+/*  CDL_GETCONTRAST -- Get the zscale contrast value.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_getContrast (
+    CDLPtr cdl,				/* package ptr		*/
+    float *contrast                     /* contrast value       */
+)
+#else
+
+void
+cdl_getContrast (cdl, contrast)
+CDLPtr	cdl;				/* package ptr		*/
+float   *contrast;                      /* contrast value       */
+#endif
+{
+	*contrast = cdl->contrast;
+
+	if (cdl_debug)
+	    printf ("[cdl_getContrast] contrast=%g\n", *contrast);
+}
+
+
+/*  CDL_GETNAME -- Get the image name for the WCS string.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_getName (
+    CDLPtr cdl,				/* package ptr		*/
+    char *imname                        /* image name           */
+)
+#else
+
+void
+cdl_getName (cdl, imname)
+CDLPtr	cdl;				/* package ptr		*/
+char    *imname;                        /* image name           */
+#endif
+{
+	if (imname) 
+	    strcpy (imname, cdl->imname);
+
+	if (cdl_debug)
+	    printf ("[cdl_setName] name='%s'\n", (imname?imname:""));
+}
+
+
+/*  CDL_GETTITLE -- Get the image title for the WCS string.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_getTitle (
+    CDLPtr cdl,				/* package ptr		*/
+    char *imtitle                       /* image title          */
+)
+#else
+
+void
+cdl_getTitle (cdl, imtitle)
+CDLPtr	cdl;				/* package ptr		*/
+char    *imtitle;                       /* image title          */
+#endif
+{
+	if (imtitle) 
+	    strcpy (imtitle, cdl->imtitle);
+
+	if (cdl_debug)
+	    printf ("[cdl_setTitle] title='%s'\n", (imtitle?imtitle:""));
+}
+
+
+/* --------------------
+ * PRIVATE PROCEDURES
+ * ------------------ */
+
+
+
+/* CDL_SETDEBUG -- Set the state of the debug flag.
+ */
+
+#ifdef ANSI_FUNC
+
+void 
+cdl_setDebug (int state)
+#else
+
+void
+cdl_setDebug (state)
+int     state;
+#endif
+{
+        cdl_debug = state;
+	if (state >= 1)
+	    imd_setDebug (state);
+	if (state >= 2)
+	    com_setDebug (state);
+} 
+
+
+/*  CDL_APPLYZSCALE -- Compute the Zscale transform image given an array of
+ *  raw pixels and image size.  We use the z1/z2/ztrans values assumed to be
+ *  previously stored.
+ */
+
+#ifdef ANSI_FUNC
+
+static void 
+cdl_applyZscale (
+    CDLPtr cdl,                         /* package ptr          */
+    uchar **pix,                   	/* input image pixels 	*/
+    int nx,
+    int ny,               		/* image dimensions   	*/
+    int bitpix				/* pixel type		*/
+)
+#else
+
+static void
+cdl_applyZscale (cdl, pix, nx, ny, bitpix)
+CDLPtr  cdl;                            /* package ptr          */
+uchar   **pix;                   	/* input image pixels 	*/
+int     nx, ny;               		/* image dimensions   	*/
+int	bitpix;				/* pixel type		*/
+#endif
+{
+	register int	i, n = nx * ny, pmin = 1, pmax = 200;
+        register int    smax, smin;
+	float 		pval, scale = 0.0, dscale = (200.0 / 3.0);
+	uchar	 	*outpix ;
+	float	 	z1, z2;			/* zscale values 	*/
+	int	 	zt;
+	extern		void bcopy();
+
+
+       if (cdl_debug)
+            printf ("[cdl_applyZscale] nx=%d by=%d bitpix=%d\n", nx,ny,bitpix);
+
+	/* Move the input array to the output array before zscaling. */
+	outpix = (uchar *) malloc (nx * ny);
+	bcopy ((char *)*pix, (char *)outpix, nx * ny);
+
+	/* Get the zscale transform values. */
+	cdl_getZTrans (cdl, &zt);
+	cdl_getZScale (cdl, &z1, &z2);
+        smin = (int) z1;
+        smax = (int) z2;
+	if (bitpix < 0)
+            scale = (z2 == z1) ? 0. : 200. / (z2 - z1);
+	else
+            scale = (smax == smin) ? 0. : 200. / (z2 - z1);
+
+
+	/* Now scale the pixels. */
+	if (bitpix == 16) {
+            register short int  *buffer = (short *)(*pix);
+
+	    if (zt == CDL_LINEAR) {
+                for (i=0; i < n; i++)
+                    outpix[i] = max (pmin, min (pmax,
+                        (int)(scale * (float)((int)buffer[i] - smin)) ));
+	    } else if (zt == CDL_LOG) {
+                scale = (smax == smin) ? 0. : (1000.0 - 1.0) / (z2 - z1);
+                for (i=0; i < n; i++) {
+		    /* Scale that to the range 1-1000 and take the log. */
+                    pval = max (1.0,min(1000.0, (scale * (buffer[i] - smin)) ));
+                    pval = log10 (pval);
+
+		    /* Now scale back to the display range */
+                    outpix[i] = (uchar) max (pmin, min (pmax,
+			(uchar)(dscale * pval) ));
+		}
+	    } else if (zt == CDL_UNITARY) {
+		for (i=0; i < n; i++) 
+		    outpix[i] = buffer[i];
+	    }
+ 
+	} else if (bitpix == 32) {
+            register int      *buffer = (int *)(*pix);
+
+	    if (zt == CDL_LINEAR) {
+                for (i=0; i < n; i++)
+                    outpix[i] = max (pmin, min (pmax,
+                        (int)(scale * (float)((int)buffer[i] - smin)) ));
+	    } else if (zt == CDL_LOG) {
+                scale = (smax == smin) ? 0. : (1000.0 - 1.0) / (z2 - z1);
+                for (i=0; i < n; i++) {
+		    /* Scale that to the range 1-1000 and take the log. */
+                    pval = max (1.0,min(1000.0, (scale * (buffer[i] - smin)) ));
+                    pval = log10 (pval);
+
+		    /* Now scale back to the display range */
+                    outpix[i] = (uchar) max (pmin, min (pmax,
+			(uchar)(dscale * pval) ));
+		}
+	    } else if (zt == CDL_UNITARY) {
+		for (i=0; i < n; i++) 
+		    outpix[i] = buffer[i];
+	    }
+ 
+	} else if (bitpix == 64) {
+            register long int  *buffer = (long *)(*pix);
+
+	    if (zt == CDL_LINEAR) {
+                for (i=0; i < n; i++)
+                    outpix[i] = max (pmin, min (pmax,
+                        (int)(scale * (float)((int)buffer[i] - smin)) ));
+	    } else if (zt == CDL_LOG) {
+                scale = (smax == smin) ? 0. : (1000.0 - 1.0) / (z2 - z1);
+                for (i=0; i < n; i++) {
+		    /* Scale that to the range 1-1000 and take the log. */
+                    pval = max (1.0,min(1000.0, (scale * (buffer[i] - smin)) ));
+                    pval = log10 (pval);
+
+		    /* Now scale back to the display range */
+                    outpix[i] = (uchar) max (pmin, min (pmax,
+			(uchar)(dscale * pval) ));
+		}
+	    } else if (zt == CDL_UNITARY) {
+		for (i=0; i < n; i++) 
+		    outpix[i] = buffer[i];
+	    }
+ 
+	} else if (bitpix == -32) {
+            register float      *buffer = (float *)(*pix);
+
+	    if (zt == CDL_LINEAR) {
+                for (i=0; i < n; i++)
+                    outpix[i] = max (pmin, min (pmax,
+                        (int)(scale * (float)((float)buffer[i] - z1)) ));
+	    } else if (zt == CDL_LOG) {
+                scale = (smax == smin) ? 0. : (1000.0 - 1.0) / (z2 - z1);
+                for (i=0; i < n; i++) {
+		    /* Scale that to the range 1-1000 and take the log. */
+                    pval = max (1.0,min(1000.0, (scale * (buffer[i] - z1)) ));
+                    pval = log10 (pval);
+
+		    /* Now scale back to the display range */
+                    outpix[i] = (uchar) max (pmin, min (pmax,
+			(uchar)(dscale * pval) ));
+		}
+	    } else if (zt == CDL_UNITARY) {
+		for (i=0; i < n; i++) 
+		    outpix[i] = buffer[i];
+	    }
+ 
+	} else if (bitpix == -64) {
+            register double      *buffer = (double *)(*pix);
+
+	    if (zt == CDL_LINEAR) {
+                for (i=0; i < n; i++)
+                    outpix[i] = max (pmin, min (pmax,
+                        (int)(scale * (float)((double)buffer[i] - z1)) ));
+	    } else if (zt == CDL_LOG) {
+                scale = (smax == smin) ? 0. : (1000.0 - 1.0) / (z2 - z1);
+                for (i=0; i < n; i++) {
+		    /* Scale that to the range 1-1000 and take the log. */
+                    pval = max (1.0,min(1000.0, (scale * (buffer[i] - z1)) ));
+                    pval = log10 (pval);
+
+		    /* Now scale back to the display range */
+                    outpix[i] = (uchar) max (pmin, min (pmax,
+			(uchar)(dscale * pval) ));
+		}
+	    } else if (zt == CDL_UNITARY) {
+		for (i=0; i < n; i++) 
+		    outpix[i] = buffer[i];
+	    }
+	}
+
+	/* Copy the scaled pixel array back to the original raster.  We don't
+	 * realloc the pointer in case it's some static array.
+	 */
+	bcopy ((char *)outpix, (char *)*pix, n);
+
+	if (cdl_debug)
+	    printf ("[cdl_zscaleImage] %dx%d-%d  --> z1=%g z2=%g zt=%d\n",
+		nx, ny, bitpix, z1, z2, zt);
+
+	free ((char *) outpix);
+}
+
+
+/* CDL_FLIP -- Reverse order of lines in image.
+ */
+
+#ifdef ANSI_FUNC
+
+static void 
+cdl_flip (uchar *buffer, int nx, int ny)
+#else
+
+static void
+cdl_flip (buffer, nx, ny)
+uchar 	*buffer;
+int     nx;
+int     ny;
+#endif
+{
+        register int    i, j, v;
+        register uchar  *buff1, *buff2;
+
+        for (i = 0; i < ny / 2; i++) {
+            buff1 = &buffer[i*nx];
+            buff2 = &buffer[(ny-1-i)*nx];
+            for (j = 0; j < nx; j++) {
+                v = *buff1;
+                *(buff1++) = *buff2;
+                *(buff2++) = v;
+            }
+        }
+}