TFItem.h

Go to the documentation of this file.

//------------------------------------------------------------------------
//
//   Joe Kniss
//     6-20-03
//                   ________    ____   ___ 
//                  |        \  /    | /  /
//                  +---+     \/     |/  /
//                  +--+|  |\    /|     < 
//                  |  ||  | \  / |  |\  \ 
//                  |      |  \/  |  | \  \ 
//                   \_____|      |__|  \__\
//                       Copyright  2003 
//                      Joe Michael Kniss
//                   <<< jmk@cs.utah.edu >>>
//               "All Your Base are Belong to Us"
//-------------------------------------------------------------------------

/// TFItem.h
///  simianUI

#ifndef __SIMIAN_UI_TF_ITEM_DOT_H
#define __SIMIAN_UI_TF_ITEM_DOT_H

/// from commonQT
#include <canvas/CanvasItems.h>
/// from simianlib
#include <tf/TFBase.h>
#include <tf/TFElement.h>
/// vector of TFItems defined below
#include <vector>

/// define the 2D domain type,
/// tfSType defined in <simianlib>/tf/TFParams.h 
typedef gutz::vec2<STF::tfSType> tfVec2;
const tfVec2 tfVec2_bad = tfVec2(STF::tfSType_bad);
/// a transformation matrix
typedef gutz::mat3<STF::tfSType> tfMat3;
const tfMat3 tfMat3_bad = tfMat3(STF::tfSType_bad);


//////////////////////////////////////////////////////////////////////////
/// TFItem, generic base class, see TFItemSTD for some concrete 
///   example implementations.
/// This is the generic tf item that the TFView will see, for the most
///  part all external interactions are through the TFItemVec.
/// TFItems are the bridge between simianlib TFElements and the QT 
///  interface.  An items behavior should be defined by the Element
///  they represent, the Item's role is to comunicate changes to 
///  element and display them from the element.  You should endevor to
///  make sure "behavior" resides in the simianlib Element and 
///  only "interaction" and "display" stuff live in the Item. 
//////////////////////////////////////////////////////////////////////////

class TFItem : public PolygonEdit {
public:   

   TFItem(QCanvas *canvas, TFEltSP elt);
   virtual ~TFItem() { _elt = 0; }

   /// transfer function element that we own
   TFEltSP getElt() const      {return _elt;}
   void    setElt(TFEltSP elt) {_elt = elt;}

   /// which TF axies are we visualizing???
   /// could be exteded to 3D... later
   void    setAxisX(int elm) {_axisX = elm;}
   int     getAxisX() const  {return _axisX;}
   void    setAxisY(int elm) {_axisY = elm;}
   int     getAxisY() const  {return _axisY;}

   /// get/set Pos in TF element for the Current Axies
   tfVec2 getTFPosCA(int i);
   void   setTFPosCA(int i, tfVec2 pos);

   /// checks if anything in the TFElement changed
   ///  if it has, calls updateDef()
   void    update();

   /// indicate to parents or pointers that we need to
   /// be removed
   bool    deleteMe() const { return _done; }

   /// get the transformation
   virtual tfMat3  getXform() const    { return _xform; }
   virtual tfMat3  getInvXform() const { return _invXform; }

   /// transform a point (tf -> canvas)
   virtual tfVec2  xform(tfVec2 pt) const            { return _xform.tpoint(pt); }
   virtual STF::tfSType xformX(STF::tfSType x) const { return x * _xform[0] + _xform[6]; }
   virtual STF::tfSType xformY(STF::tfSType y) const { return y * _xform[4] + _xform[7]; }
   
   /// inverse transform (canvas -> tf)
   virtual tfVec2  invXform(tfVec2 pt) const            { return _invXform.tpoint(pt); }
   virtual STF::tfSType invXformX(STF::tfSType x) const { return x * _invXform[0] + _invXform[6]; }
   virtual STF::tfSType invXformY(STF::tfSType y) const { return y * _invXform[4] + _invXform[7]; }

   /// set the border space around tf, in pixels (canvas space)
   tfVec2 getBorder() const         {return _border;}
   void   setBorder(tfVec2 b)       {_border = b; setTransform();}
   
   /// set the scale factor to go from [0-1] tf space to "canvas space"
   /// and the inverse of that, ie. scale should probably just be 
   /// the canvas width and height.
   tfVec2  getScale() const          {return _scale;}
   tfVec2  getInvScale() const       {return _invScale;}
   void    setScale(tfVec2 scales);

protected:
   /// called by update, for subclasses
   virtual void updateDef() {}

   TFEltSP _elt;

   void setTransform();

   tfVec2 _scale;
   tfVec2 _invScale;
   tfVec2 _border;

   tfMat3 _xform;
   tfMat3 _invXform;

   int _axisX;
   int _axisY;

   int _lastEltMod;  /// id for last elt mod
   int _lastElmMod;  /// id for last element mod

   bool _done;
};

typedef gutz::SmartPtr<TFItem> TFItemSP;

//////////////////////////////////////////////////////////////////////////
/// TFItem Factory function, defined in "TFItemFactory.cpp"
///
/// this simple function generates the correct TFItem for each TFElement type
///   if you add a new TFElement type, you should also have a corresponding
///   TFItem, modify this funciton to produce the right one.
///  TODO: should this function be a static member of TFItemVec ?

TFItemSP genTFItem(TFEltSP elt, QCanvas *canvas);

/// 
//////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////
/// TFItemVec, manages a bunch of transfer function elements, and 
///   the tf itself, as far as QT is concerned
//////////////////////////////////////////////////////////////////////////

class TFItemVec : public std::vector<TFItemSP> {
public:

   typedef std::vector<TFItemSP>::iterator       TFItemVecIter;
   typedef std::vector<TFItemSP>::const_iterator TFItemVecConstIter;

   TFItemVec(QCanvas *canvas, TFBaseSP tf);
   virtual ~TFItemVec();

   void     setTF(TFBaseSP tf);
   TFBaseSP getTF() const { return _tf; }
   
   void     setCanvas(QCanvas *canvas);
   QCanvas *getCanvas() const { return _canvas; }

   /// call update on all items in vector,
   /// also sync up with the tf... 
   ///  (check for new or deleted elements)
   void update();

   void   setScale(tfVec2 scales)      { _scales = scales; update(); }
   tfVec2 getScale() const             { return _scales; }
   void   setBorder(tfVec2 border)     { _border = border; update(); }
   tfVec2 getBorder() const            { return _border; }

   /// get an item based on the Element it represents
   TFItemSP getItem(TFEltSP elt) const;

   /// add an item, will try to figure out what "kind"
   ///  of item based on the subclass of the elt, see
   ///  genTFItem() factory function (above)
   void     addItem(TFEltSP elt);

protected:
   void checkNewElts();
   void checkDelElts();

   TFBaseSP     _tf;
   QCanvas     *_canvas;
   tfVec2       _scales;
   tfVec2       _border;
};

#endif

---

Send questions, comments, and bug reports to: