grid.c

ngspice又一个电子CAD仿真软件代码.功能更全

/**********
Copyright 1990 Regents of the University of California.  All rights reserved.
Modified: 2001 AlansFixes
$Id: grid.c,v 1.5 2005/05/30 20:28:44 sjborley Exp $
**********/

/*
 
    Routines to draw the various sorts of grids -- linear, log, polar.
*/

#include <ngspice.h>
#include <graph.h>
#include <cpdefs.h>
#include <ftedefs.h>

#include "grid.h"
#include "../display.h"

#define RAD_TO_DEG	(180.0 / M_PI)
#define LABEL_CHARS	20


/* static declarations */
static double * lingrid(GRAPH *graph, double lo, double hi, double delta, int type, Axis axis);
static double * loggrid(GRAPH *graph, double lo, double hi, int type, Axis axis);
static void polargrid(GRAPH *graph);
static void drawpolargrid(GRAPH *graph);
static void adddeglabel(GRAPH *graph, int deg, int x, int y, int cx, int cy, int lx, int ly);
static void addradlabel(GRAPH *graph, int lab, double theta, int x, int y);
static void smithgrid(GRAPH *graph);
static void drawsmithgrid(GRAPH *graph);
static void arcset(GRAPH *graph, double rad, double prevrad, double irad, double iprevrad, 
		   double radoff, int maxrad, int centx, int centy, int xoffset, int yoffset, 
		   char *plab, char *nlab, int pdeg, int ndeg, int pxmin, int pxmax);
static double cliparc(double cx, double cy, double rad, double start, double end, int iclipx, 
		      int iclipy, int icliprad, int flag);


/* note: scaleunits is static and never changed in this file
    ie, can get rid of it */
static bool scaleunits = TRUE;


void
gr_fixgrid(GRAPH *graph, double xdelta, double ydelta, int xtype, int ytype)
{
    double *dd;

    if (graph->grid.gridtype == GRID_NONE) {
        graph->grid.gridtype = GRID_LIN;
    }

    SetColor(1);
    SetLinestyle(1);

    if ((graph->data.xmin > graph->data.xmax)
            || (graph->data.ymin > graph->data.ymax)) {
      fprintf(cp_err, 
        "gr_fixgrid: Internal Error - bad limits: %g, %g, %g, %g\r\n",
        graph->data.xmin, graph->data.xmax, 
        graph->data.ymin, graph->data.ymax);
      return;
    }

    if (graph->grid.gridtype == GRID_POLAR) {
        graph->grid.circular = TRUE;
        polargrid(graph);
        return;
    } else if (graph->grid.gridtype == GRID_SMITH
        || graph->grid.gridtype == GRID_SMITHGRID)
    {
        graph->grid.circular = TRUE;
        smithgrid(graph);
        return;
    }
    graph->grid.circular = FALSE;

    if ((graph->grid.gridtype == GRID_YLOG)
            || (graph->grid.gridtype == GRID_LOGLOG))
        dd = loggrid(graph, graph->data.ymin, graph->data.ymax,
                ytype, y_axis);
    else
        dd = lingrid(graph, graph->data.ymin, graph->data.ymax,
                ydelta, ytype, y_axis);

    graph->datawindow.ymin = dd[0];
    graph->datawindow.ymax = dd[1];

    if ((graph->grid.gridtype == GRID_XLOG)
            || (graph->grid.gridtype == GRID_LOGLOG))
        dd = loggrid(graph, graph->data.xmin, graph->data.xmax,
                xtype, x_axis);
    else
        dd = lingrid(graph, graph->data.xmin, graph->data.xmax,
                xdelta, xtype, x_axis);

    graph->datawindow.xmin = dd[0];
    graph->datawindow.xmax = dd[1];

/* do we really need this? */
/*
    SetLinestyle(0);
    DrawLine(graph->viewportxoff, graph->viewportyoff,
            graph->viewport.width + graph->viewportxoff,
            graph->viewportyoff);
    DrawLine(graph->viewportxoff, graph->viewportyoff,
            graph->viewportxoff,
            graph->viewport.height + graph->viewportyoff);
    SetLinestyle(1);
*/

    return;
}

void
gr_redrawgrid(GRAPH *graph)
{

    SetColor(1);
    SetLinestyle(1);
    /* draw labels */
    if (graph->grid.xlabel) {
      Text(graph->grid.xlabel,
          (int) (graph->absolute.width * 0.35),
          graph->fontheight);
    }
    if (graph->grid.ylabel) {
    	  if (graph->grid.gridtype == GRID_POLAR 
    	          || graph->grid.gridtype == GRID_SMITH
    	          || graph->grid.gridtype == GRID_SMITHGRID) {
              Text(graph->grid.ylabel,
                   graph->fontwidth,
		   (graph->absolute.height * 3) / 4 );
	  } else {
              Text(graph->grid.ylabel,
                   graph->fontwidth,
		   graph->absolute.height / 2 );
	  }
    }

    switch( graph->grid.gridtype ) {
	case GRID_POLAR:
        	drawpolargrid(graph);
		break;
	case GRID_SMITH:
        	drawsmithgrid(graph);
		break;
	case GRID_SMITHGRID:
        	drawsmithgrid(graph);
		break;
		

    	case GRID_XLOG:
        case GRID_LOGLOG:
        	drawloggrid(graph,
               		graph->grid.xaxis.log.units,
			graph->grid.xaxis.log.hmt,
               		graph->grid.xaxis.log.lmt,
                	graph->grid.xaxis.log.decsp,
                	graph->grid.xaxis.log.subs,
                	graph->grid.xaxis.log.pp, x_axis);
		break;
	default:
        	drawlingrid(graph,
               		graph->grid.xaxis.lin.units,
               		graph->grid.xaxis.lin.spacing,
               		graph->grid.xaxis.lin.numspace,
               		graph->grid.xaxis.lin.distance,
               		graph->grid.xaxis.lin.lowlimit,
               		graph->grid.xaxis.lin.highlimit,
               		graph->grid.xaxis.lin.onedec,
               		graph->grid.xaxis.lin.mult,
               		graph->grid.xaxis.lin.tenpowmag
               		/ graph->grid.xaxis.lin.tenpowmagx,
               		graph->grid.xaxis.lin.digits,
               		x_axis);
		break;
     }

    switch( graph->grid.gridtype ) {
	case GRID_POLAR:
	case GRID_SMITH:
	case GRID_SMITHGRID:
		break;

    	case GRID_YLOG:
        case GRID_LOGLOG:
        	drawloggrid(graph,
                	graph->grid.yaxis.log.units,
			graph->grid.yaxis.log.hmt,
                	graph->grid.yaxis.log.lmt,
                	graph->grid.yaxis.log.decsp,
                	graph->grid.yaxis.log.subs,
                	graph->grid.yaxis.log.pp, y_axis);
		break;
	default:
        	drawlingrid(graph,
                	graph->grid.yaxis.lin.units,
                	graph->grid.yaxis.lin.spacing,
                	graph->grid.yaxis.lin.numspace,
                	graph->grid.yaxis.lin.distance,
                	graph->grid.yaxis.lin.lowlimit,
                	graph->grid.yaxis.lin.highlimit,
                	graph->grid.yaxis.lin.onedec,
                	graph->grid.yaxis.lin.mult,
               		graph->grid.yaxis.lin.tenpowmag
               		/ graph->grid.yaxis.lin.tenpowmagx,
               		graph->grid.yaxis.lin.digits,
                	y_axis);
		break;
     }

}

/* Plot a linear grid. Returns the new hi and lo limits. */
static double *
lingrid(GRAPH *graph, double lo, double hi, double delta, int type, Axis axis)
{
    int mag, mag2, mag3;
    double hmt, lmt, dst;
    int nsp;
    double tenpowmag = 0.0, tenpowmag2, step, spacing;
    bool onedec = FALSE;
    int margin;
    int max;
    static double dd[2];
    int mult = 1;
    char buf[LABEL_CHARS], *s;
    int slim, digits;

    if (axis == y_axis && graph->grid.ysized) {
	lmt = graph->grid.yaxis.lin.lowlimit;
	hmt = graph->grid.yaxis.lin.highlimit;
	tenpowmag = graph->grid.yaxis.lin.tenpowmag;
	dd[0] = lmt * tenpowmag;
	dd[1] = hmt * tenpowmag;
	return dd;
    }

    if (axis == x_axis && graph->grid.xsized) {
	lmt = graph->grid.xaxis.lin.lowlimit;
	hmt = graph->grid.xaxis.lin.highlimit;
	tenpowmag = graph->grid.xaxis.lin.tenpowmag;
	dd[0] = lmt * tenpowmag;
	dd[1] = hmt * tenpowmag;
	return dd;
    }

    if (delta < 0.0) {
        fprintf(cp_err, "Warning: %cdelta is negative -- reversed\n",
                (axis == x_axis) ? 'x' : 'y');
        delta = -delta;
    }

    mag2 = floor(log10(fabs(hi - lo)));
    tenpowmag2 = pow(10.0, (double) mag2);

    /* Round lo down, and hi up */

    /* First, round lo _up_ and hi _down_ out to the 3rd digit of accuracy */
    lmt = (ceil(1000 * lo / tenpowmag2)) / 1000.0;
    hmt = (floor(1000 * hi / tenpowmag2 + 0.9)) / 1000.0;

    lmt = floor(10.0 * lmt) / 10.0;
    hmt = ceil(10.0 * hmt) / 10.0;

    lo = lmt * tenpowmag2;
    hi = hmt * tenpowmag2;

    if (fabs(hi) > fabs(lo))
    	mag = floor(log10(fabs(hi)));
    else
    	mag = floor(log10(fabs(lo)));

    if (mag >= 0)
	mag3 = ((int) (mag / 3)) * 3;
    else
	mag3 = - ((int) ((2 - mag) / 3)) * 3;

    if (scaleunits)
	digits = mag3 - mag2;
    else {
	digits = mag - mag2;
	mag3 = mag;
    }

    if (digits < 1)
	digits = 0;

    if (axis == x_axis) {
      margin = graph->viewportxoff;
      /*max = graph->viewport.width + graph->viewportxoff;*/
      max = graph->absolute.width - graph->viewportxoff;
    } else {
      graph->viewportxoff = (digits + 5 + mag - mag3) * graph->fontwidth;
      margin = graph->viewportyoff;
      /*max = graph->viewport.height + graph->viewportyoff;*/
      max = graph->absolute.height - graph->viewportyoff;
    }

    /* Express the difference between the high and low values as
     * diff = d * 10^mag. We know diff >= 0.0.  If scaleunits is
     * set then make sure that mag is modulo 3.
     */

    dst = hmt - lmt;

    /* We have to go from lmt to hmt, so think of some useful places
     * to put grid lines. We will have a total of nsp lines, one
     * every spacing pixels, which is every dst / nsp units.
     */

    if (scaleunits) {
	static char scaleletters[ ] = "afpnum\0kMGT";
	char	*p;
	int	i, j;

        tenpowmag = pow(10.0, (double) mag3);

	*buf = 0;

	i = (mag3 + 18) / 3;

	if (i < 0)
		i = 6; /* No scale units */
	else if (i >= sizeof(scaleletters) - 1) {
		/* sizeof includes '\0' at end, which is useless */
		/* i = sizeof(scaleletters) - 2; */
		i = 6; /* No scale units */
	}

	j = mag3 - i * 3 + 18;
	if (j == 1)
		(void) sprintf(buf, "x10 ");
	else if (j == 2)
		(void) sprintf(buf, "x100 ");
	else if (j)
		(void) sprintf(buf, "x10^%d ", j);

	if (scaleletters[i]) {
		for (p = buf; *p; p++)
			;
		*p++ = scaleletters[i];
		*p++ = 0;
	}

    } else if (mag > 1) {
        tenpowmag = pow(10.0, (double) mag);
	(void) sprintf(buf, "x10^%d ", mag);
    }

    if ((s = ft_typabbrev(type))) {
	(void) strcat(buf, s);
    } else {
	(void) strcat(buf, "Units");
    }

    if (delta == 0.0) {
	int	i;
	double	step;

	static struct { float div_lim, step; } div_list[ ] = {
		{ 100.0, 10.0 },
		{ 50.0, 5.0 },
		{ 20.0, 2.0 },
		{ 6.0, 1.0 },
		{ 3.0, 0.5 },
		{ 1.0, 0.2 },
		{ 0.5, 0.1 },
		{ 0.0, 0.05 },
		{ 0.0, 0.01 }
	};

	for (i = 0; i < NUMELEMS(div_list); i++) {
		if (dst > div_list[i].div_lim) {
			break;
		}
	}

	do {
		step = div_list[i].step;
		nsp = (dst + step - 0.0001) / step;
		spacing = (max - margin) / nsp;
		i += 1;
	} while (i < NUMELEMS(div_list) && spacing > 50);

	if (axis == x_axis) {
		slim = digits + 5 + mag - mag3;
	        slim = graph->fontwidth * (slim + 1);
	} else
	    slim = graph->fontheight * 3;

	while (i > 0 && spacing < slim + 3) {
		i -= 1;
		step = div_list[i].step;
		nsp = (dst + step - 0.0001) / step;
		spacing = (max - margin) / nsp;
	}

	if (lmt < 0)
		lmt = - ceil(-lmt / step) * step;
	else
		lmt = floor(lmt / step) * step;

	if (hmt < 0)
		hmt = - floor(-hmt / step) * step;
	else
		hmt = ceil(hmt / step) * step;

	dst = hmt - lmt;

	lo = lmt * tenpowmag2;
	hi = hmt * tenpowmag2;

	nsp = (dst + step - 0.0001) / step;

    } else {
	/* The user told us where to put the grid lines.  They will
	 * not be equally spaced in this case (i.e, the right edge
	 * won't be a line).
	 */
	nsp = (hi - lo) / delta;
	if (nsp > 100)
		nsp = 100;
	step = (max - margin) * delta / (hi - lo);
    }
    spacing = (max - margin) / nsp;

    dd[0] = lo;
    dd[1] = hi;

    /* Reset the max coordinate to deal with round-off error. */
    if (nsp && (delta == 0.0)) {
	if (axis == x_axis)
	    graph->viewport.width = spacing * nsp;
	else
	    graph->viewport.height = spacing * nsp;
    } else if (!nsp) {
	nsp = 1;
    }

    /* have to save non-intuitive variables left over
	from old algorithms for redraws */

    if (axis == x_axis) {
      graph->grid.xsized = 1;
      graph->grid.xaxis.lin.onedec = onedec;
      graph->grid.xaxis.lin.mult = mult;
      graph->grid.xaxis.lin.tenpowmag = tenpowmag2;
      graph->grid.xaxis.lin.tenpowmagx = tenpowmag;
      graph->grid.xaxis.lin.digits = digits;
      (void) strcpy(graph->grid.xaxis.lin.units, buf);
      graph->grid.xaxis.lin.distance = dst;
      graph->grid.xaxis.lin.lowlimit = lmt;
      graph->grid.xaxis.lin.highlimit = hmt;
      graph->grid.xaxis.lin.spacing = spacing;
      graph->grid.xaxis.lin.numspace = nsp;
    } else {
      graph->grid.ysized = 1;
      graph->grid.yaxis.lin.onedec = onedec;
      graph->grid.yaxis.lin.mult = mult;
      graph->grid.yaxis.lin.tenpowmag = tenpowmag2;
      graph->grid.yaxis.lin.tenpowmagx = tenpowmag;
      graph->grid.yaxis.lin.digits = digits;
      (void) strcpy(graph->grid.yaxis.lin.units, buf);
      graph->grid.yaxis.lin.distance = dst;
      graph->grid.yaxis.lin.lowlimit = lmt;
      graph->grid.yaxis.lin.highlimit = hmt;
      graph->grid.yaxis.lin.spacing = spacing;
      graph->grid.yaxis.lin.numspace = nsp;
    }

    return (dd);
}

/* PN static */
void
drawlingrid(GRAPH *graph, char *units, int spacing, int nsp, double dst, double lmt, double hmt, bool onedec, int mult, double mag, int digits, Axis axis)
{

    int i, j;
    double m, step;
    char buf[LABEL_CHARS];

    /* i counts how many pixels we have drawn, and j counts which unit
     * we are at.
     */
    SetLinestyle(1);
    step = floor((double) dst / nsp * 100.0 + 0.000001);
    for (i = 0, m = lmt * 100.0; m - 0.001 <= hmt * 100.0;
      i += spacing, m += step)
    {
	j = m;
        if (j == 0)
            SetLinestyle(0);
        if (graph->grid.gridtype != GRID_NONE) {
            if (axis == x_axis)
                DrawLine(graph->viewportxoff + i,
                  graph->viewportyoff, graph->viewportxoff + i,
                  graph->viewport.height + graph->viewportyoff);
            else
                DrawLine(graph->viewportxoff,
                  graph->viewportyoff + i,
                  graph->viewport.width + graph->viewportxoff,
                  graph->viewportyoff + i);
        }
        if (j == 0)
            SetLinestyle(1);

	(void) sprintf(buf, "%.*f", digits + 1, m * mag / 100.0);