Plot2D.cpp

Go to the documentation of this file.

/**
\file    Plot2D.cpp
\brief   The plotting class.

\author  Glenn D. MacGougan (GDM)
\date    2007-12-19
\since   2007-12-19

\b "LICENSE INFORMATION" \n
Copyright (c) 2007, refer to 'author' doxygen tags \n
All rights reserved. \n

Redistribution and use in source and binary forms, with or without
modification, are permitted provided the following conditions are met: \n

- Redistributions of source code must retain the above copyright
  notice, this list of conditions and the following disclaimer. \n
- Redistributions in binary form must reproduce the above copyright
  notice, this list of conditions and the following disclaimer in the
  documentation and/or other materials provided with the distribution. \n
- The name(s) of the contributor(s) may not be used to endorse or promote 
  products derived from this software without specific prior written 
  permission. \n

THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS 
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
SUCH DAMAGE.
*/

#include <math.h>
#include <memory.h>
#include <float.h>
#include <string.h>
#include <ctype.h>
#include "Plot2D.h"

#define PLOT2D_MAX_PLO2D_ReadFromFile_BUFFER (8192)

#ifndef _CRT_SECURE_NO_DEPRECATE
#define _CRT_SECURE_NO_DEPRECATE
#endif


namespace namespace_Plot2D
{
  //___________________________________________________________________________


  /// struct specific for ReadFromFile and related functions (a simple linked list)
  typedef struct _listItem
  {
    bool    isReal;    //!< A boolean to indicate if real data or complex data is attached to this item.
    double  *rowptr;   //!< The pointer to real data.
    struct _listItem  *next;  //!< The pointer to the next item in the list.
  } _PLOT2D_structReadFromFileListElem;


  //___________________________________________________________________________


  /// This function gets the next valid line of data. Whitespace lines are skipped.
  static bool _PLOT2D_get_next_valid_data_line( 
    FILE *in,               //!< The input file pointer (input).
    char *linebuf,          //!< A exisiting buffer to store the input line (input/output).
    unsigned *line_length,  //!< The length of the line read (output).
    bool *atEOF             //!< A boolean to indicate if EOF has been reached.
    );

  /// Obtain the next row array from the string.
  static bool _PLOT2D_get_row_array_from_string( char *datastr, _PLOT2D_structReadFromFileListElem *L, const unsigned ncols );

  /// \brief  Determine the number of columns in the data string provided.
  /// \return true if successful, false otherwise.
  static bool _PLO2D_determine_nr_cols_in_data_str( const char *datastr, unsigned *ncols );


  /// \brief  Determine the matrix file delimiter and if a comment line is available.
  /// \return true if successful, false otherwise.
  static bool _PLOT2D_determine_file_delimiter( 
    const char *path,    //!< path to the input file
    char *delimiter,     //!< delimiter, 'b' is binary
    bool *hasComment     //!< bool to indicate if a comment line is present    
    );


  /// \brief  Read a real-only matrix from a file (ASCII formatted, any common delimiters).
  /// \return true if successful, false otherwise.
  static bool _PLOT2D_ReadFromFile( Plot2D::_PLOT2D_structMTX *M, const char *path );


  //___________________________________________________________________________
  

  bool _PLOT2D_get_next_valid_data_line( 
    FILE *in,               //!< The input file pointer (input).
    char *linebuf,          //!< A exisiting buffer to store the input line (input/output).
    unsigned *line_length,  //!< The length of the line read (output).
    bool *atEOF             //!< A boolean to indicate if EOF has been reached.
    )
  {
    unsigned i = 0;
    i = 0;
    *line_length = 0;
    while( i == *line_length )
    {
      if( fgets( linebuf, PLOT2D_MAX_PLO2D_ReadFromFile_BUFFER, in ) == NULL )
      {
        *atEOF = true;
        if( feof(in) )
        {
          // reached the end of the file properly
          fclose(in);        
          return true;
        }
        else if( ferror(in) != 0 )
        {
          // error in reading the datafile
          fclose(in);
          return false;        
        }
        else
        {
          // error in reading the datafile
          fclose(in);
          return false;
        }
      }  

      *line_length = (unsigned int)strlen(linebuf);
      for( i = 0; i < *line_length; i++ )
      {
        if( !isspace(linebuf[i]) )
          break;
      }
    }

    // provide some buffer room, in case of overreading the linebuffer.
    if( *line_length < PLOT2D_MAX_PLO2D_ReadFromFile_BUFFER-2 )
    {
      linebuf[*line_length] = '\0';
      linebuf[(*line_length)+1] = '\0';
    }

    return true;
  }



  bool _PLOT2D_determine_file_delimiter( 
    const char *path,    //!< path to the input file
    char *delimiter,     //!< delimiter, 'b' is binary
    bool *hasComment     //!< bool to indicate if a comment line is present    
    )
  { 
    unsigned i = 0;
    unsigned line_length = 0;   
    char line[PLOT2D_MAX_PLO2D_ReadFromFile_BUFFER];
    char *linebuf;  
    FILE *in;
    bool atEOF = false;

    *hasComment = false;

    // open the input file
    in = fopen( path, "r" );
    if( !in )
      return false;

    // get the first line of data (or the comment line)
    if( !_PLOT2D_get_next_valid_data_line( in, line, &line_length, &atEOF ) )
      return false;
    if( atEOF )
      return false;

    // check the first line with isalpha (the first line might be the comment line
    linebuf = (char *)line;
    for( i = 0; i < line_length; i++ )
    {
      if( isalpha( line[i] ) )
      {
        if( line[i] == 'e' || line[i] == 'E' || line[i] == '-' || line[i] == '+' || line[i] == '.' || line[i] == 'i' || line[i] == 'j' )
          continue;

        // first line is likely a comment line, store this for decoding later
        *hasComment = true;

        if( !_PLOT2D_get_next_valid_data_line( in, line, &line_length, &atEOF ) )
          return false;
        if( atEOF )
          return false;      

        linebuf = (char *)line;
        break;
      }
    }
    fclose( in ); 

    // default is whitespace
    *delimiter = 'w';

    if( strstr( linebuf, "," ) )  { *delimiter = ','; return true; }
    if( strstr( linebuf, ":" ) )  { *delimiter = ':'; return true; }
    if( strstr( linebuf, ";" ) )  { *delimiter = ';'; return true; }
    if( strstr( linebuf, "|" ) )  { *delimiter = '|'; return true; }
    if( strstr( linebuf, "`" ) )  { *delimiter = '`'; return true; }
    if( strstr( linebuf, "~" ) )  { *delimiter = '~'; return true; }
    if( strstr( linebuf, "!" ) )  { *delimiter = '!'; return true; }
    if( strstr( linebuf, "@" ) )  { *delimiter = '@'; return true; }
    if( strstr( linebuf, "#" ) )  { *delimiter = '#'; return true; }
    if( strstr( linebuf, "$" ) )  { *delimiter = '$'; return true; }
    if( strstr( linebuf, "%%" ) ) { *delimiter = '%'; return true; }
    if( strstr( linebuf, "^" ) )  { *delimiter = '^'; return true; }
    if( strstr( linebuf, "&" ) )  { *delimiter = '&'; return true; }
    if( strstr( linebuf, "*" ) )  { *delimiter = '*'; return true; }
    if( strstr( linebuf, "(" ) )  { *delimiter = '('; return true; }
    if( strstr( linebuf, ")" ) )  { *delimiter = ')'; return true; }
    if( strstr( linebuf, "_" ) )  { *delimiter = '_'; return true; }
    if( strstr( linebuf, "=" ) )  { *delimiter = '='; return true; }
    if( strstr( linebuf, "{" ) )  { *delimiter = '{'; return true; }
    if( strstr( linebuf, "}" ) )  { *delimiter = '}'; return true; }
    if( strstr( linebuf, "[" ) )  { *delimiter = '['; return true; }
    if( strstr( linebuf, "]" ) )  { *delimiter = ']'; return true; }
    if( strstr( linebuf, "\\" ) ) { *delimiter = '\\'; return true; }
    if( strstr( linebuf, "\'" ) ) { *delimiter = '\''; return true; }
    if( strstr( linebuf, "<" ) )  { *delimiter = '<'; return true; }
    if( strstr( linebuf, "<" ) )  { *delimiter = '<'; return true; }
    if( strstr( linebuf, ">" ) )  { *delimiter = '>'; return true; }
    if( strstr( linebuf, "?" ) )  { *delimiter = '?'; return true; }
    if( strstr( linebuf, "/" ) )  { *delimiter = '/'; return true; }

    return true;
  }



  bool _PLO2D_determine_nr_cols_in_data_str( const char *datastr, unsigned *ncols )
  { 
    unsigned i = 0;
    unsigned line_length;
    char c;
    bool wasLastCharData = false;
    double dtmp;
    int rv;

    if( !datastr )
      return false;

    line_length = (unsigned int)strlen(datastr);
    if( line_length == 0 )
      return false;

    // intialize ncols
    *ncols = 0;

    // advance over whitespace to the first data element  
    for( i = 0; i < line_length; i++ )
    {
      if( isspace(datastr[i]) )         
        continue;
      else 
        break;
    }  
    if( i == line_length )
    {
      // no data in the string
      return false;
    }

    // determine the number of columns in the matrix
    for( /* i */; i < line_length; i++ )
    {
      c = datastr[i];
      if( isdigit(c) || c == '.' || c == '-' || c == '+' )
      {
        if( !wasLastCharData )
        {
          // try to read in the data to be sure the element is valid
#ifndef _CRT_SECURE_NO_DEPRECATE
          rv = sscanf_s( &(datastr[i]), "%lf", &dtmp );
#else
          rv = sscanf( &(datastr[i]), "%lf", &dtmp );
#endif
          if( rv == 0 || rv == EOF )
          {
            // invalid element, file is corrupt
            (*ncols) = 0;
            return false;          
          }
          (*ncols)++;
        }
        wasLastCharData = true;
      }
      else if( c == 'e' || c == 'E' )
      {
        if( !wasLastCharData )
        {
          // the exponent should not be the leading character in 
          // a data element
          (*ncols) = 0;
          return false;
        }
        continue;
      }
      else
      {
        wasLastCharData = false;
      }
    }

    return true;
  }


  bool _PLOT2D_get_row_array_from_string( char *datastr, _PLOT2D_structReadFromFileListElem *L, const unsigned ncols )
  {
    unsigned i = 0;
    unsigned n; // number of columns read successfully
    unsigned line_length;
    char c;
    BOOL wasLastCharData = false;
    int rv;

    if( !datastr )
      return false;

    if( !L )
      return false;

    if( !L->rowptr )
      return false;

    line_length = (unsigned int)strlen(datastr);
    if( line_length == 0 )
      return false;

    // advance over whitespace to the first data element  
    for( i = 0; i < line_length; i++ )
    {
      if( isspace(datastr[i]) )         
        continue;
      else 
        break;
    }  
    if( i == line_length )
    {
      // no data in the string
      return false;
    }

    // read in one row of data
    n = 0;  
    for( /* i */; i < line_length; i++ )
    {
      c = datastr[i];
      if( isdigit(c) || c == '.' || c == '-' || c == '+' )
      {
        if( !wasLastCharData )
        {
          // try to read in the data to be sure the element is valid
#ifndef _CRT_SECURE_NO_DEPRECATE
          rv = sscanf_s( &(datastr[i]), "%lf", &(L->rowptr[n]) );
#else
          rv = sscanf( &(datastr[i]), "%lf", &(L->rowptr[n]) );
#endif
          if( rv == 0 || rv == EOF )
          {
            // invalid element, file is corrupt                    
            return false;          
          }
          n++;
          if( n == ncols )
            break;
        }
        wasLastCharData = true;
      }
      else if( c == 'e' || c == 'E' )
      {
        if( !wasLastCharData )
        {
          // the exponent should not be the leading character in 
          // a data element        
          return false;
        }
        continue;
      }
      else
      {
        wasLastCharData = false;
      }
    }

    if( n != ncols )
    {
      // the number of columns does not match
      return false;
    }

    return true;
  }




  // Reads in the matrix from the specified file using the indicated *delimiter
  // ReadFromFile is 'read smart' (it determines the size of the input matrix on its own)
  // The number of columns are first determined then all data is read into linked lists
  // until end of file is reached. Data is then stored in the matrix.
  bool _PLOT2D_ReadFromFile( Plot2D::_PLOT2D_structMTX *M, const char *path )
  {
    unsigned i = 0;
    unsigned j = 0;
    FILE *in = NULL;
    char delimiter = 0;
    char linebuf[PLOT2D_MAX_PLO2D_ReadFromFile_BUFFER];
    unsigned ncols = 0;
    unsigned nrows = 0;
    unsigned line_length = 0;
    bool hasCommentLine = false;  
    bool errorInReadingDataFile = false;
    bool atEOF = false;

    // a linked list of row arrays
    _PLOT2D_structReadFromFileListElem *L = NULL;
    _PLOT2D_structReadFromFileListElem *nL = NULL;
    _PLOT2D_structReadFromFileListElem head;
    head.next = NULL;
    head.rowptr = NULL;

    // check input
    if( !M )
      return false;

    M->data = NULL;
    M->nrows = 0;
    M->ncols = 0;

    // check path 
    if( !path  )
      return false;

    // check path exists
    in = fopen( path, "r" );
    if( !in )
      return false;
    fclose(in);

    // determine the file delimiter
    if( _PLOT2D_determine_file_delimiter( path, &delimiter, &hasCommentLine ) == false )  
      return false;

    // open the input file for full input operations
    in = fopen( path, "r" );
    if( !in )
      return false;

    // advance over whitespace lines at the beginning of the file
    if( !_PLOT2D_get_next_valid_data_line( in, linebuf, &line_length, &atEOF ) )
      return false;
    if( atEOF )
      return false;

    if( hasCommentLine )
    {
      if( !_PLOT2D_get_next_valid_data_line( in, linebuf, &line_length, &atEOF ) )
        return false;
      if( atEOF )
        return false;
    }

    // determine the number of columns in the first line of data
    if( _PLO2D_determine_nr_cols_in_data_str( linebuf, &ncols ) == false )
      return false;


    // super fast rowwise input routine
    // a rowwise matrix is constructed using a linked list approach
    // line by line input 
    nrows = 0;
    head.rowptr = (double*)malloc( ncols*sizeof(double) );
    // get the row data from the string and store it in the list item row array
    if( _PLOT2D_get_row_array_from_string( linebuf, &head, ncols ) == false )
    { 
      // must free head's rowarray   
      free( head.rowptr );
      return false;
    }
    nrows++;
    nL = &head;

    while(1)
    { 
      // get the next string of data
      if( !_PLOT2D_get_next_valid_data_line( in, linebuf, &line_length, &atEOF ) )
      {
        errorInReadingDataFile = true;
        break;
      }
      if( atEOF )
      {
        break;
      }

      // the 'current' list itme
      L = nL;

      // allocate the next list item
      nL = (_PLOT2D_structReadFromFileListElem*)malloc( sizeof( _PLOT2D_structReadFromFileListElem ) );
      if( !nL )
      {
        // memory allocate failure
        // must free the linked list
        errorInReadingDataFile = true;
        // must free head's rowarray   
        free( head.rowptr );
        return false;
      }
      // intialize the row 
      nL->rowptr = NULL;
      nL->next = NULL;
      // allocate the row
      nL->rowptr = (double*)malloc( ncols*sizeof(double) );
      if( !nL->rowptr )
      {
        // memory allocate failure
        // must free the linked list    
        errorInReadingDataFile = true;
        break;      
      }

      // store the pointer to the next list item
      // in the 'current'
      L->next = nL;

      // get the row data from the string and store it in the list item row array
      if( _PLOT2D_get_row_array_from_string( linebuf, nL, ncols ) == false )
      { 
        // must free the linked list          
        errorInReadingDataFile = true;
        break;      
      }
      nrows++;
    }

    if( errorInReadingDataFile )
    {
      // free the list
      L = head.next;
      while( L!=NULL )
      {
        nL = L->next;
        free( L->rowptr );
        free(L);
        L = nL;    
      }
      free( head.rowptr );

      return false;
    }

    // copy the list into a MTX object

    // allocate the row array of pointers
    M->data = (double*)malloc( nrows*ncols*sizeof(double) );
    if( !M->data )
      return false;

    L = &head;
    for( i = 0; i < nrows; i++ )
    {
      if( L == NULL )
      {
        // this should never happen
        free( M->data );
        return false;
      }
      memcpy( &(M->data[i*ncols]), L->rowptr, sizeof(double)*ncols );
      free( L->rowptr );
      L->rowptr = NULL;
      L = L->next;
    }

    // free the list items
    L = head.next;
    while( L!=NULL )
    {
      nL = L->next;
      if( L->rowptr )
      {
        // should never happen but just in case
        free( L->rowptr );
      }        
      free(L);
      L = nL;    
    }
    // free the head data
    if( head.rowptr )
    {
      // should never happen but just in case
      free( head.rowptr );
    }

    M->nrows = nrows;
    M->ncols = ncols;

    return true;
  }  


  Plot2D::~Plot2D()
  {
    int i = 0;

    if( m_mtx.data != NULL )
    {
      free( m_mtx.data );
      m_mtx.data = NULL;
    }
    for( i = 0; i < 12; i++ )
    {
      if( m_Series[i].X != NULL )
      {
        free(m_Series[i].X);
        m_Series[i].X = NULL;
      }
      if( m_Series[i].Y != NULL )
      {
        free(m_Series[i].Y);
        m_Series[i].Y = NULL;
      }
    }
  }


  Plot2D::Plot2D()
    : m_ArePlotOptionsSet(false),
    m_xmin(DBL_MAX),
    m_xmax(-DBL_MAX),
    m_ymin(DBL_MAX),
    m_ymax(-DBL_MAX)
  {
    int i = 0;    
    CPLOT_PlotOptionsInit( &m_opt );
    CPLOT_Init( &m_plot );

    for( i = 0; i < 12; i++ )
    {
      memset( &m_Series[i], 0, sizeof(CPLOT_structSeries) );
    }
  }

  void Plot2D::SetTitle( const std::string title )
  {
    m_title = title;
    m_opt.title = (char*)m_title.c_str();
  }

  bool Plot2D::SetNrSeries( const int nrSeries )
  {
    if( nrSeries >= 12 )
      return false;

    m_opt.numberOfSeries = nrSeries;

    return true;
  }

  bool Plot2D::SetPlotSize( const int width_cm, const int height_cm )
  {
    if( width_cm <= 0 || height_cm <= 0 )
      return false;

    m_opt.PlotSize_Width_cm = width_cm;
    m_opt.PlotSize_Height_cm = height_cm;

    return true;
  }

  bool Plot2D::Set_X_Axis_LowerLimit( const double value )
  {
    m_opt.x.lowerlimit.doNotUseDefault = true;
    m_opt.x.lowerlimit.val = value;    

    if( m_opt.x.upperlimit.doNotUseDefault )
    {
      if( m_opt.x.lowerlimit.val >= m_opt.x.upperlimit.val )
        return false;

    }
    return true;
  }

  bool Plot2D::Set_X_Axis_UpperLimit( const double value )
  {
    m_opt.x.upperlimit.doNotUseDefault = true;
    m_opt.x.upperlimit.val = value;    

    if( m_opt.x.lowerlimit.doNotUseDefault )
    {
      if( m_opt.x.lowerlimit.val >= m_opt.x.upperlimit.val )
        return false;

    }
    return true;
  }

  bool Plot2D::Set_X_Axis_TickStart( const double value )
  {
    m_opt.x.tickstart.doNotUseDefault = true;
    m_opt.x.tickstart.val = value;    

    if( m_opt.x.tickend.doNotUseDefault )
    {
      if( m_opt.x.tickstart.val >= m_opt.x.tickend.val )
        return false;
    }
    return true;
  }

  bool Plot2D::Set_X_Axis_TickSize( const double value )
  {
    m_opt.x.ticksize.doNotUseDefault = true;
    m_opt.x.ticksize.val = value;    
    return true;
  }

  bool Plot2D::Set_X_Axis_TickEnd( const double value )
  {
    m_opt.x.tickend.doNotUseDefault = true;
    m_opt.x.tickend.val = value;    

    if( m_opt.x.tickstart.doNotUseDefault )
    {
      if( m_opt.x.tickstart.val >= m_opt.x.tickend.val )
        return false;
    }
    return true;
  }

  bool Plot2D::Set_X_Label( const std::string label )
  {
    m_x_label = label;
    m_opt.x.label = (char*)m_x_label.c_str();
    return true;
  }

  bool Plot2D::Set_Y_Label( const std::string label )
  {
    m_y_label = label;
    m_opt.y.label = (char*)m_y_label.c_str();
    return true;
  }

  bool Plot2D::Set_X_Axis_isGridOn( const bool isGridOn )
  {
    m_opt.x.isGridOn = isGridOn;
    return true;
  }

  bool Plot2D::Set_Y_Axis_isGridOn( const bool isGridOn )
  {
    m_opt.y.isGridOn = isGridOn;
    return true;
  }



  bool Plot2D::Set_Y_Axis_LowerLimit( const double value )
  {
    m_opt.y.lowerlimit.doNotUseDefault = true;
    m_opt.y.lowerlimit.val = value;    

    if( m_opt.y.upperlimit.doNotUseDefault )
    {
      if( m_opt.y.lowerlimit.val >= m_opt.y.upperlimit.val )
        return false;

    }
    return true;
  }

  bool Plot2D::Set_Y_Axis_UpperLimit( const double value )
  {
    m_opt.y.upperlimit.doNotUseDefault = true;
    m_opt.y.upperlimit.val = value;    

    if( m_opt.y.lowerlimit.doNotUseDefault )
    {
      if( m_opt.y.lowerlimit.val >= m_opt.y.upperlimit.val )
        return false;

    }
    return true;
  }

  bool Plot2D::Set_Y_Axis_TickStart( const double value )
  {
    m_opt.y.tickstart.doNotUseDefault = true;
    m_opt.y.tickstart.val = value;    

    if( m_opt.y.tickend.doNotUseDefault )
    {
      if( m_opt.y.tickstart.val >= m_opt.y.tickend.val )
        return false;
    }
    return true;
  }

  bool Plot2D::Set_Y_Axis_TickSize( const double value )
  {
    m_opt.y.ticksize.doNotUseDefault = true;
    m_opt.y.ticksize.val = value;    
    return true;
  }

  bool Plot2D::Set_Y_Axis_TickEnd( const double value )
  {
    m_opt.y.tickend.doNotUseDefault = true;
    m_opt.y.tickend.val = value;    

    if( m_opt.y.tickstart.doNotUseDefault )
    {
      if( m_opt.y.tickstart.val >= m_opt.y.tickend.val )
        return false;
    }
    return true;
  }

  bool Plot2D::SetRightYLabel( 
    const std::string label,            //!< The description string.
    double y_label_right_scale_factor,  //!< The scale factor.
    double y_label_right_bias,          //!< The bias.
    CPLOT_enumColor color               //!< The color.
    )
  {
    if( label.empty() )
      return false;
    m_y_label_right = label;
    
    m_opt.y_label_right = (char *)m_y_label_right.c_str();
    m_opt.y_label_right_scale_factor = y_label_right_scale_factor;
    m_opt.y_label_right_bias = y_label_right_bias;
    m_opt.RightYLabelColor = color;
    return true;
  }

  bool Plot2D::SetGPSLabel( const int UTCOffset )
  {
    if( UTCOffset < 0 )
      return false;
    m_opt.useGPSLabel = true;
    m_opt.UTCOffset = UTCOffset;
    return true;
  }

  bool Plot2D::SetBackgroundColor( const CPLOT_enumColor color )
  {
    m_opt.figureBackgroundColor = color;
    return true;
  }
    

  void Plot2D::EnablePlotStatistics( const bool enable )
  {
    m_opt.plotStatistics = enable;    
  }

  void Plot2D::SetTheSeriesLabelsBelowThePlot( const bool setBelow )
  {
    m_opt.plotLabelOnRight = !setBelow;
  }

  bool Plot2D::SavePlotToBitmapFile( std::string filename )
  {
    if( !CPLOT_SaveToFile( &m_plot, filename.c_str() ) )
      return false;

    return true;
  }
  
  bool Plot2D::SetSeriesInfo( const unsigned index, PLOT2D_structSeriesInfo &series )
  {
    unsigned i = 0;
    unsigned n = 0;         // The number of rows in the file.
    double *X = NULL;       // The X array.
    double *Y = NULL;       // The Y array.

    double xmin = 0;
    double xmax = 0;
    double ymin = 0;
    double ymax = 0;
    
    if( index >= 12 )
      return false;

    if( index >= (unsigned)m_opt.numberOfSeries )
      return false;

    // Check if there is a need to load the data file or was it the last one used.
    if( m_prev_datapath.compare( series.DataPath ) != 0 )
    {
      if( m_mtx.data != NULL )
      {
        free( m_mtx.data );
        m_mtx.data = NULL;
        m_mtx.ncols = 0;
        m_mtx.nrows = 0;
      }      
      if( series.DataPath.compare( "stdin" ) == 0 )
      {
        // Data is input from stdin.
        // Read all the data line by line and save to a temporary file.
        FILE* fid = NULL;
        char buffer[8192];
        size_t buffer_length = 0;
        fid = fopen("_plot2d_stdin_.tmp", "w" );
        if( fid == NULL )        
          return false;
        do
        {
          if( fgets( buffer, 8192, stdin ) == NULL )
            break;
          buffer_length = strlen( buffer );
          if( buffer_length > 0 )
            fprintf( fid, buffer ); // newline is included in fgets          
        }
        while( buffer_length > 1 );
        fclose(fid);

        if( !_PLOT2D_ReadFromFile( &m_mtx, "_plot2d_stdin_.tmp" ) )
          return false;

        // Get rid of the temporary file.
        remove( "_plot2d_stdin_.tmp" );
      }
      else
      {
        if( !_PLOT2D_ReadFromFile( &m_mtx, series.DataPath.c_str() ) )
          return false;
      }
      m_prev_datapath = series.DataPath;
    }

    // Check special case of a single column matrix input.
    if( m_mtx.ncols == 1 && series.X_Column == 0 && series.Y_Column == 1 )
    {
      // Change the series column indexes to allow for plotting of the single column
      // The x column will be a 1 based index into the column vector.
      series.Y_Column = 0;
    }

    // Check the indices provided.
    if( series.X_Column >= m_mtx.ncols )
    {
      return false;
    }
    if( series.Y_Column >= m_mtx.ncols )
    {
      return false;
    }

    n = m_mtx.nrows;

    // Allocate memory for the vectors required.
    X = (double*)malloc( n*sizeof(double) );
    if( !X )
    {      
      return false;
    }
    Y = (double*)malloc( n*sizeof(double) );
    if( !Y )
    {
      free( X );      
      return false;
    }

    // Copy the columns used.
    if( series.X_Column == series.Y_Column && series.Y_Column == 0 && m_mtx.ncols == 1 )
    {
      for( i = 0; i < n; i++ )
      { 
        X[i] = i+1.0;
        Y[i] = m_mtx.data[i*m_mtx.ncols + series.Y_Column];
      }
    }
    else
    {
      for( i = 0; i < n; i++ )
      {      
        X[i] = m_mtx.data[i*m_mtx.ncols + series.X_Column];
        Y[i] = m_mtx.data[i*m_mtx.ncols + series.Y_Column];
      }
    }
    if( series.negate_X )
    {
      for( i = 0; i < n; i++ )
      {      
        X[i] *= -1;
      }
    }
    if( series.negate_Y )
    {
      for( i = 0; i < n; i++ )
      {      
        Y[i] *= -1;
      }
    }
    
    if( m_Series[index].X != NULL )
    {
      // The data is already set for this index. That's not good.
      free( m_Series[index].X );
      m_Series[index].X = NULL;
    }
    if( m_Series[index].Y != NULL )
    {
      // The data is already set for this index. That's not good.
      free( m_Series[index].Y );
      m_Series[index].Y = NULL;
    }
    m_Series[index].X = X;
    m_Series[index].Y = Y;
    m_Series[index].label = (char*)series.Label.c_str();
    m_Series[index].units = (char*)series.Units.c_str();
    m_Series[index].n = n;
    m_Series[index].connected = series.IsConnected;
    m_Series[index].markOutlierData = series.MarkOutlierData;
    m_Series[index].precision = series.Precision;
    m_Series[index].color = series.Color;


    // Determine the maximum and minimum values for this series.    
    // Why? because if we are plotting multiple series, we first have to
    // determine the windows maximum, minimums.
    xmin = DBL_MAX;
    xmax = -DBL_MAX;
    for( i = 0; i < n; i++ )
    {
      // ignore NaN and INF.
      if( CPLOT_IsNAN( X[i] ) || CPLOT_IsPostiveINF( X[i] ) || CPLOT_IsNegativeINF( X[i] ) )
        continue;

      if( X[i] < xmin )
      {
        xmin = X[i];
      }
      if( X[i] > xmax )
      {
        xmax = X[i];
      }            
    }

    ymin = DBL_MAX;
    ymax = -DBL_MAX;
    for( i = 0; i < n; i++ )
    {
      // ignore NaN and INF.
      if( CPLOT_IsNAN( Y[i] ) || CPLOT_IsPostiveINF( Y[i] ) || CPLOT_IsNegativeINF( Y[i] ) )
        continue;

      if( Y[i] < ymin )
      {
        ymin = Y[i];
      }
      if( Y[i] > ymax )
      {
        ymax = Y[i];
      }
    }

    if( xmin < m_xmin )
      m_xmin = xmin;
    if( xmax > m_xmax )
      m_xmax = xmax;
    if( ymin < m_ymin )
      m_ymin = ymin;
    if( ymax > m_ymax )
      m_ymax = ymax;
    
    return true;
  }

  bool Plot2D::PlotAll()
  {
    int i = 0;
    double val = 0;
    typedef struct 
    {
      double lowerlimit;
      double upperlimit;
      double tickstart;
      double ticksize;
      double tickend;
    } _structAxis;
    _structAxis x;
    _structAxis y;
    
    // First deal with determining the full window size 
    // use the max min values already determined for all series if needed.
    // We do this because otherwise the plot window dimensions are determined
    // by the first series to be plotted.

    // Special case - all defaults indicated
    if( !m_opt.x.lowerlimit.doNotUseDefault &&
      !m_opt.x.upperlimit.doNotUseDefault &&
      !m_opt.x.tickstart.doNotUseDefault &&
      !m_opt.x.tickend.doNotUseDefault )
    {
      val = m_xmin;
      if( val < 0 )
      {
        val = -ceil( -val * 10.0 ) / 10.0;
      }
      else
      {
        val = floor( val * 10.0 ) / 10.0;        
      }
      x.lowerlimit = val;

      val = m_xmax;
      if( val < 0 )
      {
        val = -floor( -val * 10.0 ) / 10.0;      
      }
      else
      {
        val = ceil( val * 10.0 ) / 10.0;        
      }
      x.upperlimit = val;


      if( x.lowerlimit == x.upperlimit )
      {
        x.lowerlimit -= x.lowerlimit/100.0;
        x.upperlimit += x.upperlimit/100.0;
      }

      x.tickstart = x.lowerlimit;
      x.ticksize = (x.upperlimit-x.lowerlimit)/5.0; 
      x.tickend = x.upperlimit;
    }
    else 
    {  
      // deal with mixed or all user specified case

      if( m_opt.x.lowerlimit.doNotUseDefault )
        x.lowerlimit = m_opt.x.lowerlimit.val;
      else
        x.lowerlimit = m_xmin;

      if( m_opt.x.upperlimit.doNotUseDefault )
        x.upperlimit = m_opt.x.upperlimit.val;
      else
        x.upperlimit = m_xmax;

      if( m_opt.x.tickstart.doNotUseDefault )
        x.tickstart = m_opt.x.tickstart.val;
      else
        x.tickstart = x.lowerlimit;

      if( m_opt.x.tickend.doNotUseDefault )
        x.tickend = m_opt.x.tickend.val;
      else
        x.tickend = x.upperlimit;

      if( m_opt.x.ticksize.doNotUseDefault )
        x.ticksize = m_opt.x.ticksize.val;
      else
        x.ticksize = (x.tickend - x.tickstart)/5.0;
    }
    if( x.lowerlimit == x.upperlimit )
      return false;
    if( x.tickstart == x.tickend )
      return false;
    if( x.ticksize <= 0.0 )
      return false;



    // Special case - all defaults indicated
    if( !m_opt.y.lowerlimit.doNotUseDefault &&
      !m_opt.y.upperlimit.doNotUseDefault &&
      !m_opt.y.tickstart.doNotUseDefault &&
      !m_opt.y.tickend.doNotUseDefault )
    {
      val = m_ymin;
      if( val < 0 )
      {
        val = -ceil( -val * 10.0 ) / 10.0;
      }
      else
      {
        val = floor( val * 10.0 ) / 10.0;        
      }
      y.lowerlimit = val;

      val = m_ymax;
      if( val < 0 )
      {
        val = -floor( -val * 10.0 ) / 10.0;      
      }
      else
      {
        val = ceil( val * 10.0 ) / 10.0;        
      }
      y.upperlimit = val;


      if( y.lowerlimit == y.upperlimit )
      {
        y.lowerlimit -= y.lowerlimit/100.0;
        y.upperlimit += y.upperlimit/100.0;
      }

      y.tickstart = y.lowerlimit;
      y.ticksize = (y.upperlimit-y.lowerlimit)/10.0; 
      y.tickend = y.upperlimit;
    }
    else 
    {  
      // deal with mixed or all user specified case

      if( m_opt.y.lowerlimit.doNotUseDefault )
        y.lowerlimit = m_opt.y.lowerlimit.val;
      else
        y.lowerlimit = m_ymin;

      if( m_opt.y.upperlimit.doNotUseDefault )
        y.upperlimit = m_opt.y.upperlimit.val;
      else
        y.upperlimit = m_ymax;

      if( m_opt.y.tickstart.doNotUseDefault )
        y.tickstart = m_opt.y.tickstart.val;
      else
        y.tickstart = y.lowerlimit;

      if( m_opt.y.tickend.doNotUseDefault )
        y.tickend = m_opt.y.tickend.val;
      else
        y.tickend = y.upperlimit;

      if( m_opt.y.ticksize.doNotUseDefault )
        y.ticksize = m_opt.y.ticksize.val;
      else
        y.ticksize = (y.tickend - y.tickstart)/10.0;
    }
    if( y.lowerlimit == y.upperlimit )
      return false;
    if( y.tickstart == y.tickend )
      return false;  
    if( y.ticksize <= 0.0 )
      return false;

    // All the values for lower, upper, and ticks are now set.

    m_opt.x.lowerlimit.val = x.lowerlimit;
    m_opt.x.upperlimit.val = x.upperlimit;
    m_opt.x.tickstart.val = x.tickstart;
    m_opt.x.ticksize.val = x.ticksize;
    m_opt.x.tickend.val = x.tickend;

    m_opt.x.lowerlimit.doNotUseDefault = TRUE;
    m_opt.x.upperlimit.doNotUseDefault = TRUE;
    m_opt.x.tickstart.doNotUseDefault = TRUE;
    m_opt.x.ticksize.doNotUseDefault = TRUE;
    m_opt.x.tickend.doNotUseDefault = TRUE;

    m_opt.y.lowerlimit.val = y.lowerlimit;
    m_opt.y.upperlimit.val = y.upperlimit;
    m_opt.y.tickstart.val = y.tickstart;
    m_opt.y.ticksize.val = y.ticksize;
    m_opt.y.tickend.val = y.tickend;

    m_opt.y.lowerlimit.doNotUseDefault = TRUE;
    m_opt.y.upperlimit.doNotUseDefault = TRUE;
    m_opt.y.tickstart.doNotUseDefault = TRUE;
    m_opt.y.ticksize.doNotUseDefault = TRUE;
    m_opt.y.tickend.doNotUseDefault = TRUE;

    if( !CPLOT_SetPlotOptions( &m_plot, &m_opt ) )
      return false;
    m_ArePlotOptionsSet = true;

    for( i = 0; i < m_opt.numberOfSeries; i++ )
    {
      if( m_Series[i].X == NULL ||  m_Series[i].Y == NULL )
        return false;

      if( !CPLOT_Plot( &m_plot, &m_Series[i] ) )
      {
        free( m_Series[i].X );
        free( m_Series[i].Y );
        m_Series[i].X = NULL;
        m_Series[i].Y = NULL;        
        return false;
      }

      free( m_Series[i].X );
      free( m_Series[i].Y );
      m_Series[i].X = NULL;
      m_Series[i].Y = NULL;
    }

    return true;
  }

  bool Plot2D::Plot( PLOT2D_structSeriesInfo &series )
  {
    unsigned i = 0;
    unsigned n = 0;         // The number of rows in the file.
    double *X = NULL;       // The X array.
    double *Y = NULL;       // The Y array.
    CPLOT_structSeries s;   // The deep level series struct.

    memset( &s, 0, sizeof(CPLOT_structSeries) );
    
    if( !m_ArePlotOptionsSet )
    {
      if( !CPLOT_SetPlotOptions( &m_plot, &m_opt ) )
        return false;
      m_ArePlotOptionsSet = true;
    }

    if( m_prev_datapath.compare( series.DataPath ) != 0 )
    {
      if( m_mtx.data != NULL )
      {
        free( m_mtx.data );
        m_mtx.data = NULL;
        m_mtx.ncols = 0;
        m_mtx.nrows = 0;
      }
      if( !_PLOT2D_ReadFromFile( &m_mtx, series.DataPath.c_str() ) )
        return false;
      m_prev_datapath = series.DataPath;
    }

    // Check the indices provided.
    if( series.X_Column >= m_mtx.ncols )
    {
      return false;
    }
    if( series.Y_Column >= m_mtx.ncols )
    {
      return false;
    }

    n = m_mtx.nrows;

    // Allocate memory for the vectors required.
    X = (double*)malloc( n*sizeof(double) );
    if( !X )
    {
      return false;
    }
    Y = (double*)malloc( n*sizeof(double) );
    if( !Y )
    {
      free( X );
      return false;
    }

    // Copy the columns used.
    for( i = 0; i < n; i++ )
    {
      X[i] = m_mtx.data[i*m_mtx.ncols + series.X_Column];
      Y[i] = m_mtx.data[i*m_mtx.ncols + series.Y_Column];
    }

    s.X = X;
    s.Y = Y;
    s.label = (char*)series.Label.c_str();
    s.units = (char*)series.Units.c_str();
    s.n = n;
    s.connected = series.IsConnected;
    s.markOutlierData = series.MarkOutlierData;
    s.precision = series.Precision;
    s.color = series.Color;
    
    if( !CPLOT_Plot( &m_plot, &s ) )
    {
      free( X );
      free( Y );
      X = NULL;
      Y = NULL;
      s.X = NULL;
      s.Y = NULL;        
      return false;
    }

    free( X );
    free( Y );
    X = NULL;
    Y = NULL;
    s.X = NULL;
    s.Y = NULL;    
    return true;
  }



  
} // end of namespace Plot2D;