comparison tools/x11coord.c @ 0:5242703e91d3 tip

Initial checkin for AIM92 aimR8.2 (last updated May 1997).

+/****************************************************************************
+*       Routines for x11coord package.
+****************************************************************************/
+
+#include <stdio.h>
+#include <math.h>
+#include "x11coord.h"
+
+/****************************************************************************
+*   Set parameters for data-pixel conversion macros
+****************************************************************************/
+/* Initialize parameters for size and position of window on screen */
+set_window_parameters(xorg,yorg, width,height)
+int xorg,yorg;      /* Pixel coords of window origin wrt theDisplay origin */
+int width,height;   /* Size of window (in pixels) */
+{
+    _xorg   = xorg;
+    _yorg   = yorg;
+    _width  = width;
+    _height = height;
+    set_bordered_box((int)0);   /* defaults */
+    set_data_parameters((int)0,(int)0, (float)0,(float)0, (float)width,(float)height);
+}
+
+/* Initialize parameters for size and position of box in preset window */
+set_box_parameters(xorg,yorg, width,height)
+int xorg,yorg;      /* Pixel coords of box origin wrt bottom-left of window */
+int width,height;   /* Size of window (in pixels) */
+{
+    _Xp0    = xorg;
+    _Yp0    = _height - yorg;
+    _Xp1    = xorg + width;
+    _Yp1    = _height - (yorg + height);
+    _Wb     = _Xp1 - _Xp0;
+    _Hb     = _Yp0 - _Yp1;
+    set_data_parameters((int)0,(int)0, (float)0,(float)0, (float)width,(float)height);
+}
+
+
+/* Initialize parameters for size and position of box in preset window,   */
+/* given the width of the border as a %age of the window size on any side */
+set_bordered_box(bpc)
+int bpc;
+{
+    int  xborder, yborder, Wb, Hb;
+
+    xborder = (_width *  bpc) / 100;
+    yborder = (_height * bpc) / 100;
+    Wb      = _width -  2*xborder;
+    Hb      = _height - 2*yborder;
+    set_box_parameters(xborder,yborder, Wb,Hb);
+}
+
+/* Initialize parameters for area and location of data-space to appear in box */
+set_data_parameters(xp0,yp0, xd0,yd0, xrange,yrange)
+int   xp0,yp0;      /* Box origin shift as a percentage of box width,height */
+float xd0,yd0;      /* Data coord to appear under box origin.               */
+float xrange,yrange;/* Data ranges (corresponding to box width and height). */
+{
+    _xrange = xrange;
+    _yrange = yrange;
+    _xshift = (_Wb * xp0)/100;
+    _yshift = (_Hb * yp0)/100;
+    _xd0    = xd0;
+    _yd0    = yd0;
+    _Xd0    = xd0 - _xrange*((float)_xshift/_Wb);
+    _Yd0    = yd0 - _yrange*((float)_yshift/_Hb);
+    _Xd1    = xd0 + (_xrange - _xrange*((float)_xshift/_Wb));
+    _Yd1    = yd0 + (_yrange - _yrange*((float)_yshift/_Hb));
+
+    _xoffset = _Xp0       + _xshift - _xd0*_Wb/_xrange ;
+    _yoffset = _Yp1 + _Hb - _yshift + _yd0*_Hb/_yrange ;
+    _xscale  = _Wb/_xrange;
+    _yscale  = _Hb/_yrange;
+}
+
+
+/****************************************************************************
+*       Creating windows, initializing GC and Font,  etc..   (X11 specific)
+****************************************************************************/
+xopen()
+{
+
+    if ((char *)getenv("DISPLAY") == (char *)0 )  {
+	fprintf(stderr,"DISPLAY not set\n");
+	exit(1);
+    }
+    if ((theDisplay = XOpenDisplay(NULL)) == NULL)  {
+	fprintf(stderr,"Can't open display %s\n", getenv("DISPLAY"));
+	exit(1);
+    }
+    theScreen = XDefaultScreen(theDisplay);
+    theForeground = theBlack = XBlackPixel(theDisplay,theScreen);  /* Black lines, text, and borders */
+    theBackground = theWhite = XWhitePixel(theDisplay,theScreen);  /* White background */
+    theWidth = XDisplayWidth(theDisplay,theScreen);
+    theHeight = XDisplayHeight(theDisplay,theScreen);
+    theGC = initGC() ;
+}
+
+
+/*
+eg: xgc( 1, "times_roman14" ) ;
+*/
+
+xgc( linewidth, fontstr )
+int   linewidth ;
+char *fontstr   ;
+{
+    setLinewidth( linewidth ) ;
+    theFont = (XFontStruct *)0;
+    if ( setFont( fontstr ) == NULL ) {
+	fprintf( stderr,"can't load font %s\n", fontstr ) ;
+	exit( 1 ) ;
+    }
+}
+
+
+GC initGC()
+{
+    GC  gc;
+
+    gc = XDefaultGC(theDisplay, theScreen);
+    /* Set foreground and background pixel values (ie colours) */
+    XSetState(theDisplay, gc, theForeground, theBackground, GXcopy, AllPlanes);
+    return gc;
+}
+
+
+
+setLinewidth(width)     /* Set line width, used by XDrawLine commands */
+int  width;
+{
+    XGCValues  gcvalues;
+
+    gcvalues.line_width = width;
+    XChangeGC(theDisplay, theGC, GCLineWidth, &gcvalues);
+}
+
+
+setFont(fontname)   /* Free last theFont (unless null) and load new font */
+char *fontname;     /* return null if can't load font */
+{
+    if (theFont != (XFontStruct *)0) XFreeFont(theDisplay,theFont);
+    if ((theFont = XLoadQueryFont(theDisplay, fontname)) == NULL)
+	return 0 ;
+    XSetFont(theDisplay, theGC, theFont->fid);
+    return 1 ;
+}
+
+
+Window  xCreate(name, event_mask, xorg,yorg, width,height)
+char *name;
+long  event_mask;
+int   xorg,yorg, width,height;
+{
+    Window w;
+
+    if ((w = XCreateSimpleWindow(theDisplay, XDefaultRootWindow(theDisplay),
+			   xorg, yorg, (unsigned)width, (unsigned)height, 1,
+				     theForeground, theBackground)) == (Window)0 ) {
+	fprintf(stderr,"can't create window\n");
+	exit(1);
+    }
+    XStoreName(theDisplay, w, name);
+    XSelectInput(theDisplay, w, event_mask);
+    XMapWindow(theDisplay, w);
+    XFlush(theDisplay);
+    return w;
+}
+
+
+/****************************************************************************
+* Drawing axes and boxes in a given window w.
+****************************************************************************/
+axis(w, p0,p1, ploc,axis)
+Window w;
+int    p0,p1;   /* First and last axis pixel distances, relative to parent */
+int    ploc;    /* Location of axis (orthogonal pixel dist from parent org) */
+char   axis;    /* Orientation of axis ('x' or 'y') */
+{
+    if (axis=='x')  XDrawLine(theDisplay, w, theGC, p0,ploc, p1,ploc);
+    if (axis=='y')  XDrawLine(theDisplay, w, theGC, ploc,p0, ploc,p1);
+}
+
+box(w, x0,y0, x1,y1)    /* draw rectangular box */
+Window w;
+int    x0,y0, x1,y1;
+{
+    axis(w, y0,y1, x0,'y');
+    axis(w, y0,y1, x1,'y');
+    axis(w, x0,x1, y0,'x');
+    axis(w, x0,x1, y1,'x');
+}
+
+/****************************************************************************
+* Calibrating axes and boxes in a given window w.
+****************************************************************************/
+struct mark_struct {
+    int    type;        /* type= HALFMARK or FULLMARK */
+    int    position;    /* mark position on screen relative to the parent system */
+    char   label[16];   /* ASCII label of real plot value (FULLMARK only) */
+};
+
+#define NMARKS      150 /* size of array of calibration marks */
+#define FULLMARK    10  /* Box calibration marks */
+#define HALFMARK    5
+
+calibrate_Axis(w, p0,p1, d0,d1, ploc,axis)
+Window w;
+int    p0,p1;   /* First and last axis pixel distances, relative to parent */
+float  d0,d1;   /* First and last axis data values */
+int    ploc;    /* Location of axis (orthogonal pixel dist from parent org) */
+char   axis;    /* Orientation of axis ('x' or 'y') */
+{
+    int     n;
+    struct  mark_struct mark[NMARKS];
+
+    if ((n = calibrate(mark, p0,p1, d0,d1)) < 0) {
+	fprintf(stderr,"mark array out of space, increase NMARKS\n");
+	exit(1);
+    }
+    if (axis=='x')  plotX(w, ploc, mark, n);
+    if (axis=='y')  plotY(w, ploc, mark, n);
+}
+
+
+calibrate_Box(w, xp0,yp0, xp1,yp1, xd0,yd0, xd1,yd1)
+Window  w;
+int     xp0,yp0, xp1,yp1;
+float   xd0,yd0, xd1,yd1;
+{
+    calibrate_Axis(w, xp0,xp1, xd0,xd1, yp0,'x');
+    calibrate_Axis(w, yp0,yp1, yd0,yd1, xp0,'y');
+}
+
+
+plotX(w, Y, mark, n)    /* Plot calibration marks along an X axis */
+Window w;
+int    Y;
+struct mark_struct mark[];
+int    n;
+{
+    int   i, H, W;
+    int   X;
+
+    for (i = 0 ; i < n ; i++) {
+	X = mark[i].position;
+	XDrawLine(theDisplay, w, theGC, X, Y, X, Y+mark[i].type);
+	if (mark[i].type == FULLMARK)      /* Label calibration value */
+	{
+	    W = stringwidth(mark[i].label) / 2; /* Shift label left by half width */
+	    H=20;                               /* Shift label down a bit */
+	    XDrawString(theDisplay, w, theGC, X-W, Y+H, mark[i].label, strlen(mark[i].label));
+	}
+    }
+}
+
+plotY(w, X, mark, n)    /* Plot calibration marks along a Y axis */
+Window w;
+int    X;
+struct mark_struct mark[];
+int    n;
+{
+    int   i, H, W;
+    int   Y;
+
+    for (i = 0 ; i < n ; i++) {
+	Y = mark[i].position;
+	XDrawLine(theDisplay, w, theGC, X, Y, X-mark[i].type, Y);
+	if (mark[i].type == FULLMARK) {    /* Label calibration value */
+	    W = stringwidth(mark[i].label) + 10;/* Shift label left by width */
+	    H=5;                                /* Shift label down a bit */
+	    XDrawString(theDisplay, w, theGC, X-W, Y+H, mark[i].label, strlen(mark[i].label));
+	}
+    }
+}
+
+/****************************************************************************
+*       Macros used by calibration routines
+****************************************************************************/
+#define rem(x,y)    fabs((x) - (y)*(int)((x)/(y)))      /* real remainder */
+#define rem2(x,y)   fabs((x) - (y)*(int)((x)/(y)-0.5))  /* real remainder for -ve x */
+#define round(x)    ((x >= 0) ? ((int)(x+0.5)) : ((int)(x-0.5)))
+#define min(x,y)    ((x < y) ? x : y)
+#define EPS         1.0e-5
+
+/****************************************************************************
+* Calibrate one axis.
+* Fill the given array "mark" with mark structs, and return the number of
+*   marks, or -1 indicating that the mark array is full, (and NMARKS should
+*   be increased).
+* Each mark struct in the array gives the mark position (in pixels relative
+*   to the given first and last mark positions), the mark type (being HALFMARK
+*   or FULLMARK), and a label string (for each FULLMARK only).
+* Arguments are as follows:
+*   p0,p1   first and last screen positions in pixels, relative to the parent
+*           window, (used to calculate mark positions on the screen).
+*   d0,d1   first and last data values (used to calculate axis labels).
+*****************************************************************************/
+calibrate(mark, p0, p1, d0, d1)
+struct mark_struct mark[];
+int    p0,p1;   /* first and last axis pixel distances, relative to parent */
+float  d0,d1;   /* first and last axis data values */
+{
+    int   position, plotsize, nmarks=0;
+    float div, hdiv, offset, hoffset, value, hvalue;
+    float range, scalefactor, maxerror, nextvalue, lastvalue;
+    float label, real_division (), sig_figs ();
+    float tmp;
+
+    if (d0 > d1) {      /* swap to get +ve range */
+	tmp = d1; d1 = d0; d0 = tmp;
+	tmp = p1; p1 = p0; p0 = tmp;
+    }
+
+    plotsize = p1-p0;   /* screen size     */
+    range    = d1-d0;   /* real plot range */
+
+    div = real_division (range);
+    hdiv = div/10;      /* Halfmarks every 10th labelled division (fullmark) */
+
+    /* calculate real offset and hoffset of 1st fullmark and halfmark */
+    /* respectively, from first (ie min) real value d0.               */
+    if (d0 == 0)
+    {
+	offset = hoffset = 0;
+    }
+    else
+    {
+	if (d0 > 0)
+	{
+	    offset = div - rem(d0,div);
+	    hoffset = hdiv - rem(d0,hdiv);
+	}
+	else    /* (d0 < 0) */
+	{
+	    offset = rem2(d0,div);
+	    hoffset = rem2(d0,hdiv);
+	}
+    }
+
+    value = d0 + offset;       /* real value of 1st fullmark */
+    hvalue = d0 + hoffset;     /* real value of 1st halfmark */
+
+    scalefactor = (float)plotsize/range;    /* scale factor between real range and plotted range */
+    maxerror = hdiv/2;
+    lastvalue = d0+range+maxerror;
+    nextvalue = value-maxerror;
+
+    /* Plot halfmarks up to 1st fullmark */
+
+    for (  ; hvalue < nextvalue ; hvalue += hdiv)
+    {
+	position = (int)((hvalue-d0) * scalefactor);   /* actual plotted position (in plot range) */
+	setmark (&mark[nmarks], HALFMARK, p0+position, NULL);
+	if (++nmarks >= NMARKS) return -1;
+    }
+
+    /* Loop plotting fullmarks, with halfmarks between each */
+
+    for (  ; value < lastvalue ; value += div)
+    {
+	position = (int)((value-d0) * scalefactor);    /* actual plotted position */
+	label = sig_figs (value, range);
+	setmark (&mark[nmarks], FULLMARK, p0+position, label);
+	if (++nmarks >= NMARKS) return -1;
+
+	/* Loop plotting halfmarks between each fullmark */
+
+	nextvalue = value+div-maxerror;
+	if (nextvalue > lastvalue) nextvalue = lastvalue;
+	for (hvalue = value+hdiv ; hvalue < nextvalue ; hvalue += hdiv)
+	{
+	    position = (int)((hvalue-d0) * scalefactor);   /* actual plotted position */
+	    setmark (&mark[nmarks], HALFMARK, p0+position, NULL);
+	    if (++nmarks >= NMARKS) return -1;
+	}
+    }
+    return nmarks;
+}
+
+
+float
+real_division (range)   /* Return recomended division between fullmarks on real scale */
+float range;
+{
+    int   power;
+    float scalefactor, scaled_range, div;
+
+    if (range <= 0) {
+	fprintf(stderr,"range must be positive\n");
+	exit(1);
+    }
+
+    if (range >= 1.0)
+	power = -(int)(log10(range) + EPS);
+    else
+	power = -(int)(log10(range) - 1 + EPS);
+    scalefactor = pow (10.0, (float)power);
+
+    scaled_range = range * scalefactor; /* scaled_range is (1 <= range <= 9.9999) */
+
+    /* Set division size (in scaled_range) between given breaks in the scale */
+
+    if      (scaled_range < 1.5) div = 0.1;
+    else if (scaled_range < 2.5) div = 0.2;
+    else if (scaled_range < 5.0) div = 0.5;
+    else                         div = 1.0;
+
+    return (div/scalefactor);   /* return div scaled down to real range */
+}
+
+
+float
+sig_figs (value, range) /* Round value to 2 sig figs on the scale of the range */
+float value, range;
+{
+    int   power;
+    float scalefactor, scaled_value;
+
+    if (range >= 1.0)
+	power = 1-(int)(log10(range) + EPS);
+    else
+	power = 1-(int)(log10(range) - 1 + EPS);
+    scalefactor = pow (10.0, (float)power);
+
+    scaled_value = value * scalefactor; /* scaled_value is in range (10 <= range <= 99.999) */
+    value = round(scaled_value);
+
+    return (value/scalefactor);
+}
+
+/* Fill one mark struct with the mark position, type, and label */
+setmark (mark, mark_type, x, x1)
+struct mark_struct *mark;
+int   mark_type;
+int   x;                /* position */
+float x1;               /* value of label */
+{
+    if ((mark->type = mark_type) == FULLMARK)
+	labelstring(mark->label, x1);
+    mark->position = x;
+}
+
+/* Return with str containing an appropriate ASCII string of the given value */
+labelstring(str, value)
+char  *str;
+float  value;
+{
+    float decval;       /* decimal part of a number */
+
+    decval = value - (int)value;
+    if (value < 0) decval = -decval;
+    if (value > -EPS && value < EPS)    sprintf(str,"0"             );
+    else if (fabs(value) >= 10000)      sprintf(str,"%g",      value);
+    else if (decval <= EPS)             sprintf(str,"%d", (int)value);
+    else if (decval <= 0.001)           sprintf(str,"%.4f",    value);
+    else if (decval <= 0.01)            sprintf(str,"%.3f",    value);
+    else if (decval <= 0.1)             sprintf(str,"%.2f",    value);
+    else                                sprintf(str,"%.1f",    value);
+}
+
+/****************************************************************************
+	Text printing routines.
+****************************************************************************/
+/* The origin for a char is an x-value of `lbearing' to the left of the    */
+/*  left-most char ink, and a y-value between the `ascent' and the         */
+/*  `descent', (ie along an underline), (ref 6-20).                        */
+/* The `margin' is an ad-hoc idea.                                         */
+
+/* Return the width in pixels of the given string, using the current font */
+stringwidth(str)
+char *str;
+{
+    int width;
+
+    width = XTextWidth(theFont, str, strlen(str));
+    return width;
+}
+
+/* Return the height in pixels of the given string, using the current font */
+stringheight(str)
+char *str;
+{
+    XCharStruct stringinfo;     /* ref Xlib 6-17 */
+    int   dr, fa, fd;
+    short asc, desc, width;
+    int   height;
+
+    XTextExtents(theFont, str, strlen(str), &dr,&fa,&fd, &stringinfo);
+    asc   = stringinfo.ascent;          /* max of char ascents in string */
+    desc  = stringinfo.descent;         /* max of char descents in string */
+    width = stringinfo.width;           /* sum of char widths across string */
+    height = asc+desc;                  /* max height over all chars  */
+    return height;
+}
+
+
+/****************************************************************************
+	Misc routines.
+****************************************************************************/
+/* Plot a dot at data coord (x,y). Dotsize=0,1,2,3,.., and size 0 is empty */
+Dot(w,x,y,dotsize)
+Window w;
+float  x,y;
+int    dotsize;
+{
+    int d, X,Y;
+
+    if ((d=dotsize-1) >= 0) {
+	if (d==0)           /* dotsize = 1 */
+	    Point(w, x,y);
+	else {              /* dotsize > 1 */
+	    for (X=(-d) ; X<=d ; X++)
+		for (Y=(-d) ; Y<=d ; Y++)
+		    XDrawPoint(theDisplay,w,theGC,px(x)+X,py(y)+Y);
+	}
+    }
+}