X-Git-Url: http://git.kpe.io/?p=ctsim.git;a=blobdiff_plain;f=libctgraphics%2Fezplot.cpp;h=ed1ca233d26ef8e8c02e967e78717935a77b64bd;hp=72f7e5149fbbfdbc9ff0ea53b4b5ed810db6e397;hb=3f6c94c6bd432ad7b7a55ad991d3b8223fb44f18;hpb=df761d2b3cac3d347f4ef0f9f69e88d3bb66b2fa

diff --git a/libctgraphics/ezplot.cpp b/libctgraphics/ezplot.cpp
index 72f7e51..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.25 2000/12/27 20:09:19 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
@@ -36,14 +36,12 @@ static const int DEF_CURVE_CLR = C_RED;
 
 
 EZPlotCurve::EZPlotCurve (const double* xData, const double* yData, int n)
-: x(NULL), y(NULL)
+: 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;
 }
@@ -94,7 +92,7 @@ EZPlot::addCurve (const float x[], const double y[], int num)
 }
 
 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 = new double [num];
   
@@ -108,7 +106,7 @@ EZPlot::addCurve (const double x[], const float y[], int num)
 
 
 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;
@@ -134,34 +132,48 @@ 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 ();
-
+    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 ()
 {
-  charheight = rSGP.getCharHeight();
-  charwidth = rSGP.getCharWidth();
-
-  m_iCurrentCurve = -1;
+  m_iCurrentCurve = -1;
+
+  m_pSGP = NULL;
+
 
   c_xlabel = "";
   c_ylabel =  "";
@@ -206,7 +218,7 @@ EZPlot::initPlotSettings ()
   s_ylegend  = FALSE;
   s_textsize = FALSE;
   
-  clr_axis   = C_BLACK;		// set fixed colors 
+  clr_axis   = C_LTGRAY;		// set fixed colors 
   clr_title  = C_RED;
   clr_label  = C_BLUE;
   clr_legend = C_CYAN;
@@ -214,118 +226,230 @@ EZPlot::initPlotSettings ()
   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;
-}
-    
-
+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 ()
 *
@@ -340,23 +464,31 @@ EZPlot::getLegend (unsigned int iCurve) const
 */
 
 void
-EZPlot::plot ()
-{
+EZPlot::plot (SGP* pSGP)
+{
+
   if (m_vecCurves.size() <= 0)
     return;
   
-  rSGP.setWindow (0., 0., 1., 1.);
+
+  m_pSGP = pSGP;
+
+
+  m_pSGP->setWindow (0., 0., 1., 1.);
   
   if (s_textsize == TRUE)
-    rSGP.setTextPointSize (v_textsize);
-  charheight = rSGP.getCharHeight();
-  charwidth = rSGP.getCharWidth();
+    m_pSGP->setTextPointSize (v_textsize);
+
+  charheight = m_pSGP->getCharHeight();
+  charwidth = m_pSGP->getCharWidth();
  
-  const EZPlotCurve& firstCurve = *m_vecCurves[0];
+  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; 
+  double ymax = ymin; 
+
   unsigned int iCurve;
   for (iCurve = 0; iCurve < m_vecCurves.size(); iCurve++) {
     const EZPlotCurve* const pCurve = m_vecCurves [iCurve];
@@ -454,21 +586,32 @@ EZPlot::plot ()
   ya_max = yp_max;
   
   // adjust frame for title 
-  title_row = ya_max;;
+  title_row = ya_max;;
+
   if (c_title.length() > 0)
-    ya_max -= 2 * charheight;
+    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 
+  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) {
+    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 (nLegend > max_leg)
+
+          nLegend = max_leg;
+
       }
     }
   }
@@ -493,10 +636,11 @@ EZPlot::plot ()
     
     yl_min = yl_max - leg_height;
     
-    rSGP.setColor (clr_legend);
-    rSGP.drawRect (xl_min, yl_min, xl_max, yl_max);
+    m_pSGP->setColor (clr_legend);
+    m_pSGP->drawRect (xl_min, yl_min, xl_max, yl_max);
     
-    int iLegend = 0;			// current legend position 
+    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)
@@ -506,21 +650,24 @@ EZPlot::plot ()
       double xmax = xl_max - 1.0 * charwidth;
       double y = yl_max - (2.0 + iLegend * 3) * charheight;
       
-      rSGP.moveAbs (xmin, y + 0.5 * charheight);
-      rSGP.drawText (pstrLegend->c_str());
-      rSGP.setColor (getColor (iCurve));
+      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) {
-        rSGP.setLineStyle (iLS);
-        rSGP.moveAbs (xmin, y);
-        rSGP.lineAbs (xmax, y);
-      }
+        m_pSGP->setLineStyle (iLS);
+        m_pSGP->moveAbs (xmin, y);
+        m_pSGP->lineAbs (xmax, y);
+      }
+
       int iSymbol = getSymbol (iCurve);
       if (iSymbol > 0) {
         double xinc = (xmax - xmin) / (5 - 1);
-        rSGP.setLineStyle (SGP::LS_SOLID);
+        m_pSGP->setLineStyle (SGP::LS_SOLID);
         for (int j = 0; j < 5; j++) {
-          rSGP.moveAbs (xmin + j * xinc, y);
+          m_pSGP->moveAbs (xmin + j * xinc, y);
           symbol(iSymbol, 0.5 * charwidth, 0.5 * charheight);
         }
       }
@@ -540,14 +687,22 @@ EZPlot::plot ()
   xlbl_row = xp_min;		// put x-label on bottom of plot frame 
   
   // Y-Label 
-  if (c_ylabel.length() > 0) {
-    rSGP.setTextAngle (HALFPI);
-    rSGP.setTextSize (1.5 * charheight);
-    double xExtent, yExtent;
-    rSGP.getTextExtent (c_ylabel.c_str(), &xExtent, &yExtent);
-    rSGP.setTextSize (charheight);
-    xa_min += xExtent;
-    rSGP.setTextAngle (0.0);
+  if (c_ylabel.length() > 0) {
+
+    m_pSGP->setTextAngle (HALFPI);
+
+    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;
   
@@ -565,13 +720,21 @@ EZPlot::plot ()
   
   if (o_yaxis == NOAXIS || o_ytlabel == FALSE)
     ytl_ofs = 0.0;
-  else if (o_yticks == LEFT)
-    ytl_ofs = -(2 + 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
-
+  xa_max -= 0.7 * x_fldwid * charwidth; // make room for last x tick label
+
   xt_min = xa_min;
   yt_min = ya_min;
   xt_max = xa_max;
@@ -591,11 +754,11 @@ EZPlot::plot ()
   
   if (ytl_ofs != 0.0 && s_xcross == FALSE) {
     if (o_yticks == LEFT) {
-      xa_min += (2 + 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;
@@ -650,59 +813,80 @@ EZPlot::plot ()
   
   // 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;
-  
-  double clipRect[4];
-  clipRect[0] = xgn_min; clipRect[1] = ygn_min; clipRect[2] = xgn_max; clipRect[3] = ygn_max;
-
+  
+
+  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];
-    
-    rSGP.setColor (getColor (iCurve));
-    int iSym = getSymbol (iCurve);
-    int iLS = getLinestyle (iCurve);
-
+    
+
+    m_pSGP->setColor (getColor (iCurve));
+
+    int iSym = getSymbol (iCurve);
+
+    int iLS = getLinestyle (iCurve);
+
+
+
     if (iLS != SGP::LS_NOLINE) {
-      rSGP.setLineStyle (iLS);
+      m_pSGP->setLineStyle (iLS);
       double x1 = convertWorldToNDC_X (pCurve->x[0]);
-      double y1 = convertWorldToNDC_Y (pCurve->y[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)) {
-          rSGP.moveAbs (x1, y1);
-          rSGP.lineAbs (x2Clip, y2Clip);
-        }
-        x1 = x2;
-        y1 = y2;
+        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) {
+    if (iSym > 0) {
+
       int iSymFreq = getSymbolFreq (iCurve);
-      rSGP.setLineStyle (SGP::LS_SOLID);
+      m_pSGP->setLineStyle (SGP::LS_SOLID);
       double x = convertWorldToNDC_X (pCurve->x[0]);
       double y = convertWorldToNDC_Y (pCurve->y[0]);
-      rSGP.moveAbs (x, y);
+      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]);
+          y = convertWorldToNDC_Y (pCurve->y[i]);
+
           if (y >= ygn_min && y <= ygn_max) {
-            rSGP.moveAbs (x, y);
-            symbol (iSym, symwidth, symheight);
+            m_pSGP->moveAbs (x, y);
+            symbol (iSym, symwidth, symheight);
+
           }
         }
     }
-  }
-  
+  }  
 }
 
 
@@ -726,8 +910,8 @@ EZPlot::drawAxes()
   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 = 0.5 * charheight;
@@ -741,21 +925,21 @@ EZPlot::drawAxes()
   
   if (c_title.length() > 0) {
     double wText, hText;
-    rSGP.setTextSize (charheight * 2.0);
-    rSGP.getTextExtent (c_title.c_str(), &wText, &hText);
-    rSGP.moveAbs (xa_min + (xa_max-xa_min)/2 - wText/2, title_row);
-    rSGP.setTextColor (clr_title, -1);
-    rSGP.drawText (c_title);
-    rSGP.setTextSize (charheight);
+    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 
@@ -781,44 +965,47 @@ EZPlot::drawAxes()
   if (o_xaxis == LINEAR) {
     // 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.setTextSize (charheight * 1.5);
-    rSGP.setTextColor (clr_label, -1);
-    double wText, hText;
-    rSGP.getTextExtent (c_xlabel.c_str(), &wText, &hText);
-    rSGP.moveAbs (xa_min + (xa_max-xa_min)/2 - wText / 2, xlbl_row +  charheight * 1.5);
-    rSGP.drawText (c_xlabel);
-    rSGP.setTextSize (charheight);
+    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);
+          m_pSGP->moveAbs (x2, xaxispos);
+          m_pSGP->lineAbs (x2, xaxispos + TICKRATIO * xticklen);
         }
         axis_near = FALSE;
         if (xaxispos + xtl_ofs > ya_min && o_yaxis != NOAXIS) {
@@ -834,9 +1021,11 @@ EZPlot::drawAxes()
         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);
+          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 
@@ -848,47 +1037,51 @@ EZPlot::drawAxes()
   
   if (o_yaxis == LINEAR) {
     
-    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);
+        m_pSGP->moveAbs (xa_max, y);
+        m_pSGP->lineAbs (xa_min, y);
       }
-    }
-    rSGP.setTextAngle (HALFPI);
-    rSGP.setTextSize (1.5 * charheight);
-    rSGP.setTextColor (clr_label, -1);
-    double xExtent, yExtent;
-    rSGP.getTextExtent (c_ylabel.c_str(), &xExtent, &yExtent);
-    rSGP.moveAbs (ylbl_col, ya_min + (ya_max-ya_min)/2 - yExtent / 2);
-    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);
+          m_pSGP->moveAbs (yaxispos, y2);
+          m_pSGP->lineAbs (yaxispos + TICKRATIO * yticklen, y2);
         }
         axis_near = FALSE;
         if (yaxispos + ytl_ofs > xa_min && o_xaxis != NOAXIS) {
@@ -901,10 +1094,15 @@ EZPlot::drawAxes()
             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);
+          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
@@ -918,34 +1116,34 @@ 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);
   }
 }
 
@@ -1003,7 +1201,8 @@ loop:
   double g = floor (mina / wdt);
   if (fabs(g + 1 - mina / wdt) < j)
     g = g + 1;
-#undef TEST1
+#undef TEST1
+
 #ifdef TEST1
   g++;
 #endif
@@ -1063,8 +1262,10 @@ EZPlot::make_numfmt (char *fmtstr, int *fldwid, int *nfrac, double minval, doubl
   
   double delta = (maxval - minval) / nint;
   double absmin = fabs(minval);
-  double absmax = fabs(maxval);
-  if (absmin > absmax)
+  double absmax = fabs(maxval);
+
+  if (absmin > absmax)
+
     absmax = absmin;
   double logt = log10( absmax );