ascii_chart.cxx

Go to the documentation of this file.

#include <cxxtls/ascii_chart.h>
#include <algorithm>
#include <cxxtls/foreach.h>
#include <string.h>
#include <string>
#include <portable_io.h>


using std::fill_n;
using std::ostream;
using std::vector;
using std::string;
using std::endl;

namespace cxxtls
{

ascii_chart::
ascii_chart(int width, int height, char blank, char star)
: width_(width),
  height_(height),
  blank_(blank),
  star_(star)
{
  
  data_ = new char*[height+1];

  char **scan = data_;

  while(height)
  {
    *scan = new char[width+1];

    ++scan;
    --height;
  }

  *scan = 0;

  clear(); // sets dirty to false

}

ascii_chart::
~ascii_chart()
{
  char** scan = data_;

  while(*scan)
  {
    delete [] *scan;

    ++scan;
  }

  delete [] data_;
}

void
ascii_chart::
clear()
{

  dirty_ = false;

  char **scan;

  for(scan = data_; *scan; ++scan)
  {
    fill_n(*scan, width_, blank_);
    (*scan)[width_] = 0;
  }

  xrange_.first  = 0;
  xrange_.second = 0;
  yrange_.first  = 0;
  yrange_.second = 0;


}

void
ascii_chart::
range(data_t const &data)
{
  //
  // First, compute the range of data
  //

  bool first_time=true;

  X_t xl=0;  // low/high vars
  X_t xh=0;
  Y_t yl=0;
  Y_t yh=0;

  data_t::const_iterator i = data.begin();
  data_t::const_iterator l = data.end();

  while(i != l)
  {
    X_t x = i->first;
    Y_t y = i->second;
    
    if(first_time)
    {
      xl = x;
      xh = x;
      yl = y;
      yh = y;
      first_time = false;
    }
    else
    {
      if(x < xl) xl = x;
      if(x > xh) xh = x;
      if(y < yl) yl = y;
      if(y > yh) yh = y;
    }

    ++i;
  }

  xrange_.first = xl;
  xrange_.second= xh;
  yrange_.first = yl;
  yrange_.second= yh;

}

void
ascii_chart::
plot(data_t const &data,int) // last parm is ignored
{

  if(dirty_)
    clear();

  range(data);   // get extrema for the data

  // when plotting, we'll bias the data in the range 0 to width_, 0 to height_

  X_t x_span = xrange_.second - xrange_.first;
  Y_t y_span = yrange_.second - yrange_.first;



  CXXTLS_FOREACH(data_t::value_type const &i, data)
  {
    X_t x = i.first;
    Y_t y = i.second;

    // slide the input data so that runs from 0 - x_span, 0 - y_span

    x -= xrange_.first;
    y -= yrange_.first;

    // scale the data so it fits in the range 0-width, 0-height

    x *= width_;
    x /= x_span;

    y *= height_;
    y /= y_span;

    // clamp the data so no array index errors are likely

    int x_int = static_cast<int>(x);
    int y_int = static_cast<int>(y);

    if(x_int <  0)      x_int = 0;
    if(x_int >= width_) x_int = width_-1;

    if(y_int < 0)        y_int = 0;
    if(y_int >= height_) y_int = height_ -1;

    data_[height_-1 - y_int][x_int]=star_;

  }

  dirty_ = true;

  
}

static void detrail(char *s)
{
  size_t l = strlen(s);

  while(l)
  {
    --l;

    if(s[l] != '0' &&
       s[l] != '.' &&
       s[l] != '-'
      )
    {
      s[l+1] = 0;
      return;
    }
  }

  if(l == 0)
  {
    s[0] = '0';
    s[1] = 0;
  }

}


void
ascii_chart::
print_helper(ostream& stream) const
  // print the chart and add right side and bottom annotations
{
  int i;

  //
  //  Print the stars and the horizontal annotations
  //

  {
    string tmp;

    if(static_cast<int>(width_) > static_cast<int>(title_.size()))
    {
      int count = (width_ - title_.size()) / 2;

      while(count--)
        tmp += ' ';

      stream << tmp << title_ << endl;

    }
    else
      stream << title_ << endl;
  }


  for(i=0; i < height_; ++i)
  {
    stream << data_[i] << "|";

    if( i == 0)
      stream << yrange_.second;
    else
    if( i == height_-1)
      stream << yrange_.first;
    else
    if( i == height_/2)
      stream << (yrange_.first + yrange_.second)/2;

    stream << endl;
    
  }

  //
  // put a row of dashes at the bottom of the stars and blanks plot
  //
  {
    string tmp;
    
    for(i=0; i < width_; ++i)
    {
      tmp += '-';
    }
    
    tmp += '+';
    
    stream << tmp << endl;
  }

  //
  //  Print the X annotations by manually printing the individual characters
  //  of the x range vertically instead of horizontally.
  //

  char buffer1[1000];
  char buffer2[1000];

  sprintf(buffer1, "%f", xrange_.first);
  sprintf(buffer2, "%f", xrange_.second);

  detrail(buffer1);
  detrail(buffer2);

  int b1_len = strlen(buffer1);
  int b2_len = strlen(buffer2);

  int max_len = (b1_len > b2_len ) 
                  ? b1_len 
                  : b2_len;

  vector<string> bottom(max_len);

  for(i=0; i < max_len; ++i)
  {
    int j;

    for(j=0; j < width_; ++j)
      bottom[i] += ' ';
  }

  for(i=0; i < b1_len; ++i)
    bottom[i][0] = buffer1[i];

  for(i=0; i < b2_len; ++i)
    bottom[i][width_-1] = buffer2[i];

  for(i=0; i < max_len; ++i)
   stream << bottom[i].c_str() << endl;
  
}
} // namespace cxxtls