QtCut.cxx

Go to the documentation of this file.

// For truncation warning
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

#include "QtCut.h"

#include "PyDataSource.h"

#include "controllers/CutController.h"
#include "datasrcs/DataSource.h"
#include "datasrcs/TupleCut.h"
#include "plotters/Cut1DPlotter.h"
#include "plotters/Cut2DPlotter.h"
#include "axes/Range.h"
#include "axes/AxesType.h"


// with Python 2.3, include before qapplication.h to avoid conflict
// with symbol `slots'
#include <boost/python.hpp>

#include "qapplication.h"

using std::vector;
using namespace boost::python;

namespace hippodraw {
namespace Python {

void
export_QtCut()
{
  class_ <QtCut, bases<QtDisplay> >
    ( "Cut",
      "An object of this class applies a cut or filter on the data that is\n"
      "used as input to its target displays.",
      init < const DataSource&, 
             const std::vector < std::string > & >
      ( "Cut ( DataSource, sequence ) -> Cut\n"
        "Cut ( DataArray, sequence ) -> Cut\n"
        "Cut ( DataSource, sequence, Display, value, value ) -> Cut\n"
        "Cut ( DataArray, sequence, Display, value, value ) -> Cut\n"
        "\n"
        "Creates a Cut bound to DataSource.  For each form, the first\n"
        "argument is the DataSource and the second argument is sequence of\n"
        "strings specifying the binding.  The latter two forms apply the\n"
        "Cut to a Display with low and high values for the Cut range." ) )

    .def ( init < const DataSource &,
           const std::vector < std::string > &,
           QtDisplay *, double, double > () )

    .def (  init < const PyDataSource&, 
            const std::vector < std::string > & > () )

    .def ( init < const PyDataSource &,
           const std::vector < std::string > &,
           QtDisplay *, double, double > () )

    .def ( "addTarget", &QtCut::addTarget,
           "addTarget ( Display ) -> None\n"
           "\n"
           "Adds a Display to the list of targets." )

    .def ( "addTargets", &QtCut::addTargets,
           "addTargets ( sequence ) -> None\n"
           "\n"
           "Adds Display objects in the sequence to the list targets" )

    .def ( "setCutRange", &QtCut::setCutRange,
           "setCutRange ( value, value, string ) -> None\n"
           "\n"
           "Sets the range of the Cut.  Arguments are low and high values,\n"
           "and the axis." )

    .def ( "cutRange", &QtCut::cutRange,
           "cutRange () -> tuple\n"
           "\n"
           "Returns a pair of values of the range ofeach Cut." )

    .def ( "setEnabled", &QtCut::setEnabled,
           "setEnabled ( boolean ) -> None\n"
           "\n"
           "Sets the cut to be enabled or not" )

    .def ( "toggleInverted", &QtCut::toggleInverted,
           "toggleInverted () -> None\n"
           "\n"
           "Toggles the inversion status" )

    ;
}

} // namespace Python
} // namespace hippodraw

void
QtCut::
createCut ( const DataSource & nt,
            const std::vector < std::string > & binding )
{
  CutController * controller = CutController::instance ();
  m_plotter = controller -> createCut ( std::string(), &nt, binding );
}

QtCut::
QtCut ( const DataSource & nt, 
        const std::vector< std::string > & binding,
        QtDisplay * target, double low, double high  )
   : QtDisplay ( )
{
  createCut ( nt, binding );

  addTarget ( target );
  setCutRange ( low, high, "x" );
}

QtCut::
QtCut ( const PyDataSource & ds, 
        const std::vector< std::string > & binding,
        QtDisplay * target, double low, double high  )
   : QtDisplay ( )
{
  createCut ( ds.dataSource(), binding );

  addTarget ( target );
  setCutRange ( low, high, "x" );
}

QtCut::
QtCut ( const DataSource & nt, 
        const std::vector< std::string > & binding )
   : QtDisplay ( )
{
  createCut ( nt, binding );
}

QtCut::
QtCut ( const PyDataSource & nt, 
        const std::vector< std::string > & binding )
   : QtDisplay ( )
{
  createCut ( nt.dataSource (), binding );
}

QtCut::QtCut ( PlotterBase * plotter ) 
   : QtDisplay()
{
  CutPlotter * cut_plotter = dynamic_cast < CutPlotter * > ( plotter );
  assert ( cut_plotter != 0 );

  m_plotter = plotter;
}

void QtCut::addTarget ( QtDisplay * target )
{
  if (qApp) qApp->lock();

  CutController * controller = CutController::instance ();
  controller -> addCut ( m_plotter, target -> display () );
  
  if (qApp) qApp->unlock();
}

void QtCut::addTargets ( const std::vector < QtDisplay * > & targets )
{
  if (qApp) qApp->lock();

  CutController * controller = CutController::instance ();
  unsigned int size = targets.size ();
  for ( unsigned int i = 0; i < size; i++ ) {
    QtDisplay * target = targets [ i ];
    controller -> addCut ( m_plotter, target -> display () );
  }
  
  if (qApp) qApp->unlock();
}

void QtCut::setCutRange ( double low, double high, const std::string & axis )
{
  hippodraw::Axes::Type type = hippodraw::Axes::convert( axis );

  if (qApp) qApp->lock();
  
  CutPlotter * cut_plotter = dynamic_cast < CutPlotter * > ( m_plotter );
  assert ( cut_plotter != 0 );

  const Range range ( low, high );
  cut_plotter -> setCutRangeAt ( range, type );    

  if (qApp) qApp->unlock();
}


std::vector<double> QtCut::cutRange ()
{
  if (qApp) qApp->lock();

  std::vector<double> myCutRange;
  vector < const TupleCut * > cuts;
  m_plotter -> fillCutList ( cuts );

  for ( unsigned int i = 0; i < cuts.size(); i++ ) {
    const TupleCut * cut = cuts [ i ];
    const Range & range = cut -> getRange ();
    myCutRange.push_back ( range.low () );
    myCutRange.push_back ( range.high () );
  }
  if (qApp) qApp->unlock();

  return myCutRange;

}

void
QtCut::
setEnabled ( bool yes )
{
  if ( qApp ) qApp -> lock ();
  CutPlotter * plotter = dynamic_cast < CutPlotter * > ( m_plotter );
  plotter -> setEnabled ( yes );
  if (qApp) qApp->unlock();
}

void
QtCut::
toggleInverted ()
{
  if ( qApp ) qApp -> lock ();
  CutPlotter * plotter = dynamic_cast < CutPlotter * > ( m_plotter );
  plotter -> toggleInverted ();
  if (qApp) qApp->unlock();
}

---