KKB::Chart Class Reference

Used to Create chart's from defined series of data. More...

#include <Chart.h>

Classes
class	PlotPoint
class	Series
class	XLabel

Public Types
typedef PlotPoint *	PlotPointPtr
typedef vector< SeriesPtr >	SeriesList
typedef Series *	SeriesPtr

Public Member Functions
	Chart (KKStr _title)
	~Chart ()
void	AddAValue (kkuint32 _seriesIDX, float _xVal, float _yVal)
RasterPtr	CreateRaster ()
void	DefineASeries (KKStr _name)
void	DefineASeries (KKStr _name, PixelValue _color)
void	DefineAXLabel (float _xVal, KKStr _name)
kkint32	NumOfSeries ()
void	Save (KKStr _fileName)
void	SaveAsImage (KKStr _fileName)

Detailed Description

Used to Create chart's from defined series of data.

This class is meant to allow you to define multiple series, their x and y ranges and the data for each series.

Todo:

This class Chart has not been used as of yet so requires testing.

Definition at line 24 of file Chart.h.

Member Typedef Documentation

typedef PlotPoint* KKB::Chart::PlotPointPtr

Definition at line 33 of file Chart.h.

typedef vector<SeriesPtr> KKB::Chart::SeriesList

Definition at line 32 of file Chart.h.

typedef Series* KKB::Chart::SeriesPtr

Definition at line 29 of file Chart.h.

Constructor & Destructor Documentation

KKB::Chart::Chart

(

KKStr

_title

)

Definition at line 142 of file Chart.cpp.

References Chart(), KKB::FloatMax, KKB::FloatMin, and KKB::KKStr::KKStr().

Referenced by Chart().

                             :
  title      (_title),
  series     (),
  xLabels    (),
  minXValue  (FloatMax),
  maxXValue  (FloatMin),
  minYValue  (FloatMax),
  maxYValue  (FloatMin),

  maxPointsPlotedInASeries (0),
  numOfDefaultColorsUsed (0),

  chartWidth  (0),
  chartHeight (0),
  xOffset     (0),
  yOffset     (0),
  yRange      (0.0),
  xRange      (0.0),
  yScale      (0.0),
  xScale      (0.0),
  xMin        (0.0),
  xMax        (0.0),
  yMin        (0.0),
  yMax        (0.0),
  yIncrement  (0.0)

{
}

KKB::Chart::~Chart

(

)

Definition at line 172 of file Chart.cpp.

{
  for  (kkuint32 x = 0;  x < series.size ();  x++)
  {
    delete  series[x];
    series[x] = NULL;
  }
}

Member Function Documentation

void KKB::Chart::AddAValue	(	kkuint32	_seriesIDX,
		float	_xVal,
		float	_yVal
	)

Definition at line 184 of file Chart.cpp.

{
  if  ((_seriesIDX < 0)  ||  (_seriesIDX >= series.size ()))
  {
    cerr << std::endl
         << "*** ERROR ***  Chart::AddAValue" << std::endl
         << "               Invalid SeriesIDX[" << _seriesIDX << "]"  << std::endl
         << "               Only [" << series.size () << "] series defined." << std::endl
         << std::endl;
    exit (-1);
  }

  series[_seriesIDX]->AddAValue (_xVal, _yVal);

  if  (series[_seriesIDX]->Size ()  >  maxPointsPlotedInASeries)
     maxPointsPlotedInASeries = series[_seriesIDX]->Size ();


  if  (_xVal <  minXValue)
    minXValue = _xVal;

  if  (_xVal >  maxXValue)
    maxXValue = _xVal;

  if  (_yVal <  minYValue)
    minYValue = _yVal;

  if  (_yVal >  maxYValue)
    maxYValue = _yVal;

}  /* AddAValue */

RasterPtr Chart::CreateRaster

(

)

Definition at line 287 of file Chart.cpp.

References KKB::Raster::DrawDot(), KKB::Raster::DrawLine(), KKB::PixelValue::PixelValue(), KKB::Chart::PlotPoint::PlotPoint(), and KKB::Raster::Raster().

Referenced by SaveAsImage().

{
  PixelValue  axisColor     (  0,   0,   0);
  PixelValue  scaleColor    (190, 190, 190);
  PixelValue  zeroAxisColor (240, 132, 240);

  chartWidth = maxPointsPlotedInASeries * 10;

  if  (chartWidth > 1000)
    chartWidth = 1000;

  chartHeight = chartWidth;

  if  (chartHeight > 500)
    chartHeight = 500;


  xOffset = 10;
  yOffset = 10;

  
  yRange = maxYValue - minYValue;
  xRange = maxXValue - minXValue;

  yScale = (double)chartHeight / yRange;
  xScale = (double)chartWidth  / xRange;

  yMin = minYValue;
  yMax = maxYValue;

  xMin = minXValue;
  xMax = maxXValue;
  

  {
    // Lets refine the scaling
    double  sigTensPlace = floor (log10 (yRange));

    sigTensPlace = pow (10.0, sigTensPlace);

    yIncrement = floor (yRange / sigTensPlace) * sigTensPlace;

    kkint32  numOfYIncremets = (kkint32)((yRange / yIncrement) + 0.5);

    if  (numOfYIncremets < 2)
    {
      yIncrement = yIncrement / 4.0;
    }
    else if  (numOfYIncremets < 5)
    {
      yIncrement = yIncrement / 2.0;
    }
    else if  (numOfYIncremets > 7)
    {
      yIncrement = yIncrement * 2.0;
    }
    else if  (numOfYIncremets > 13)
    {
      yIncrement = yIncrement * 4.0;
    }

    yMin = floor (minYValue / yIncrement) * yIncrement;
    yMax = ceil  (maxYValue / yIncrement) * yIncrement;

    yRange = yMax - yMin;
    yScale = (double)chartHeight / yRange;
  }


  kkint32  height = chartHeight + 2 * yOffset;
  kkint32  width  = chartWidth  + 2 * xOffset;

  RasterPtr  chart = new Raster (height, width, true);

  {
    // Draw Main Axis
    chart->DrawLine (yOffset, xOffset, yOffset + chartHeight, xOffset,              axisColor);
    chart->DrawLine (yOffset, xOffset, yOffset              , xOffset + chartWidth, axisColor);
  }


  {
    // Draw y scales

    double  y = yMin + yIncrement;

    while  (y < yMax)
    {
      chart->DrawLine (RasterCoordinates (PlotPoint (0.0,  (double)y)),
                       RasterCoordinates (PlotPoint (xMax, (double)y)),
                       scaleColor
                      );
      y += yIncrement;
    }
  }


  if  ((yMin < 0.0)  &&  (yMax > 0.0))
  {
    // Draw a line for y=0.0
    chart->DrawLine (RasterCoordinates (PlotPoint (double ((kkint32)(xMin + 0.5)),  0.0)),
                     RasterCoordinates (PlotPoint (double ((kkint32)(xMax + 0.5)),  0.0)),
                     zeroAxisColor
                    );

  }



  if  ((xMin < 0.0)  &&  (xMax > 0.0))
  {
    // Draw a line for x=0.0
    chart->DrawLine (RasterCoordinates (PlotPoint (0.0,  double ((kkint32)(yMin + 0.5)))),
                     RasterCoordinates (PlotPoint (0.0,  double ((kkint32)(yMax + 0.5)))),
                     zeroAxisColor
                    );

  }



  {
    // Lets plot the individual series

    for  (kkuint32 seriesIDX = 0;  seriesIDX < series.size ();  seriesIDX++)
    {
      SeriesPtr  s = series[seriesIDX];

      if  (s->points.size () == 0)
        continue;

      PlotPoint  lastPoint (s->points[0]);
      
      chart->DrawDot (RasterCoordinates (lastPoint), s->color, 3);

      for  (kkuint32 plotIDX = 1;  plotIDX < s->points.size ();  plotIDX++)
      {
        PlotPoint  point (s->points[plotIDX]);

        chart->DrawDot (RasterCoordinates (point), s->color, 3);

        chart->DrawLine (RasterCoordinates (lastPoint), 
                         RasterCoordinates (point),
                         s->color
                        );

        lastPoint = point;
      }
    }
  }


  return  chart;
}  /* CreateRaster */

void KKB::Chart::DefineASeries

(

KKStr

_name

)

Definition at line 245 of file Chart.cpp.

{
  series.push_back (new Series (_name, defaultColors[numOfDefaultColorsUsed % numOfDefinedDefaultColors]));
  numOfDefaultColorsUsed++;
}

void KKB::Chart::DefineASeries	(	KKStr	_name,
		PixelValue	_color
	)

Definition at line 253 of file Chart.cpp.

{
  series.push_back (new Series (_name, _color));
}

void KKB::Chart::DefineAXLabel	(	float	_xVal,
		KKStr	_name
	)

Definition at line 263 of file Chart.cpp.

{
  xLabels.push_back (XLabel (_xVal, _name));
}

kkint32 KKB::Chart::NumOfSeries ( )

inline

Definition at line 40 of file Chart.h.

Referenced by Save().

{return  (kkint32)series.size ();}

void Chart::Save

(

KKStr

_fileName

)

Definition at line 487 of file Chart.cpp.

References NumOfSeries(), KKB::Chart::PlotPoint::XVal(), and KKB::Chart::XLabel::XVal().

{
  ofstream  o (_fileName.Str ());
  if  (!o.is_open ())
  {
    cerr << std::endl
         << "*** ERROR ***     Chart::Save,    Error Opening file[" << _fileName << "]." << std::endl
         << std::endl;
    return;
  }


  {
    // Make sure we have a XLabel for all Points Plotted
    for  (kkuint32 seriesIDX = 0;  seriesIDX < series.size ();  seriesIDX++)
    {
      SeriesPtr s = series[seriesIDX];
      for  (kkuint32  plotIDX = 0;  plotIDX < s->points.size ();  plotIDX++)
      {
        PlotPoint& p = s->points[plotIDX];
        if  (LookUpXLableIDX (p.XVal ()) < 0)
        {
          char  buff[80];

#         ifdef  USE_SECURE_FUNCS
            sprintf_s (buff, sizeof (buff), "%g", p.XVal ());
#         else
            sprintf (buff, "%g", p.XVal ());
#         endif

          xLabels.push_back (XLabel (p.XVal (), buff));
        }
      }
    }
  }


  std::sort (xLabels.begin (), xLabels.end ());


  {
    // Output Header Info
    o << "Title" << "\t" << title << std::endl;
    o << "MinAndMaxXValues:" << "\t" << minXValue << "\t" << maxXValue << std::endl;
    o << "MinAndMaxYValues:" << "\t" << minYValue << "\t" << maxYValue << std::endl;

    o << "MaxPointsPlottedInASeries" << "\t" << maxPointsPlotedInASeries << std::endl;
    o << std::endl;
  }


  o << std::endl;
  o << std::endl;


  {
    // Column Headers 
    o << "XLabel" << "\t" << "XValue"; 
    for  (kkint32 seriesIDX = 0;  seriesIDX < NumOfSeries ();  seriesIDX++)
    {
      o << "\t" << series[seriesIDX]->name;
    }
    o << std::endl;
  }



  {
    kkuint32  x;

    for  (x = 0;  x < xLabels.size (); x++)
    {
      XLabel&  xLabel = xLabels[x];

      double  xVal = xLabel.XVal ();


      o << xLabel.Name () << "\t" << xVal;

      kkint32  seriesIDX = 0;

      for  (seriesIDX = 0;  seriesIDX < NumOfSeries ();  seriesIDX++)
      {
        o << "\t";

        PlotPointPtr  p = LookUpPoint (seriesIDX, xVal);
        if  (p)
        {
          o << p->YVal ();
        }
      }

      o << std::endl;
    }
  }
     

  o.close ();
}    /* Save */

void Chart::SaveAsImage

(

KKStr

_fileName

)

Definition at line 445 of file Chart.cpp.

References CreateRaster(), and KKB::SaveImage().

{
  RasterPtr  raster = CreateRaster ();
  SaveImage  (*raster, _fileName); 
} /* SaveAsImage */

---

The documentation for this class was generated from the following files:

• C:/Users/Kurt/GitHub/KSquareLibraries/KKBase/Chart.h
• C:/Users/Kurt/GitHub/KSquareLibraries/KKBase/Chart.cpp