X-Git-Url: http://git.kpe.io/?p=ctsim.git;a=blobdiff_plain;f=libctgraphics%2Fezplot.cpp;h=ed1ca233d26ef8e8c02e967e78717935a77b64bd;hp=45796684b2741dc822a69029e67a3718f062ef57;hb=3f6c94c6bd432ad7b7a55ad991d3b8223fb44f18;hpb=08a5cd04c3994d5ea24713b9b000791bd2e406fe diff --git a/libctgraphics/ezplot.cpp b/libctgraphics/ezplot.cpp index 4579668..ed1ca23 100644 --- a/libctgraphics/ezplot.cpp +++ b/libctgraphics/ezplot.cpp @@ -4,9 +4,9 @@ ** 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 @@ -25,31 +25,25 @@ #include "ezplot.h" #include +#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 () @@ -62,45 +56,62 @@ 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); } @@ -121,22 +132,52 @@ EZPlot::clearCurves () } -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; @@ -177,63 +218,290 @@ EZPlot::initPlotSettings () 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]; } } @@ -244,19 +512,19 @@ EZPlot::plot () 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; @@ -266,7 +534,7 @@ EZPlot::plot () 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; @@ -275,12 +543,12 @@ EZPlot::plot () 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 @@ -288,61 +556,76 @@ EZPlot::plot () 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; @@ -352,110 +635,138 @@ EZPlot::plot () 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) @@ -494,121 +805,156 @@ EZPlot::plot () 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; @@ -617,74 +963,72 @@ EZPlot::drawAxes(void) /*-------------*/ 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 /*--------*/ @@ -692,73 +1036,76 @@ EZPlot::drawAxes(void) /*--------*/ 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 } @@ -769,65 +1116,65 @@ EZPlot::symbol (int sym, double symwidth, double symheight) 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); } @@ -836,7 +1183,7 @@ EZPlot::axis_scale (double min, double max, int nint, double *minp, double *maxp 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; @@ -854,10 +1201,18 @@ EZPlot::axis_scale (double min, double max, int nint, double *minp, double *maxp 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(h - g); if (fabs(*maxp) >= 10.0 || fabs(*minp) >= 10.0) { @@ -873,22 +1228,22 @@ EZPlot::axis_scale (double min, double max, int nint, double *minp, double *maxp /* 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) @@ -904,49 +1259,53 @@ void 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(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(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(fabs(trunc(log10(delta)))) + 1; - } else /* use users' frac */ + frac = static_cast(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; }