ColorBoxPointRep.cxx

Go to the documentation of this file.

#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

#include "ColorBoxPointRep.h"

#include "BinToColor.h"
#include "BinToColorFactory.h"

#include "datasrcs/DataPointTuple.h"
#include "datasrcs/DataSource.h"
#include "graphics/ViewBase.h"
#include "transforms/BinaryTransform.h"

#include <cassert>

using namespace hippodraw;

using std::vector;

ColorBoxPointRep::
ColorBoxPointRep ( )
  : PointRepBase ( "ColorBox", 0.0 )
{
  BinToColorFactory * factory = BinToColorFactory::instance ();
  m_bin_to_color = factory -> create ( "Rainbow" );
}

ColorBoxPointRep::ColorBoxPointRep ( const ColorBoxPointRep & point_rep )
  : PointRepBase ( point_rep )
{
  BinToColor * btc = point_rep.m_bin_to_color;

  m_bin_to_color = btc -> clone ();
}

ColorBoxPointRep::~ColorBoxPointRep()
{
  delete m_bin_to_color;
}

RepBase * ColorBoxPointRep::clone()
{
  return new ColorBoxPointRep( *this );
}

const BinToColor *
ColorBoxPointRep::
getValueTransform ( ) const
{
  return m_bin_to_color;
}

void
ColorBoxPointRep::
setValueTransform ( BinToColor * btc )
{
  delete m_bin_to_color;
  m_bin_to_color = btc;
}

namespace dp = hippodraw::DataPoint3DTuple;

void
ColorBoxPointRep::
drawProjectedValues ( const DataSource * ntuple,
                      TransformBase * transform,
                      ViewBase * view )
{
  const Range & range = view -> getRange ( Axes::Z );

  double high = range.high();
  double low = range.low();

  const BinaryTransform * bt
    = dynamic_cast < const BinaryTransform * > ( transform );
  assert ( bt != 0 );

  bt -> transformZ ( high );
  bt -> transformZ ( low );

  Range newrange ( low, high );
  m_bin_to_color->setRange ( newrange );
  const HippoRectangle & user_rect = view -> getUserRect ();

  bool isLinear = bt -> isLinearInXY ();
  bool surpress_zero = low == 0.0;

  unsigned int size = ntuple -> rows ();

  for ( unsigned int i = 0; i < size; i++ ) {
    const vector < double > & row = ntuple -> getRow ( i );

    double value = row [ dp::Z ];
    if ( surpress_zero && value == 0.0 ) continue;

    double half_xwidth = row [ dp::XERR ];
    double half_ywidth = row [ dp::YERR ];

    double x1 = row [ dp::X ] - half_xwidth;
    double y1 = row [ dp::Y ] - half_ywidth;
    double x2 = row [ dp::X ] + half_xwidth;
    double y2 = row [ dp::Y ] + half_ywidth;

    assert ( x1 < x2 && y1 < y2 );

    if ( isLinear == false ) {
      bt -> transform ( x1, y1 );
      bt -> transform ( x2, y2 );
    }

    user_rect.makeInBounds ( x1, y1 );
    user_rect.makeInBounds ( x2, y2 );

    if ( m_desel ) {
      const int gray = 226;
      view -> drawSquare ( x1, y1, x2, y2, gray, gray, gray );
      return;
    }

    bt -> transformZ ( value );
    if ( value > user_rect.getZ() ) {
       if ( !user_rect.isInDepth ( value ) ) {
          double x(0), y(0);
          user_rect.makeInBounds(x, y, value);
       }
       Color color;
       m_bin_to_color -> doubleToColor ( value, color );
       view -> drawSquare ( x1, y1, x2, y2,
                            color.getRed (), 
                            color.getGreen(), 
                            color.getBlue() );
    }
  }
}

---