BinsFunction.cxx

Go to the documentation of this file.

#ifdef HAVE_CONFIG_H
#include "config.h"
#else
#ifdef _MSC_VER
// For abs.
#include "msdevstudio/MSconfig.h"
#endif
#endif

#include "BinsFunction.h"

#include "datasrcs/DataPointTuple.h"
#include "functions/FunctionBase.h"

#include <algorithm>

#include <cmath>
#include <cassert>

using namespace hippodraw;

#ifdef ITERATOR_MEMBER_DEFECT
using namespace std;
#else
using std::atan;
using std::abs;
using std::list;
using std::vector;
#endif

BinsFunction::BinsFunction ( int nb, double ml, double mh )
  : m_x_range ( ml, mh )
{
  setNumberOfBins ( Axes::X, nb );
  m_values_dirty = true;
}

BinsFunction::BinsFunction ( const BinsFunction & binner )
  : m_num_bins ( binner.m_num_bins ), 
    m_x_range ( binner.m_x_range )
{
}

BinsFunction::~BinsFunction ()
{
}

BinsFunction * BinsFunction::clone () const
{
  return new BinsFunction ( *this );
}

void
BinsFunction::
setNumberOfBins ( hippodraw::Axes::Type axis, int nb )
{
  assert ( axis == Axes::X );

  m_num_bins = nb;

  m_values_dirty = true;
}

namespace dp = hippodraw::DataPoint2DTuple;

void 
BinsFunction::
resize ( unsigned int new_size, 
         std::list < std::vector < double > > & values )
{
  vector < double > row ( dp::SIZE );
  values.resize ( new_size, row );
}

void
BinsFunction::
createValuesArray ( std::list < std::vector < double > > & values )
{
  resize ( m_num_bins, values );

  double delta = m_x_range.length () / ( m_num_bins - 1 );
  double x = m_x_range.low ();
  list < vector < double >  > ::iterator it = values.begin();
  for ( ; it != values.end (); ++it ) {
    double y = m_function->operator() ( x );

    if ( y > DBL_MAX ) {
      y = m_function -> operator () ( x + 0.1 * delta );
    }

    vector < double > & row = *it;
    row [ dp::X ] = x;
    row [ dp::Y ] = y;

    x += delta;
  }
  smoothCurve ( values );
  m_values_dirty = false;
}


void
BinsFunction::
smoothCurve ( std::list < std::vector < double > > & values )
{
  double x_length = m_x_range.length ();
  double xv_length = m_xv_range.length ();
  double min_delta = 7.0 * x_length / xv_length;
  double maxKink = 5.0 * M_PI / 180.0;
  double kinkScale 
    = m_yv_range.length () / m_y_range.length ()
    * x_length / xv_length;

  vector < double > row ( dp::SIZE );
  list < vector < double > >:: iterator p = values.begin ();
  for ( ; ; p++ ) {
    list < vector < double>  >:: iterator it1, it2;
    it1 = p; it1++;
    it2 = p; it2++; it2++;
    if ( it2 == values.end () ) break;

    while ( true ) {

      const vector < double > & pv = *p;
      const vector < double > & pv1= *it1;
      const vector < double > & pv2 = *it2;

      double x0 = pv [ dp::X ];
      double x1 = pv1 [ dp::X ];
      double x2 = pv2 [ dp::X ];

      double delta1 = x1 - x0;
      double delta2 = x2 - x1;

      double ydelta1 = pv1 [ dp::Y ] - pv [ dp::Y ];
      double ydelta2 = pv2 [ dp::Y ] - pv1 [ dp::Y ];

      double kink 
        = atan ( ydelta2 / delta2 * kinkScale )
        - atan ( ydelta1 / delta1 * kinkScale );

      if ( abs ( kink ) <= maxKink
           || ( delta1 <= min_delta && delta2 <= min_delta ) ) {
        break;
      }
      if ( delta1 <= delta2 ) {
        double tx = 0.5 * ( x2 + x1 );
        double ty = m_function->operator () ( tx );
        row [ dp::X ] = tx;
        row [ dp::Y ] = ty;

        it2 = values.insert ( it2, row );
      }
      else {
        double tx = 0.5 * ( x1 + x0 );
        double ty = m_function->operator () ( tx );
        row [ dp::X ] = tx;
        row [ dp::Y ] = ty;
        it2 = it1;
        it1 = values.insert ( it1, row );
      }
    } // end while
  } // end for
}

void
BinsFunction::
setRangeOn ( hippodraw::Axes::Type axis, 
             const Range & d_range,
             const Range & v_range )
{
  assert ( axis == Axes::X || axis || Axes::Y );
  if ( axis == Axes::X ) {
    m_x_range = d_range;
    m_xv_range = v_range;
  }
  else { // Y
    m_y_range = d_range;
    m_yv_range = v_range;
  }
  m_values_dirty = true;
}

const Range &
BinsFunction::
setRange ( hippodraw::Axes::Type axis, 
           const Range & range, 
           bool )
{
  assert ( axis == Axes::X || axis == Axes::Y );
  if ( axis == Axes::X ) {
      m_x_range = range;
  }
  else { // Y
      m_y_range = range;
  }
  m_values_dirty = true;
  return range;
}

void BinsFunction::setFunction ( FunctionBase * function )
{
  m_function = function;
  m_values_dirty = true;
}

---