** EZPLOT
**
** This is part of the CTSim program
-** Copyright (C) 1983-2000 Kevin Rosenberg
+** Copyright (c) 1983-2001 Kevin Rosenberg
**
-** $Id: ezplot.cpp,v 1.9 2000/07/29 19:50:08 kevin Exp $
+** $Id: ezplot.cpp,v 1.31 2001/02/20 04:48:45 kevin Exp $
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License (version 2) as
#include "ezplot.h"
#include <algorithm>
+#ifdef __GNUWIN32__
+int snprintf (char *, size_t, const char*, ...);
+#endif
// Defaults
static const double TICKRATIO = 0.4; // ratio of minor to major tick lengths
static const int MAXNUMFMT = 15; // maximum length of a numeric format
-static const double DEF_CHARHEIGHT = (1./43.); //size of characters in NDC
-static const double DEF_CHARWIDTH = (1./80.); // size of characters in NDC
static const int DEF_CURVE_CLR = C_RED;
-
-EZPlotCurve::EZPlotCurve (const double* xData, const double* yData, int n, int color, int linestyle, int symbol, int symfreq, const string& legend)
- : x(NULL), y(NULL), m_sLegend (legend)
+EZPlotCurve::EZPlotCurve (const double* xData, const double* yData, int n)
+: x(new double[n]), y(new double[n])
{
- x = new double [n];
- y = new double [n];
-
- int copyCount = n * sizeof(double);
- memcpy (x, xData, copyCount);
- memcpy (y, yData, copyCount);
-
+ for (int i = 0; i < n; i++) {
+ x[i] = xData[i];
+ y[i] = yData[i];
+ }
+
m_iPointCount = n;
- m_iColor = color;
- m_iLineStyle = linestyle;
- m_iSymbol = symbol;
- m_iSymbolFreq = symfreq;
}
EZPlotCurve::~EZPlotCurve ()
void
EZPlot::addCurve (const double *y, int n)
{
- double x [n];
-
+ double* x = new double [n];
+
for (int i = 0; i < n; i++)
x[i] = i;
-
+
addCurve (x, y, n);
+ delete x;
+}
+
+
+void
+EZPlot::addCurve (const float *y, int n)
+{
+ double* yDouble = new double [n];
+
+ for (int i = 0; i < n; i++)
+ yDouble[i] = y[i];
+
+ addCurve (yDouble, n);
+ delete yDouble;
}
void
EZPlot::addCurve (const float x[], const double y[], int num)
{
- double dx [num];
-
+ double* dx = new double [num];
+
for (int i = 0; i < num; i++)
dx[i] = x[i];
-
+
addCurve (dx, y, num);
+ delete dx;
}
void
-EZPlot::addCurve (const double x[], const float y[], int num)
+EZPlot::addCurve (const double* const x, const float* const y, int num)
{
- double dy [num];
-
+ double* dy = new double [num];
+
for (int i = 0; i < num; i++)
dy[i] = y[i];
-
+
addCurve (x, dy, num);
+
+ delete dy;
}
void
-EZPlot::addCurve (const double x[], const double y[], int num)
+EZPlot::addCurve (const double* const x, const double* const y, int num)
{
if (num < 1)
return;
-
- EZPlotCurve* pCurve = new EZPlotCurve (x, y, num, o_color, o_linestyle, o_symbol, o_symfreq, c_legend);
+
+ EZPlotCurve* pCurve = new EZPlotCurve (x, y, num);
m_vecCurves.push_back (pCurve);
}
}
-EZPlot::EZPlot (SGP& sgp)
- : rSGP (sgp)
+EZPlot::EZPlot ()
{
+ initKeywords();
+
+ m_pol.addSkipWord ("please");
+
+ m_pol.addSkipWord ("use");
+
+ m_pol.addSkipWord ("are");
+
+ m_pol.addSkipWord ("and");
+
+ m_pol.addSkipWord ("is");
+
+ m_pol.addSkipWord ("the");
+
+ m_pol.addSkipWord ("equals");
+
+ m_pol.addSkipChar ('=');
+
+
+
+ m_pol.usefile (POL::P_USE_STR,"");
+
+ m_pol.set_inputline ("!eoc ,");
+
+ m_pol.reader ();
+
+ m_pol.closefile ();
+
+
+
initPlotSettings();
}
void
EZPlot::initPlotSettings ()
{
- charwidth = DEF_CHARWIDTH;
- charheight = DEF_CHARHEIGHT;
-
+ m_iCurrentCurve = -1;
+
+ m_pSGP = NULL;
+
+
c_xlabel = "";
c_ylabel = "";
c_title = "";
- c_legend = "";
o_xporigin = 0.0;
o_yporigin = 0.0;
s_ylegend = FALSE;
s_textsize = FALSE;
- clr_axis = C_BLACK; /* set fixed colors */
- clr_title = C_CYAN;
- clr_label = C_CYAN;
- clr_legend = C_RED;
+ clr_axis = C_LTGRAY; // set fixed colors
+ clr_title = C_RED;
+ clr_label = C_BLUE;
+ clr_legend = C_CYAN;
clr_number = C_GREEN;
clr_grid = C_LTGRAY;
}
+void
+
+EZPlot::setColor (unsigned int iCurve, int iColor)
+
+{
+
+ if (m_veciColor.size() <= iCurve) {
+
+ m_veciColor.resize ((m_iCurrentCurve + 1) * 2);
+
+ m_vecbColorSet.resize ((m_iCurrentCurve + 1) * 2);
+
+ }
+
+ m_veciColor [iCurve] = iColor;
+
+ m_vecbColorSet [iCurve] = true;
+
+}
+
+
+
+void
+
+EZPlot::setSymbol (unsigned int iCurve, int iSymbol)
+
+{
+
+ if (m_veciSymbol.size() <= iCurve) {
+
+ m_veciSymbol.resize ((m_iCurrentCurve + 1) * 2);
+
+ m_vecbSymbolSet.resize ((m_iCurrentCurve + 1) * 2);
+
+ }
+
+ m_veciSymbol [iCurve] = iSymbol;
+
+ m_vecbSymbolSet [iCurve] = true;
+
+}
+
+
+
+void
+
+EZPlot::setSymbolFreq (unsigned int iCurve, int iSymbolFreq)
+
+{
+
+ if (m_veciSymbolFreq.size() <= iCurve) {
+
+ m_veciSymbolFreq.resize ((m_iCurrentCurve + 1) * 2);
+
+ m_vecbSymbolFreqSet.resize ((m_iCurrentCurve + 1) * 2);
+
+ }
+
+ m_veciSymbolFreq [iCurve] = iSymbolFreq;
+
+ m_vecbSymbolFreqSet [iCurve] = true;
+
+}
+
+
+
+void
+
+EZPlot::setLinestyle (unsigned int iCurve, int iLinestyle)
+
+{
+
+ if (m_veciLinestyle.size() <= iCurve) {
+
+ m_veciLinestyle.resize ((m_iCurrentCurve + 1) * 2);
+
+ m_vecbLinestyleSet.resize ((m_iCurrentCurve + 1) * 2);
+
+ }
+
+ m_veciLinestyle [iCurve] = iLinestyle;
+
+ m_vecbLinestyleSet [iCurve] = true;
+
+}
+
+
+
+void
+
+EZPlot::setLegend (unsigned int iCurve, const std::string& strLegend)
+
+{
+
+ if (m_vecsLegend.size() <= iCurve) {
+
+ m_vecsLegend.resize ((m_iCurrentCurve + 1) * 2);
+
+ m_vecbLegendSet.resize ((m_iCurrentCurve + 1) * 2);
+
+ }
+
+ m_vecsLegend [iCurve] = strLegend;
+
+ m_vecbLegendSet [iCurve] = true;
+
+}
+
+
+
+void
+
+EZPlot::setLegend (unsigned int iCurve, const char* const pszLegend)
+
+{
+
+ if (m_vecsLegend.size() <= iCurve) {
+
+ m_vecsLegend.resize ((m_iCurrentCurve + 1) * 2);
+
+ m_vecbLegendSet.resize ((m_iCurrentCurve + 1) * 2);
+
+ }
+
+ m_vecsLegend [iCurve] = pszLegend;
+
+ m_vecbLegendSet [iCurve] = true;
+
+}
+
+
+
+int
+
+EZPlot::getColor (unsigned int iCurve) const
+
+{
+
+ if (m_veciColor.size() > iCurve && m_vecbColorSet[iCurve])
+
+ return m_veciColor[iCurve];
+
+ else
+
+ return o_color;
+
+}
+
+
+
+int
+
+EZPlot::getSymbol (unsigned int iCurve) const
+
+{
+
+ if (m_veciSymbol.size() > iCurve && m_vecbSymbolSet[iCurve])
+
+ return m_veciSymbol[iCurve];
+
+ else
+
+ return o_symbol;
+
+}
+
+
+
+int
+
+EZPlot::getSymbolFreq (unsigned int iCurve) const
+
+{
+
+ if (m_veciSymbolFreq.size() > iCurve && m_vecbSymbolFreqSet[iCurve])
+
+ return m_veciSymbolFreq[iCurve];
+
+ else
+
+ return o_symfreq;
+
+}
+
+
+
+int
+
+EZPlot::getLinestyle (unsigned int iCurve) const
+
+{
+
+ if (m_veciLinestyle.size() > iCurve && m_vecbLinestyleSet[iCurve])
+
+ return m_veciLinestyle[iCurve];
+
+ else
+
+ return o_linestyle;
+
+}
+
+
+
+const std::string*
+
+EZPlot::getLegend (unsigned int iCurve) const
+
+{
+
+ if (m_vecsLegend.size() > iCurve && m_vecbLegendSet[iCurve])
+
+ return &m_vecsLegend[iCurve];
+
+ else
+
+ return NULL;
+
+}
+
+
+
+
/* NAME
- * plot Plots all curves collected by addCurves ()
- *
- * SYNOPSIS
- * plot()
- *
- * DESCRIPTION
- * This routine plots the curves that have stored by addCurves().
- *
- * CALLS
- * drawAxes() & make_numfmt()
- */
+* plot Plots all curves collected by addCurves ()
+*
+* SYNOPSIS
+* plot()
+*
+* DESCRIPTION
+* This routine plots the curves that have stored by addCurves().
+*
+* CALLS
+* drawAxes() & make_numfmt()
+*/
void
-EZPlot::plot ()
+EZPlot::plot (SGP* pSGP)
{
- double x_added_ticks; /* number of tick spaces added to axis */
- double y_added_ticks;
- double symwidth, symheight; /* size of symbol in NDC */
- double leg_width, leg_height; /* size of legend box */
- int i, j, ip, n;
-
+
if (m_vecCurves.size() <= 0)
return;
- if (s_textsize == TRUE)
- charheight = v_textsize;
- else
- charheight = DEF_CHARHEIGHT;
+
+ m_pSGP = pSGP;
+
+
+ m_pSGP->setWindow (0., 0., 1., 1.);
+ if (s_textsize == TRUE)
+ m_pSGP->setTextPointSize (v_textsize);
+
+ charheight = m_pSGP->getCharHeight();
+ charwidth = m_pSGP->getCharWidth();
+
const EZPlotCurve& firstCurve = *m_vecCurves[0];
+
double xmin = firstCurve.x[0]; // extent of curves in world coord
double xmax = xmin;
double ymin = firstCurve.y[0];
- double ymax = ymin;
-
- for (EZPlotCurveConstIterator iterCurve = m_vecCurves.begin(); iterCurve != m_vecCurves.end(); iterCurve++) {
- const EZPlotCurve& curve = **iterCurve;
-
- for (ip = 0; ip < curve.m_iPointCount; ip++) {
- if (curve.x[ip] > xmax)
- xmax = curve.x[ip];
- else if (curve.x[ip] < xmin)
- xmin = curve.x[ip];
- if (curve.y[ip] > ymax)
- ymax = curve.y[ip];
- else if (curve.y[ip] < ymin)
- ymin = curve.y[ip];
+ double ymax = ymin;
+
+ unsigned int iCurve;
+ for (iCurve = 0; iCurve < m_vecCurves.size(); iCurve++) {
+ const EZPlotCurve* const pCurve = m_vecCurves [iCurve];
+
+ for (int ip = 0; ip < pCurve->m_iPointCount; ip++) {
+ if (pCurve->x[ip] > xmax)
+ xmax = pCurve->x[ip];
+ else if (pCurve->x[ip] < xmin)
+ xmin = pCurve->x[ip];
+ if (pCurve->y[ip] > ymax)
+ ymax = pCurve->y[ip];
+ else if (pCurve->y[ip] < ymin)
+ ymin = pCurve->y[ip];
}
}
else if (v_xcross > xmax)
xmax = v_xcross;
}
-
+
if (s_ycross == TRUE) {
if (v_ycross < ymin)
ymin = v_ycross;
else if (v_ycross > ymax)
ymax = v_ycross;
}
-
- /* find nice endpoints for axes */
- axis_scale (xmin, xmax, o_xmajortick - 1, &xgw_min, &xgw_max, &x_nint);
- axis_scale (ymin, ymax, o_ymajortick - 1, &ygw_min, &ygw_max, &y_nint);
-
- /* check if user set x-axis extents */
+
+ // find nice endpoints for axes
+ if (! axis_scale (xmin, xmax, o_xmajortick - 1, &xgw_min, &xgw_max, &x_nint) || ! axis_scale (ymin, ymax, o_ymajortick - 1, &ygw_min, &ygw_max, &y_nint))
+ return;
+
+ // check if user set x-axis extents
if (s_xmin == TRUE) {
xgw_min = v_xmin;
x_nint = o_xmajortick - 1;
x_nint = o_xmajortick - 1;
}
- /* check if user set y-axis extents */
+ // check if user set y-axis extents
if (s_ymin == TRUE) {
ygw_min = v_ymin;
y_nint = o_ymajortick - 1;
ygw_max = v_ymax;
y_nint = o_ymajortick - 1;
}
-
- /* calculate increment between major axis in world coordinates */
+
+ // calculate increment between major axis in world coordinates
xw_tickinc = (xgw_max - xgw_min) / x_nint;
yw_tickinc = (ygw_max - ygw_min) / y_nint;
-
- /* we have now calcuated xgw_min, xyw_max, ygw_min, & ygw_max */
+
+ // we have now calcuated xgw_min, xyw_max, ygw_min, & ygw_max
// set the number of decimal point to users' setting or default
// Two formats for numbers: Fixed: -nnn.f and Exponent: -n.fffE+eee
x_frac = v_lxfrac;
else
x_frac = -1;
-
+
if (s_lyfrac == TRUE)
y_frac = v_lyfrac;
else
y_frac = -1;
-
+
make_numfmt (x_numfmt, &x_fldwid, &x_frac, xgw_min, xgw_max, x_nint);
make_numfmt (y_numfmt, &y_fldwid, &y_frac, ygw_min, ygw_max, y_nint);
-
- xtl_wid = x_fldwid * charwidth; /* calc size of tick labels */
+
+ xtl_wid = x_fldwid * charwidth; // calc size of tick labels
ytl_wid = y_fldwid * charwidth;
tl_height = charheight;
- /* calculate the extent of the plot frame */
+ // calculate the extent of the plot frame
xp_min = o_xporigin;
yp_min = o_yporigin;
xp_max = xp_min + o_xlength;
yp_max = yp_min + o_ylength;
-
+
xp_min = clamp (xp_min, 0., 1.);
xp_max = clamp (xp_max, 0., 1.);
yp_min = clamp (yp_min, 0., 1.);
yp_max = clamp (yp_max, 0., 1.);
- xa_min = xp_min; /* extent of axes */
+ xa_min = xp_min; // extent of axes
xa_max = xp_max;
ya_min = yp_min;
ya_max = yp_max;
-
- /* adjust frame for title */
+
+ // adjust frame for title
+ title_row = ya_max;;
+
if (c_title.length() > 0)
- ya_max -= 2.5 * charheight;
- title_row = ya_max + 0.5 * charheight;
-
- /* calculate legend box boundaries */
- int max_leg = 0; /* longest legend in characters */
- int num_leg = 0; /* number of legend titles */
- for (EZPlotCurveConstIterator iterCurve = m_vecCurves.begin(); iterCurve != m_vecCurves.end(); iterCurve++) {
- const EZPlotCurve& curve = **iterCurve;
- if ((n = curve.m_sLegend.length()) > 0) {
- ++num_leg;
- max_leg = max (max_leg, n);
+ ya_max -= 2 * charheight;
+
+ else
+
+ ya_max -= 0.7 * charheight; // allow room for yaxis ticklabel
+
+
+ // calculate legend box boundaries
+ int max_leg = 0; // longest legend in characters
+ int num_leg = 0; // number of legend titles
+
+ for (iCurve = 0; iCurve < m_vecCurves.size(); iCurve++) {
+ const std::string* pstrLegend = getLegend (iCurve);
+
+ if (pstrLegend && pstrLegend->length() > 0) {
+
+ int nLegend = pstrLegend->length();
+ if (nLegend > 0) {
+ ++num_leg;
+ if (nLegend > max_leg)
+
+ nLegend = max_leg;
+
+ }
}
}
-
+
if (num_leg > 0 && o_legendbox != NOLEGEND) {
- leg_width = (max_leg + 2) * charwidth;
- leg_height = num_leg * 3 * charheight;
+ double leg_width = (max_leg + 2) * charwidth; // size of legend box
+ double leg_height = num_leg * 3 * charheight;
if (s_xlegend == TRUE)
xl_max = v_xlegend;
else {
xl_max = xa_max;
if (o_legendbox == OUTSIDE)
- xa_max -= (leg_width + 0.5 * charwidth);
+ xa_max -= (leg_width + 0.5 * charwidth);
}
xl_min = xl_max - leg_width;
yl_max = ya_max;
yl_min = yl_max - leg_height;
+
+ m_pSGP->setColor (clr_legend);
+ m_pSGP->drawRect (xl_min, yl_min, xl_max, yl_max);
+
+ int iLegend = 0; // current legend position
+
+ for (iCurve = 0; iCurve < m_vecCurves.size(); iCurve++) {
+ const std::string* pstrLegend = getLegend (iCurve);
+ if (! pstrLegend || pstrLegend->length() == 0)
+ continue;
+
+ double xmin = xl_min + 1.0 * charwidth;
+ double xmax = xl_max - 1.0 * charwidth;
+ double y = yl_max - (2.0 + iLegend * 3) * charheight;
+
+ m_pSGP->moveAbs (xmin, y + 0.5 * charheight);
+
+ m_pSGP->drawText (pstrLegend->c_str());
+ m_pSGP->setColor (getColor (iCurve));
+
+ int iLS = getLinestyle (iCurve);
+ if (iLS != SGP::LS_NOLINE) {
+ m_pSGP->setLineStyle (iLS);
+ m_pSGP->moveAbs (xmin, y);
+ m_pSGP->lineAbs (xmax, y);
+ }
- rSGP.setWindow (xl_min, yl_min, xl_max, yl_max);
- rSGP.setViewport (xl_min, yl_min, xl_max, yl_max);
- rSGP.setColor (clr_legend);
- rSGP.drawRect (xl_min, yl_min, xl_max, yl_max);
-
- n = 0; /* current legend position */
- for (EZPlotCurveIterator iterCurve = m_vecCurves.begin(); iterCurve != m_vecCurves.end(); iterCurve++) {
- const EZPlotCurve& curve = **iterCurve;
-
- if (curve.m_sLegend.length() == 0)
- continue;
-
- double xmin = xl_min + 1.0 * charwidth;
- double xmax = xl_max - 1.0 * charwidth;
- double y = yl_max - (2.0 + n * 3) * charheight;
-
- rSGP.moveAbs (xmin, y + 0.5 * charheight);
- rSGP.drawText (curve.m_sLegend);
- rSGP.setColor (curve.m_iColor);
- if (curve.m_iLineStyle != SGP::LS_NOLINE) {
- rSGP.setLineStyle (curve.m_iLineStyle);
- rSGP.moveAbs (xmin, y);
- rSGP.lineAbs (xmax, y);
- }
- if (curve.m_iSymbol > 0) {
- double xinc = (xmax - xmin) / (5 - 1);
- rSGP.setLineStyle (SGP::LS_SOLID);
- for (j = 0; j < 5; j++) {
- rSGP.moveAbs (xmin + j * xinc, y);
- symbol(curve.m_iSymbol, 0.5 * charwidth, 0.5 * charheight);
- }
+ int iSymbol = getSymbol (iCurve);
+ if (iSymbol > 0) {
+ double xinc = (xmax - xmin) / (5 - 1);
+ m_pSGP->setLineStyle (SGP::LS_SOLID);
+ for (int j = 0; j < 5; j++) {
+ m_pSGP->moveAbs (xmin + j * xinc, y);
+ symbol(iSymbol, 0.5 * charwidth, 0.5 * charheight);
+ }
}
- ++n; /* move to next legend position */
+ ++iLegend; // move to next legend position
}
- } /* end legend printing */
-
- /* calculate the extent of the axes */
-
+ } // end legend printing
+
+ // calculate the extent of the axes
+
/*-------------------------*/
/* adjust frame for labels */
/*-------------------------*/
- /* x-label */
+ // X-Label
if (c_xlabel.length() > 0)
- ya_min += 3.0 * charheight;
- xlbl_row = xp_min; /* put x-label on bottom of plot frame */
+ ya_min += 1.5 * charheight;
+ xlbl_row = xp_min; // put x-label on bottom of plot frame
+
+ // Y-Label
+ if (c_ylabel.length() > 0) {
+
+ m_pSGP->setTextAngle (HALFPI);
- /* y-label */
- if (c_ylabel.length() > 0)
- xa_min += 3.0 * charwidth; /* reverse rSGP.setTextSize because writing text sideways */
- ylbl_col = xp_min + 2 * charwidth;
+ m_pSGP->setTextSize (1.5 * charheight);
+ double xExtent, yExtent;
+
+ m_pSGP->getTextExtent (c_ylabel.c_str(), &xExtent, &yExtent);
+
+ m_pSGP->setTextSize (charheight);
+
+ xa_min += xExtent;
+
+ m_pSGP->setTextAngle (0.0);
+
+ }
+ ylbl_col = xp_min;
+
/*------------------------------*/
/* adjust frame for tick labels */
/*------------------------------*/
-
- /* calc offset of tick labels from axes */
+
+ // Calc offset of tick labels from axes
if (o_xaxis == NOAXIS || o_xtlabel == FALSE)
xtl_ofs = 0.0;
else if (o_xticks == BELOW)
- xtl_ofs = -2.5 * charheight;
+ xtl_ofs = -0.5 * charheight;
else if (o_xticks == ABOVE)
- xtl_ofs = 1.5 * charheight;
+ xtl_ofs = 0.5 * charheight;
if (o_yaxis == NOAXIS || o_ytlabel == FALSE)
ytl_ofs = 0.0;
- else if (o_yticks == LEFT)
- ytl_ofs = -(1 + y_fldwid) * charwidth;
- else if (o_yticks == RIGHT)
+ else if (o_yticks == LEFT) {
+ double xExtentMin, xExtentMax, yExtent;
+ char s[1024];
+ snprintf (s, sizeof(s), y_numfmt, ymin);
+ m_pSGP->getTextExtent (s, &xExtentMin, &yExtent);
+ snprintf (s, sizeof(s), y_numfmt, ymax);
+ m_pSGP->getTextExtent (s, &xExtentMax, &yExtent);
+ if (xExtentMin > xExtentMax)
+ xExtentMax = xExtentMin;
+ ytl_ofs = -xExtentMax;
+ } else if (o_yticks == RIGHT)
ytl_ofs = 1.5 * charwidth;
+
+ xa_max -= 0.7 * x_fldwid * charwidth; // make room for last x tick label
- /* see if need to shrink axis extents and/or tick extents */
+ xt_min = xa_min;
+ yt_min = ya_min;
+ xt_max = xa_max;
+ yt_max = ya_max;
+
+ // see if need to shrink axis extents and/or tick extents
if (xtl_ofs != 0.0 && s_ycross == FALSE) {
if (o_xticks == BELOW) {
- ya_min += 2.5 * charheight;
+ ya_min += 1.5 * charheight;
yt_min = ya_min;
} else if (o_xticks == ABOVE) {
ya_min += 0.0;
- yt_min = ya_min + 2.5 * charheight;
+ yt_min = ya_min + 1.5 * charheight;
}
- } else /* noaxis, no t-labels, or user set cross */
+ } else // noaxis, no t-labels, or user set cross
yt_min = ya_min;
if (ytl_ofs != 0.0 && s_xcross == FALSE) {
if (o_yticks == LEFT) {
- xa_min += (1 + y_fldwid) * charwidth;
+ xa_min += 2*charwidth - ytl_ofs; // (2 + y_fldwid) * charwidth;
xt_min = xa_min;
} else if (o_yticks == RIGHT) {
xa_min += 0.0;
- xt_min = xa_min + ytl_ofs + y_fldwid * charwidth;
+ xt_min = xa_min + ytl_ofs; // + y_fldwid * charwidth;
}
} else
xt_min = xa_min;
- xt_max = xa_max;
- yt_max = ya_max;
-
- /* decrease size of graph, if necessary, to accommadate space */
- /* between axis boundary and boundary of ticks */
-
- x_added_ticks = -1;
- y_added_ticks = -1;
-
+ // decrease size of graph, if necessary, to accommadate space
+ // between axis boundary and boundary of ticks
+ double x_added_ticks = 0; // number of tick spaces added to axis
+ double y_added_ticks = 0;
if (o_xaxis == NOAXIS || o_xtlabel == FALSE)
x_added_ticks = 0;
if (o_yaxis == NOAXIS || o_ytlabel == FALSE)
xgn_max = xt_max;
ygn_min = yt_min;
ygn_max = yt_max;
-
- /*---------------------------------------------------------------------------*/
- /* PLOT CURVES */
+ //------------------------------------------------------------------------
+
+ m_xWorldScale = (xgn_max - xgn_min) / (xgw_max - xgw_min);
+ m_yWorldScale = (ygn_max - ygn_min) / (ygw_max - ygw_min);
+
+ // PLOT CURVES
- rSGP.setLineStyle (SGP::LS_SOLID);
+ m_pSGP->setLineStyle (SGP::LS_SOLID);
drawAxes();
+
+ // size of symbol in NDC
+ double symwidth = charwidth;
+ double symheight = charheight;
+
- /* Convert WC in graph boundary to axis boundary */
- rSGP.setWindow (xgw_min, ygw_min, xgw_max, ygw_max); /* Graph boundary */
- rSGP.setViewport (xgn_min, ygn_min, xgn_max, ygn_max);
- double xminTemp = xa_min, xmaxTemp = xa_max;
- double yminTemp = ya_min, ymaxTemp = ya_max;
- rSGP.transformNDCtoMC (&xminTemp, &yminTemp); // calc WC to axis boundaries
- rSGP.transformNDCtoMC (&xmaxTemp, &ymaxTemp);
- rSGP.setWindow (xminTemp, yminTemp, xmaxTemp, ymaxTemp); // Set window to axis boundaries
- rSGP.setViewport (xa_min, ya_min, xa_max, ya_max);
-
- symwidth = charwidth * (xgw_max - xgw_min);
- symheight = charheight * (ygw_max - ygw_min);
-
- for (EZPlotCurveIterator iterCurve = m_vecCurves.begin(); iterCurve != m_vecCurves.end(); iterCurve++) {
- const EZPlotCurve& curve = **iterCurve;
-
- rSGP.setColor (curve.m_iColor);
- if (curve.m_iLineStyle != SGP::LS_NOLINE) {
- rSGP.setLineStyle (curve.m_iLineStyle);
- rSGP.polylineAbs (curve.x, curve.y, curve.m_iPointCount);
- }
- if (curve.m_iSymbol > 0) {
- rSGP.setLineStyle (SGP::LS_SOLID);
- rSGP.moveAbs (curve.x[0], curve.y[0]);
- symbol (curve.m_iSymbol, symwidth, symheight);
- for (i = 1; i < curve.m_iPointCount; i++)
- if (i % curve.m_iSymbolFreq == 0 || i == curve.m_iPointCount - 1) {
- rSGP.moveAbs (curve.x[i], curve.y[i]);
- symbol (curve.m_iSymbol, symwidth, symheight);
- }
- }
- }
+ double clipRect[4];
+
+ clipRect[0] = xgn_min; clipRect[1] = ygn_min; clipRect[2] = xgn_max; clipRect[3] = ygn_max;
+
+
+
+ for (iCurve = 0; iCurve < m_vecCurves.size(); iCurve++) {
+ const EZPlotCurve* const pCurve = m_vecCurves [iCurve];
+
+
+ m_pSGP->setColor (getColor (iCurve));
+
+ int iSym = getSymbol (iCurve);
+
+ int iLS = getLinestyle (iCurve);
+
+
+
+ if (iLS != SGP::LS_NOLINE) {
+ m_pSGP->setLineStyle (iLS);
+ double x1 = convertWorldToNDC_X (pCurve->x[0]);
+ double y1 = convertWorldToNDC_Y (pCurve->y[0]);
+
+ for (int i = 1; i < pCurve->m_iPointCount; i++) {
+ double x2 = convertWorldToNDC_X (pCurve->x[i]);
+ double y2 = convertWorldToNDC_Y (pCurve->y[i]);
+
+ double x2Clip = x2;
+
+ double y2Clip = y2;
+
+ if (clip_rect (x1, y1, x2Clip, y2Clip, clipRect)) {
+
+ m_pSGP->moveAbs (x1, y1);
+
+ m_pSGP->lineAbs (x2Clip, y2Clip);
+
+ }
+
+ x1 = x2;
+
+ y1 = y2;
+
+ }
+ }
+ if (iSym > 0) {
+
+ int iSymFreq = getSymbolFreq (iCurve);
+ m_pSGP->setLineStyle (SGP::LS_SOLID);
+ double x = convertWorldToNDC_X (pCurve->x[0]);
+ double y = convertWorldToNDC_Y (pCurve->y[0]);
+ m_pSGP->moveAbs (x, y);
+ symbol (iSym, symwidth, symheight);
+ for (int i = 1; i < pCurve->m_iPointCount; i++)
+ if (i % iSymFreq == 0 || i == pCurve->m_iPointCount - 1) {
+ x = convertWorldToNDC_X (pCurve->x[i]);
+ y = convertWorldToNDC_Y (pCurve->y[i]);
+
+ if (y >= ygn_min && y <= ygn_max) {
+ m_pSGP->moveAbs (x, y);
+ symbol (iSym, symwidth, symheight);
+
+ }
+ }
+ }
+ }
}
/* NAME
- * drawAxes INTERNAL routine to draw axis & label them
- *
- * SYNOPSIS
- * drawAxes()
- */
+* drawAxes INTERNAL routine to draw axis & label them
+*
+* SYNOPSIS
+* drawAxes()
+*/
void
-EZPlot::drawAxes(void)
+EZPlot::drawAxes()
{
- double xticklen = 0, yticklen = 0; /* length of ticks in NDC */
- double minorinc; /* increment between minor axes */
- double xaxispos, yaxispos; /* crossing of axes */
+ double xticklen = 0, yticklen = 0; // length of ticks in NDC
+ double minorinc; // increment between minor axes
+ double xaxispos, yaxispos; // crossing of axes
double x, y, x2, y2;
- bool axis_near; /* TRUE if axis too close to print t-label */
+ bool axis_near; // TRUE if axis too close to print t-label
int i, j;
- char str[100];
+ char str[256];
char *numstr;
- rSGP.setTextSize (charheight);
- rSGP.setTextColor (1, -1);
+ m_pSGP->setTextSize (charheight);
+ m_pSGP->setTextColor (1, -1);
if (o_xticks == ABOVE)
- xticklen = charheight;
+ xticklen = 0.5 * charheight;
else if (o_xticks == BELOW)
- xticklen = -charheight;
+ xticklen = -0.5 * charheight;
if (o_yticks == RIGHT)
yticklen = charwidth;
else if (o_yticks == LEFT)
yticklen = -charwidth;
- rSGP.setWindow (xp_min, yp_min, xp_max, yp_max);
- rSGP.setViewport (xp_min, yp_min, xp_max, yp_max);
-
if (c_title.length() > 0) {
- rSGP.moveAbs (xa_min + (xa_max-xa_min)/2 - c_title.length()*charwidth, title_row);
- rSGP.setTextSize (charheight * 2.0);
- rSGP.setTextColor (clr_title, -1);
- rSGP.drawText (c_title);
- rSGP.setTextSize (charheight);
+ double wText, hText;
+ m_pSGP->setTextSize (charheight * 2.0);
+ m_pSGP->getTextExtent (c_title.c_str(), &wText, &hText);
+ m_pSGP->moveAbs (xa_min + (xa_max-xa_min)/2 - wText/2, title_row);
+ m_pSGP->setTextColor (clr_title, -1);
+ m_pSGP->drawText (c_title);
+ m_pSGP->setTextSize (charheight);
}
if (o_grid == TRUE || o_box == TRUE) {
- rSGP.setColor (clr_axis);
- rSGP.moveAbs (xa_min, ya_min);
- rSGP.lineAbs (xa_max, ya_min);
- rSGP.lineAbs (xa_max, ya_max);
- rSGP.lineAbs (xa_min, ya_max);
- rSGP.lineAbs (xa_min, ya_min);
+ m_pSGP->setColor (clr_axis);
+ m_pSGP->moveAbs (xa_min, ya_min);
+ m_pSGP->lineAbs (xa_max, ya_min);
+ m_pSGP->lineAbs (xa_max, ya_max);
+ m_pSGP->lineAbs (xa_min, ya_max);
+ m_pSGP->lineAbs (xa_min, ya_min);
}
- /* calculate position of axes */
+ // calculate position of axes
- /* x-axis */
- if (s_ycross == TRUE) { /* convert users' world-coord */
- xaxispos = v_ycross; /* axis to its position in NDC */
- rSGP.setWindow (xgw_min, ygw_min, xgw_max, ygw_max);
- rSGP.setViewport (xgn_min, ygn_min, xgn_max, ygn_max);
- x = xgw_min;
- rSGP.transformMCtoNDC (x, xaxispos, &x, &xaxispos);
+ // x-axis
+ if (s_ycross == TRUE) { // convert users' world-coord
+ xaxispos = convertWorldToNDC_Y (v_ycross);// axis to its position in NDC
+ x = convertWorldToNDC_X (xgw_min);
} else
xaxispos = ya_min;
- /* y-axis */
- if (s_xcross == TRUE) { /* convert users' world-coord */
- yaxispos = v_xcross; /* axis to its NDC position */
- rSGP.setWindow (xgw_min, ygw_min, xgw_max, ygw_max);
- rSGP.setViewport (xgn_min, ygn_min, xgn_max, ygn_max);
- y = ygw_min;
- rSGP.transformMCtoNDC (yaxispos, y, &yaxispos, &y);
+ // y-axis
+ if (s_xcross == TRUE) { // convert users' world-coord
+ yaxispos = convertWorldToNDC_X (v_xcross);// axis to its NDC position
+ y = convertWorldToNDC_Y (ygw_min);
} else
yaxispos = xa_min;
/*-------------*/
if (o_xaxis == LINEAR) {
- rSGP.setWindow (xp_min, yp_min, xp_max, yp_max);
- rSGP.setViewport (xp_min, yp_min, xp_max, yp_max);
-
- /* draw axis line */
+ // draw axis line
- rSGP.setColor (clr_axis);
+ m_pSGP->setColor (clr_axis);
if (o_tag && !o_grid && !o_box && s_xcross) {
- rSGP.moveAbs (xa_min, xaxispos - charheight);
- rSGP.lineAbs (xa_min, xaxispos + charheight);
+ m_pSGP->moveAbs (xa_min, xaxispos - charheight);
+ m_pSGP->lineAbs (xa_min, xaxispos + charheight);
}
- rSGP.moveAbs (xa_min, xaxispos);
- rSGP.lineAbs (xa_max, xaxispos);
+ m_pSGP->moveAbs (xa_min, xaxispos);
+ m_pSGP->lineAbs (xa_max, xaxispos);
if (o_tag && !o_grid && !o_box) {
- rSGP.moveAbs (xa_max, xaxispos - charheight);
- rSGP.lineAbs (xa_max, xaxispos + charheight);
+ m_pSGP->moveAbs (xa_max, xaxispos - charheight);
+ m_pSGP->lineAbs (xa_max, xaxispos + charheight);
}
if (o_grid == TRUE) {
- rSGP.setColor (clr_grid);
+ m_pSGP->setColor (clr_grid);
for (i = 0; i <= x_nint; i++) {
- rSGP.moveAbs (xt_min + xn_tickinc * i, ya_max);
- rSGP.lineAbs (xt_min + xn_tickinc * i, ya_min);
+ m_pSGP->moveAbs (xt_min + xn_tickinc * i, ya_max);
+ m_pSGP->lineAbs (xt_min + xn_tickinc * i, ya_min);
}
}
- rSGP.moveAbs (xa_min + (xa_max-xa_min)/2 - c_xlabel.length()*charwidth, xlbl_row);
- rSGP.setTextSize (charheight * 2.0);
- rSGP.setTextColor (clr_label, -1);
- rSGP.drawText (c_xlabel);
- rSGP.setTextSize (charheight);
- minorinc = xn_tickinc / (o_xminortick + 1);
+ m_pSGP->setTextSize (charheight * 1.5);
+ m_pSGP->setTextColor (clr_label, -1);
+
+ double wText, hText;
+
+ m_pSGP->getTextExtent (c_xlabel.c_str(), &wText, &hText);
+ m_pSGP->moveAbs (xa_min + (xa_max-xa_min)/2 - wText / 2, xlbl_row + charheight * 1.5);
+ m_pSGP->drawText (c_xlabel);
+ m_pSGP->setTextSize (charheight);
+ minorinc = xn_tickinc / (o_xminortick + 1);
+
for (i = 0; i <= x_nint; i++) {
x = xt_min + xn_tickinc * i;
- rSGP.setColor (clr_axis);
- rSGP.moveAbs (x, xaxispos);
- rSGP.lineAbs (x, xaxispos + xticklen);
+ m_pSGP->setColor (clr_axis);
+ m_pSGP->moveAbs (x, xaxispos);
+ m_pSGP->lineAbs (x, xaxispos + xticklen);
if (i != x_nint)
- for (j = 1; j <= o_xminortick; j++) {
- x2 = x + minorinc * j;
- rSGP.moveAbs (x2, xaxispos);
- rSGP.lineAbs (x2, xaxispos + TICKRATIO * xticklen);
- }
- axis_near = FALSE;
- if (xaxispos + xtl_ofs > ya_min && o_yaxis != NOAXIS) {
- double xw, x, y, d;
-
- xw = xgw_min + i * xw_tickinc;
- rSGP.setWindow (xgw_min, ygw_min, xgw_max, ygw_max);
- rSGP.setViewport (xgn_min, ygn_min, xgn_max, ygn_max);
- rSGP.transformMCtoNDC (xw, y, &x, &y);
- rSGP.setWindow (xp_min, yp_min, xp_max, yp_max);
- rSGP.setViewport (xp_min, yp_min, xp_max, yp_max);
- d = x - yaxispos;
- if (o_yticks == RIGHT && d >= 0 && d < 0.9 * xn_tickinc)
- axis_near = TRUE;
- if (o_yticks == LEFT && d <= 0 && d > -0.9 * xn_tickinc)
- axis_near = TRUE;
- }
-
- if (o_xtlabel == TRUE && axis_near == FALSE) {
- snprintf (str, sizeof(str), x_numfmt, xgw_min + xw_tickinc * i);
- numstr = str_skip_head (str, " ");
- rSGP.moveAbs (x-strlen(numstr)*charwidth/2,xaxispos + xtl_ofs);
- rSGP.setTextColor (clr_number, -1);
- rSGP.drawText (numstr);
- }
+ for (j = 1; j <= o_xminortick; j++) {
+ x2 = x + minorinc * j;
+ m_pSGP->moveAbs (x2, xaxispos);
+ m_pSGP->lineAbs (x2, xaxispos + TICKRATIO * xticklen);
+ }
+ axis_near = FALSE;
+ if (xaxispos + xtl_ofs > ya_min && o_yaxis != NOAXIS) {
+ double xw = xgw_min + i * xw_tickinc;
+ double x = convertWorldToNDC_X (xw);
+ double d = x - yaxispos;
+ if (o_yticks == RIGHT && d >= 0 && d < 0.9 * xn_tickinc)
+ axis_near = TRUE;
+ if (o_yticks == LEFT && d <= 0 && d > -0.9 * xn_tickinc)
+ axis_near = TRUE;
+ }
+
+ if (o_xtlabel == TRUE && axis_near == FALSE) {
+ snprintf (str, sizeof(str), x_numfmt, xgw_min + xw_tickinc * i);
+ numstr = str_skip_head (str, " ");
+ double xExtent, yExtent;
+ m_pSGP->getTextExtent (numstr, &xExtent, &yExtent);
+ m_pSGP->moveAbs (x - xExtent/2, xaxispos + xtl_ofs);
+ m_pSGP->setTextColor (clr_number, -1);
+ m_pSGP->drawText (numstr);
+ }
}
- } /* x - axis */
+ } // X - Axis
/*--------*/
/*--------*/
if (o_yaxis == LINEAR) {
- rSGP.setWindow (xp_min, yp_min, xp_max, yp_max);
- rSGP.setViewport (xp_min, yp_min, xp_max, yp_max);
- rSGP.setColor (clr_axis);
+ m_pSGP->setColor (clr_axis);
if (o_tag && !o_grid && !o_box && s_ycross) {
- rSGP.moveAbs (yaxispos - charwidth, ya_min);
- rSGP.lineAbs (yaxispos + charwidth, ya_min);
+ m_pSGP->moveAbs (yaxispos - charwidth, ya_min);
+ m_pSGP->lineAbs (yaxispos + charwidth, ya_min);
}
- rSGP.moveAbs (yaxispos, ya_min);
- rSGP.lineAbs (yaxispos, ya_max);
+ m_pSGP->moveAbs (yaxispos, ya_min);
+ m_pSGP->lineAbs (yaxispos, ya_max);
if (o_tag && !o_grid && !o_box) {
- rSGP.moveAbs (yaxispos - charwidth, ya_max);
- rSGP.lineAbs (yaxispos + charwidth, ya_max);
+ m_pSGP->moveAbs (yaxispos - charwidth, ya_max);
+ m_pSGP->lineAbs (yaxispos + charwidth, ya_max);
}
if (o_grid == TRUE) {
- rSGP.setColor (clr_grid);
+ m_pSGP->setColor (clr_grid);
for (i = 0; i <= y_nint; i++) {
- y = yt_min + yn_tickinc * i;
- rSGP.moveAbs (xa_max, y);
- rSGP.lineAbs (xa_min, y);
+ y = yt_min + yn_tickinc * i;
+ m_pSGP->moveAbs (xa_max, y);
+ m_pSGP->lineAbs (xa_min, y);
}
}
- rSGP.moveAbs (ylbl_col,ya_min + (ya_max-ya_min)/2 - c_ylabel.length()*charheight);
- rSGP.setTextAngle (HALFPI);
- rSGP.setTextSize (2 * charheight);
- rSGP.setTextColor (clr_label, -1);
- rSGP.drawText (c_ylabel);
- rSGP.setTextAngle (0.0);
- rSGP.setTextSize (charheight);
+
+ m_pSGP->setTextAngle (HALFPI);
+ m_pSGP->setTextSize (1.5 * charheight);
+ m_pSGP->setTextColor (clr_label, -1);
+
+ double xExtent, yExtent;
+
+ m_pSGP->getTextExtent (c_ylabel.c_str(), &xExtent, &yExtent);
+ m_pSGP->moveAbs (ylbl_col, ya_min + (ya_max-ya_min)/2 - yExtent / 2);
+ m_pSGP->drawText (c_ylabel);
+
+ m_pSGP->setTextAngle (0.0);
+ m_pSGP->setTextSize (charheight);
minorinc = yn_tickinc / (o_yminortick + 1);
for (i = 0; i <= y_nint; i++) {
y = yt_min + yn_tickinc * i;
- rSGP.setColor (clr_axis);
- rSGP.moveAbs (yaxispos, y);
- rSGP.lineAbs (yaxispos + yticklen, y);
+ m_pSGP->setColor (clr_axis);
+ m_pSGP->moveAbs (yaxispos, y);
+ m_pSGP->lineAbs (yaxispos + yticklen, y);
if (i != y_nint)
- for (j = 1; j <= o_yminortick; j++) {
- y2 = y + minorinc * j;
- rSGP.moveAbs (yaxispos, y2);
- rSGP.lineAbs (yaxispos + TICKRATIO * yticklen, y2);
- }
- axis_near = FALSE;
- if (yaxispos + ytl_ofs > xa_min && o_xaxis != NOAXIS) {
- double yw, x, y, d;
-
- yw = ygw_min + i * yw_tickinc;
- rSGP.setWindow (xgw_min, ygw_min, xgw_max, ygw_max);
- rSGP.setViewport (xgn_min, ygn_min, xgn_max, ygn_max);
- rSGP.transformMCtoNDC (x, yw, &x, &y);
- rSGP.setWindow (xp_min, yp_min, xp_max, yp_max);
- rSGP.setViewport (xp_min, yp_min, xp_max, yp_max);
- d = y - xaxispos;
- if (o_xticks == ABOVE && d >= 0 && d < 0.9 * yn_tickinc)
- axis_near = TRUE;
- if (o_xticks == BELOW && d <= 0 && d > -0.9 * yn_tickinc)
- axis_near = TRUE;
- }
- if (o_ytlabel == TRUE && axis_near == FALSE) {
- snprintf (str, sizeof(str), y_numfmt, ygw_min + yw_tickinc * i);
- rSGP.moveAbs (yaxispos + ytl_ofs, y - 0.5 * charheight);
- rSGP.setTextColor (clr_number, -1);
- rSGP.drawText (str);
- }
+ for (j = 1; j <= o_yminortick; j++) {
+ y2 = y + minorinc * j;
+ m_pSGP->moveAbs (yaxispos, y2);
+ m_pSGP->lineAbs (yaxispos + TICKRATIO * yticklen, y2);
+ }
+ axis_near = FALSE;
+ if (yaxispos + ytl_ofs > xa_min && o_xaxis != NOAXIS) {
+ double yw = ygw_min + i * yw_tickinc;
+ double y = convertWorldToNDC_Y (yw);
+ double d = y - xaxispos;
+ if (o_xticks == ABOVE && d >= 0 && d < 0.9 * yn_tickinc)
+ axis_near = TRUE;
+ if (o_xticks == BELOW && d <= 0 && d > -0.9 * yn_tickinc)
+ axis_near = TRUE;
+ }
+ if (o_ytlabel == TRUE && axis_near == FALSE) {
+ snprintf (str, sizeof(str), y_numfmt, ygw_min + yw_tickinc * i);
+ double xExtent, yExtent;
+ m_pSGP->getTextExtent (str, &xExtent, &yExtent);
+ if (o_yticks == LEFT)
+ m_pSGP->moveAbs (yaxispos - 1.5 * charwidth - xExtent, y + 0.5 * yExtent);
+ else
+ m_pSGP->moveAbs (yaxispos + 1.5 * charwidth, y + 0.5 * yExtent);
+ m_pSGP->setTextColor (clr_number, -1);
+ m_pSGP->drawText (str);
+ }
}
- } /* y - axis */
+ } // Y - Axis
}
return;
if (sym == SB_CROSS) {
- rSGP.moveRel (-0.5 * symwidth, -0.5 * symheight);
- rSGP.lineRel (symwidth, symheight);
- rSGP.moveRel (-symwidth, 0.0);
- rSGP.lineRel (symwidth, -symheight);
- rSGP.moveRel (-0.5 * symwidth, 0.5 * symheight);
+ m_pSGP->moveRel (-0.5 * symwidth, -0.5 * symheight);
+ m_pSGP->lineRel (symwidth, symheight);
+ m_pSGP->moveRel (-symwidth, 0.0);
+ m_pSGP->lineRel (symwidth, -symheight);
+ m_pSGP->moveRel (-0.5 * symwidth, 0.5 * symheight);
} else if (sym == SB_PLUS) {
- rSGP.moveRel (-0.5 * symwidth, 0.0);
- rSGP.lineRel (symwidth, 0.0);
- rSGP.moveRel (-0.5 * symwidth, -0.5 * symheight);
- rSGP.lineRel (0.0, symheight);
- rSGP.moveRel (0.0, -0.5 * symheight);
+ m_pSGP->moveRel (-0.5 * symwidth, 0.0);
+ m_pSGP->lineRel (symwidth, 0.0);
+ m_pSGP->moveRel (-0.5 * symwidth, -0.5 * symheight);
+ m_pSGP->lineRel (0.0, symheight);
+ m_pSGP->moveRel (0.0, -0.5 * symheight);
} else if (sym == SB_BOX) {
- rSGP.moveRel (-0.5 * symwidth, -0.5 * symheight);
- rSGP.lineRel (symwidth, 0.0);
- rSGP.lineRel (0.0, symheight);
- rSGP.lineRel (-symwidth, 0.0);
- rSGP.lineRel (0.0, -symheight);
- rSGP.moveRel (0.5 * symwidth, 0.5 * symheight);
+ m_pSGP->moveRel (-0.5 * symwidth, -0.5 * symheight);
+ m_pSGP->lineRel (symwidth, 0.0);
+ m_pSGP->lineRel (0.0, symheight);
+ m_pSGP->lineRel (-symwidth, 0.0);
+ m_pSGP->lineRel (0.0, -symheight);
+ m_pSGP->moveRel (0.5 * symwidth, 0.5 * symheight);
} else if (sym == SB_CIRCLE) {
- rSGP.drawCircle (symwidth);
+ m_pSGP->drawCircle (symwidth);
} else if (sym == SB_ERRORBAR) {
- rSGP.moveRel (-0.5 * symwidth, 0.5 * symheight);
- rSGP.lineRel (symwidth, 0.0);
- rSGP.moveRel (-0.5 * symwidth, 0.0);
- rSGP.lineRel (0.0, -symheight);
- rSGP.moveRel (-0.5 * symwidth, 0.0);
- rSGP.lineRel (symwidth, 0.0);
- rSGP.moveRel (-0.5 * symwidth, 0.5 * symheight);
+ m_pSGP->moveRel (-0.5 * symwidth, 0.5 * symheight);
+ m_pSGP->lineRel (symwidth, 0.0);
+ m_pSGP->moveRel (-0.5 * symwidth, 0.0);
+ m_pSGP->lineRel (0.0, -symheight);
+ m_pSGP->moveRel (-0.5 * symwidth, 0.0);
+ m_pSGP->lineRel (symwidth, 0.0);
+ m_pSGP->moveRel (-0.5 * symwidth, 0.5 * symheight);
}
}
/* NAME
- * axis_scale calculates graph axis scaling
- *
- * SYNOPSIS:
- * retval = axis_scale (min, max, nint, minp, maxp, nintp,
- * rec_total, rec_frac)
- *
- * INPUT:
- * double min Smallest value to plot
- * double max Largest value to plot
- * int nint Number of intervals desired
- *
- * OUTPUT:
- * int retval FALSE if illegal parameters, else TRUE
- * double *minp Minimum graph value
- * double *maxp Maximum graph value
- * int *nintp Number of intervals for graph
- * int *rec_total Recommended field width for printing out the number
- * int *rec_frac Recommended number of digits for print fraction
- */
+* axis_scale calculates graph axis scaling
+*
+* SYNOPSIS:
+* retval = axis_scale (min, max, nint, minp, maxp, nintp,
+* rec_total, rec_frac)
+*
+* INPUT:
+* double min Smallest value to plot
+* double max Largest value to plot
+* int nint Number of intervals desired
+*
+* OUTPUT:
+* int retval FALSE if illegal parameters, else TRUE
+* double *minp Minimum graph value
+* double *maxp Maximum graph value
+* int *nintp Number of intervals for graph
+* int *rec_total Recommended field width for printing out the number
+* int *rec_frac Recommended number of digits for print fraction
+*/
int
EZPlot::axis_scale (double min, double max, int nint, double *minp, double *maxp, int *nintp)
{
if (min >= max || nint < 1) {
- sys_error (ERR_WARNING, "Invalid params: min=%lf, min=%lf, num intervals=%d [axis_scale]", min, max, nint);
+ sys_error (ERR_WARNING, "Invalid params: min=%lf, max=%lf, num intervals=%d [axis_scale]", min, max, nint);
return (FALSE);
}
if (fabs(min) < fabs(max))
a = fabs(max);
double scale = pow (10.0, floor(log10(a)));
- loop:
+loop:
double mina = min / scale;
double maxa = max / scale;
double d = (maxa - mina) / nint;
double g = floor (mina / wdt);
if (fabs(g + 1 - mina / wdt) < j)
g = g + 1;
+#undef TEST1
+
+#ifdef TEST1
+ g++;
+#endif
*minp = wdt * g;
double h = floor (maxa / wdt) + 1.0;
if (fabs(maxa / wdt + 1 - h) < j)
h = h - 1;
+#ifdef TEST1
+ h--;
+#endif
*maxp = wdt * h;
*nintp = static_cast<int>(h - g);
if (fabs(*maxp) >= 10.0 || fabs(*minp) >= 10.0) {
/* NAME
- * make_numfmt Make a numeric format string
- *
- * SYNOPSIS
- * make_numfmt (fmtstr, fldwid, nfrac, min, max, nint)
- * char *fmtstr Returned format string for printf()
- * int *fldwid Returned field width
- * int *nfrac If < 0, then calculate best number of
- * fraction places & return that value
- * If >= 0, then use that number of places
- * double min Minimum value
- * double max Maximum value
- * int nint Number of intervals between min & max
- *
- * DESCRIPTION
- * This routine is written as an INTERNAL routine for EZPLOT
- */
+* make_numfmt Make a numeric format string
+*
+* SYNOPSIS
+* make_numfmt (fmtstr, fldwid, nfrac, min, max, nint)
+* char *fmtstr Returned format string for printf()
+* int *fldwid Returned field width
+* int *nfrac If < 0, then calculate best number of
+* fraction places & return that value
+* If >= 0, then use that number of places
+* double min Minimum value
+* double max Maximum value
+* int nint Number of intervals between min & max
+*
+* DESCRIPTION
+* This routine is written as an INTERNAL routine for EZPLOT
+*/
static inline double
trunc (double x)
EZPlot::make_numfmt (char *fmtstr, int *fldwid, int *nfrac, double minval, double maxval, int nint)
{
int wid, frac, expon;
-
+
double delta = (maxval - minval) / nint;
double absmin = fabs(minval);
double absmax = fabs(maxval);
- double logt = log10( max(absmin, absmax) );
- if (fabs(logt) >= 6) { /* use exponential format */
+ if (absmin > absmax)
+
+ absmax = absmin;
+ double logt = log10( absmax );
+
+ if (fabs(logt) >= 6) { // use exponential format
if (fabs(logt) > 99)
- expon = 5; /* E+102 */
+ expon = 5; // E+102
else
- expon = 4; /* E+00 */
+ expon = 4; // E+00
- if (*nfrac < 0) { /* calculate frac */
- delta /= pow (10., floor(logt)); /* scale delta */
+ if (*nfrac < 0) { // calculate frac
+ delta /= pow (10., floor(logt)); // scale delta
frac = static_cast<int>(fabs(trunc(log10(delta)))) + 1;
if (frac < 1)
- frac = 1; /* to be safe, add decimal pt */
- } else /* use users' frac */
+ frac = 1; // to be safe, add decimal pt
+ } else // use users' frac
frac = *nfrac;
wid = 2 + frac + expon;
if (minval < 0. || maxval < 0.)
++wid;
sprintf (fmtstr, "%s%d%s%d%s", "%", wid, ".", frac, "g");
- } else { /* use fixed format */
+ } else { // use fixed format
wid = static_cast<int>(trunc(logt)) + 1;
if (wid < 1)
wid = 1;
if (minval < 0. || maxval < 0.)
++wid;
- if (*nfrac < 0) { /* calculate frac */
+ if (*nfrac < 0) { // calculate frac
if (delta >= 0.999999)
- frac = 1; /* add a decimal pt to be safe */
+ frac = 1; // add a decimal pt to be safe
else
- frac = static_cast<int>(fabs(trunc(log10(delta)))) + 1;
- } else /* use users' frac */
+ frac = static_cast<int>(fabs(trunc(log10(delta)))) + 1;
+ } else // use users' frac
frac = *nfrac;
wid += 1 + frac;
sprintf (fmtstr, "%s%d%s%d%s", "%", wid, ".", frac, "f");
}
-
+
*fldwid = wid;
*nfrac = frac;
}
projects / ctsim.git / blobdiff