PeriodicBinaryTransform.cxx

Go to the documentation of this file.

#include "transforms/PeriodicBinaryTransform.h"

using namespace hippodraw;

PeriodicBinaryTransform::PeriodicBinaryTransform() :
  BinaryTransform(),
  m_x_limits ( -180.0, +180.0 ),
  m_y_limits ( - 90.0, + 90.0 ),
  m_x_offset ( 0.0 ),
  m_y_offset ( 0.0 )
{
}

PeriodicBinaryTransform::PeriodicBinaryTransform ( UnaryTransform * z,
                                                   bool is_periodic,
                                                   bool needs_grid,
                                                   bool needs_x_ticks,
                                                   bool needs_y_ticks,
                                                   double xlo, double xhi,
                                                   double ylo, double yhi) :
  BinaryTransform ( z, is_periodic, needs_grid, needs_x_ticks, needs_y_ticks ),
  m_x_limits ( xlo, xhi ),
  m_y_limits ( ylo, yhi ),
  m_x_offset ( 0.0 ),
  m_y_offset ( 0.0 )
{
}

PeriodicBinaryTransform::
PeriodicBinaryTransform ( const PeriodicBinaryTransform & t ) :
  BinaryTransform ( t ),
  m_x_limits( t.limitX() ),
  m_y_limits( t.limitY() ),
  m_x_offset( t.xOffset() ),
  m_y_offset( t.yOffset() )
{
}

PeriodicBinaryTransform::~PeriodicBinaryTransform ()
{
  // Does nothing 
}

const Range & PeriodicBinaryTransform::limitX () const
{
  return m_x_limits;
}


const Range & PeriodicBinaryTransform::limitY () const
{
  return m_y_limits;
}


double PeriodicBinaryTransform::xOffset() const
{
  return m_x_offset;
}

void PeriodicBinaryTransform::setXOffset( double x_offset ) 
{
  m_x_offset = x_offset;
}

double PeriodicBinaryTransform::yOffset() const
{
  return m_y_offset;
}

void PeriodicBinaryTransform::setYOffset( double y_offset )
{
  
  m_y_offset = y_offset;
}


double
PeriodicBinaryTransform::
moduloAdd( double a1, double a2, hippodraw::Axes::Type axis ) const
{
  if ( axis == Axes::X ) {
    return moduloAddX ( a1,  a2);
  }
  else if ( axis == Axes::Y ) {
    return moduloAddY ( a1,  a2);
  }
  else  return a1 + a2;
}

double
PeriodicBinaryTransform::
moduloSub( double s1, double s2, hippodraw::Axes::Type axis ) const
{
  if ( axis == Axes::X ) {
    return moduloSubX ( s1,  s2);
  }
  else if ( axis == Axes::Y ) {
    return moduloSubY ( s1,  s2);
  }
  else return s1 - s2;
}

double PeriodicBinaryTransform::moduloAddX( double x1, double x2 ) const
{
  if ( x2 < -DBL_EPSILON )
    return moduloSubX ( x1,  -x2 );
  
  double overshoot = x1 + x2 - m_x_limits.high();
  
  if ( overshoot > DBL_EPSILON ) {
    return  m_x_limits.low() + overshoot;
  }
  else {
    return x1 + x2;  
  }
}

double PeriodicBinaryTransform::moduloSubX( double x1, double x2 ) const
{
  if ( x2 < -DBL_EPSILON )
    return moduloAddX ( x1, -x2 );
  
  double undershoot = m_x_limits.low() - ( x1 - x2 );

  if ( undershoot > DBL_EPSILON) 
    return  m_x_limits.high() - undershoot;
  else
    return x1 - x2;      
}


double PeriodicBinaryTransform::moduloAddY( double y1, double y2 ) const
{
  if ( y2 < -DBL_EPSILON ) return moduloSubY ( y1,  -y2 );
  
  double overshoot = y1 + y2 - m_y_limits.high();
    
  if ( overshoot > DBL_EPSILON ) {
    return  m_y_limits.low() + overshoot;
  }
  else {
    return y1 + y2;
  }
  
}

double PeriodicBinaryTransform::moduloSubY( double y1, double y2 ) const
{
  if ( y2 < -DBL_EPSILON ) return moduloAddY ( y1, -y2 );
  
  double undershoot = m_y_limits.low() - ( y1 - y2 );
    
  if ( undershoot > DBL_EPSILON )  return  m_y_limits.high() - undershoot;
  else return y1 - y2;
}

---