src/aclvis/Tool.h

Go to the documentation of this file.

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 *
 * Visit http://people.web.psi.ch/adelmann/ for more details
 *
 ***************************************************************************/

#ifndef ACLVIS_TOOL_H
#define ACLVIS_TOOL_H

#ifdef IPPL_USE_STANDARD_HEADERS
#include <iostream>
using namespace std;
#else
#include <iostream.h>
#endif

#include <vtk.h>
#include <vtkXRenderWindow.h>

#define NUM_OF_TOOL_TYPES 10
enum ToolType {ReadField, ReadParticle, Slice, Iso, MIso, Point, Sphere, Render, \
VectorField, VectorParticle, Axes, LineTrace, Empty};

#define XY 2
#define YZ 0
#define XZ 1

class vizStructuredFieldDataType;
class vizParticleDataType;

#define NUM_OF_UPDATE_POLICY_TYPES 4
enum UpdatePolicyType {Zero, Once, Al, UpdateEmpty};

class Tool {
public:
           Tool();
  virtual ~Tool();

  void SetUpdatePolicy(UpdatePolicyType);
  UpdatePolicyType GetUpdatePolicy();
  int UpdateTestAndSet();

  void SetLocalDimensions(int *);
  void SetLocalOrigin(float *);
  void SetLocalAspectRatio(float *);
  void SetRange(float *);
  void SetAllValues(int *, float *, float *, float *);

  void GetLocalDimensions(int *);
  void GetLocalOrigin(float *);
  void GetLocalAspectRatio(float *);
  void GetRange(float *);
  void GetAllValues(int *, float *, float *, float *);


private:
  UpdatePolicyType updatePolicy;
  int              updateCount;

  int              dims[3];
  float            origin[3];
  float            aspect[3];
  float            range[2];
};


class ReadParticleTool : public vtkPolySource, public Tool {
public:
           ReadParticleTool();
  virtual ~ReadParticleTool();

  vizParticleDataType *GetVizData();
  int PrepareFinishedData(); // Place data into the polyData structure
                             // of the read tool
  void UpdateRange();

private:
  vizParticleDataType *vizData;
  void                 Execute();
};


class ReadFieldTool : public vtkStructuredPointsSource, public Tool {
public:
           ReadFieldTool();
  virtual ~ReadFieldTool();

  void UpdateAllValues();
  void UpdateDimensions();
  void UpdateOrigin();
  void UpdateAspect();
  void UpdateRange();

  void SetDimensions(int    dims[3]); 
  void SetAspectRatio(float aspr[3]);
  void SetOrigin(float      orig[3]);

  vizStructuredFieldDataType *GetVizData();
  int PrepareFinishedData(); // Place data into the data structure
                             // of the read tool
private:
  vizStructuredFieldDataType *vizData;   
  void         Execute();
};


class RenderTool : public Tool {
public:
  RenderTool();
  void              SetRenderer(vtkRenderer *);
  void              SetRenderWindow(vtkXRenderWindow *);

  vtkRenderer*      GetRenderer();
  vtkRenderWindow*  GetRenderWindow();

  void              ResetCamera();
  void              AddActors(vtkActor *);
  void              RemoveActors(vtkActor *);
  void              Render();

private:
  int number_of_actors;

  //new stuff
  vtkRenderWindowInteractor *iren;
  vtkRenderMaster           *render_master;
  vtkRenderWindow           *render_window;

  vtkRenderer               *renderer;
};


class FilterTool : public Tool {
public:
  FilterTool();
  ~FilterTool();
  void FilterToolInit(void *, RenderTool *);

  void           SetReadTool(void *);
  void           SetRenderTool(RenderTool *);

  void*          GetReadTool();
  RenderTool*    GetRenderTool();
  vtkActor*      GetActor(); 
  vtkPolyMapper* GetPolyMapper();

private:
  void          *readtool;
  RenderTool    *rendertool;
  ToolType       readtool_type;
  vtkActor      *actor;
  vtkPolyMapper *polyMapper;
};


class SliceTool : public FilterTool {
public:
  SliceTool(void *, RenderTool *);
  ~SliceTool();

  void   SetSliceType(int param_sliceType);
  void   SetSliceValue(float param_sliceValue);
  void   SetExtent();

  int    GetSliceType();
  float  GetSliceValue();
  float  GetLowerBound();
  float  GetUpperBound();
  float  GetValueRange();

  vtkStructuredPointsGeometryFilter* GetStructuredPointsGeometryFilter();


private:
  vtkStructuredPointsGeometryFilter *p1;

  int sliceType;
  int sliceValue;
};


class IsoSurfaceTool : public FilterTool {
public:
  IsoSurfaceTool(void *, RenderTool *);
  ~IsoSurfaceTool();

  void  SetNumContours(int param_numContours);
  void  SetContourSubRange(float *param_srange);

  int   GetNumContours();
  void  GetContourSubRange(float *param_srange);

  vtkContourFilter*  GetContourFilter();

private:
  vtkContourFilter *isoF;
  int numContours;
  float srange[2];
};


class PointTool : public FilterTool {
public:
  PointTool(void *, RenderTool *);
  ~PointTool();
};


class vizTraceTool : public FilterTool {
public:
  vizTraceTool();
  vizTraceTool(void *, RenderTool *);
  virtual ~vizTraceTool();

  int                SetTraceNumber(int num); // see traceNumber
  int                SetTraceIter(int iter);  //  see traceIter

  int                GetTraceNumber()   const;
  int                GetTraceIter()     const;
  vtkCollection*     GetTraceCollection();   // see traceCollection
  vtkAppendPolyData* Getapd();               // see apd
                     
                     // This function will add the new vtkPolyData to a
                     // vtkAppendPolyData object to allow for a particle trace
                     // if the traceNumber of the vizTraceTool is greater than 1
                     // To use the trace fuctionality, place this function in
                     // the MainWindow::UpdateTools method for your subclass 
  int                AppendPolyData(vtkPolyData *newPolyData);

                     // Used by AppendPolyData to control the mumber of
                     // vtkPolyData saved in the trace
  int                CullStalePolyData(int fromSetFlag=0);

                     // Used by AppendPolyData to control traceIter 
  int                IterateTraceIter(int amt = 1);               

protected:
  vtkAppendPolyData *apd;         //The data saved for the particle trace
  vtkCollection     *traceCollection; // Saves pointers to vtkDataSets in apd
  int                traceNumber; // # of time steps of data to keep
  int                traceIter;   // current # of saved updates on data 
};


class SphereTool : public vizTraceTool {
public:
  SphereTool(void *, RenderTool *);
  virtual ~SphereTool();

  vtkSphereSource*   GetSphereSource();

private:
  vtkGlyph3D        *glyph;
  vtkSphereSource   *sphere;
};


class vizVectorTool : public vizTraceTool {
public:
  vizVectorTool();
  virtual ~vizVectorTool();

  void        SetScaleFactor(float scaleFact);  // Added scaling of vector length
  void        SetScaleByValue(int togle);       // Scale by Vector (1) or Scalar (0)
  void        FlipTubeArrowFlag();              // If flag = 1, make tube arrows,
                                                // if flag = 0, make line arrows
  void        SetArrowTubeRadius(float rad);
  void        SetNumberOfTubeFacets(int numFacets);

  float       GetScaleFactor()         const;
  int         GetScaleByValue()        const; 
  int         GetTubeArrowFlag()       const;
  float       GetArrowTubeRadius()     const;
  int         GetNumberOfTubeFacets()  const;
  

  void  MakeUnitArrowPolyData(vtkPolyData *&arrowPolyData); 
                                            // Make a unit tube to
                                            // to represent the vectors.
                                            // it is scaled to the 
                                            // vector length
  
protected:
  vtkPolyData  *vectorRepPolyData;
  vtkGlyph3D   *vectGlyph;
  float         scaleFactor;
  int           scaleByValue; // if 0 scale by scalar, 
                              //if 1 scale by vector (not implemented)
  
  int           tubeArrow; // flag that determine wheather the arrow is made of lines or tubes
  float         arrowTubeRadius;
  int           numTubeFacets;
};


class vizVectorFieldTool : public vizVectorTool {
public:
  vizVectorFieldTool();
  vizVectorFieldTool(void *, RenderTool *);
  virtual ~vizVectorFieldTool();
};


class vizVectorParticleTool : public vizVectorTool {
public:
  vizVectorParticleTool();
  vizVectorParticleTool(void *, RenderTool *);
  virtual ~vizVectorParticleTool();
};


class vizAxesTool : public FilterTool {
public:
            vizAxesTool();
            vizAxesTool(void *param_readtool, RenderTool *param_rendertool);
  virtual  ~vizAxesTool();

  int       SetScaleFactor(float scaleFact);
  
  float     GetScaleFactor() const;
  int       GetMaxSideLenOfGlobalBoundingBox(RenderTool *ren, float& maxSide);
  int       GetGlobalBoundingBox(RenderTool *ren, float allBounds[6]);

private:
  vtkAxes  *axes;
  float     scaleFactor;
};


class vizParticleLineTraceTool : public vizTraceTool {
public:
  vizParticleLineTraceTool();
  vizParticleLineTraceTool(void *param_readtool, RenderTool *param_rendertool);
  ~vizParticleLineTraceTool();

  void     MakeAndAppendNewLines(vtkPolyData *newPD);
  void     TubeIt(vtkPolyData* polyLines);
  void     FlipTubeLinesFlag();
private:
  vtkPolyData    *currentPolyData;
  vtkPolyData    *newPolyData;
  vtkTubeFilter  *tubeFilter;
  int             tubeLines;
};


class vizPointData : public vtkUserDefined 
{
public:
           vizPointData();
  virtual ~vizPointData();

  vtkIntScalars *GetIds();

private:
  vtkIntScalars *ids;
};


class vizStructuredFieldDataType {
public:
  // possible different data structures for the vtk storage
  enum {ACLVIS_UNKNOWN, ACLVIS_SCALAR, ACLVIS_VECTOR, ACLVIS_TENSOR};

  vizStructuredFieldDataType();
  vizStructuredFieldDataType(unsigned numPts, int ptDataType = ACLVIS_UNKNOWN);
  virtual ~vizStructuredFieldDataType();

  int InitData(unsigned numPts, int ptDataType = ACLVIS_UNKNOWN);
                                  // Initialize with the number of 
                                  // points to be stored and the 
                                  // type of data stored at each point
                                  // using the above enum values.
   
  int InitPointDataType(int pdType); // To set the value of "type"
                                     // to one of the enum vals
  
  int AddScalar(float sc);                  // adds a scalar to "scalars"
  int AddScalar(int index, float sc);       // adds a scalar to "scalars"
  int AddVector(float vect[3]);             // adds a vector to "vectors"
  int AddVector(int index, float vect[3]);  // adds a vector to "vectors"

  int InsertFieldData(vtkDataSet *dataSet);
                              // Add place data into the polyData structure
                             // of the read tool

  int SetPointData(vtkDataSet *dataSet); //add the data structure to 
                                         //the given vtk data set

  int GetPointDataType() const; // To set the value of "type"

  void* GetPointData(); // return pointer to point data

protected:
  // data associated with each point "pointData"
  int type;
  union {
    vtkFloatScalars *scalars;
    vtkFloatVectors *vectors;
    vtkFloatTensors *tensors;
  };

  int             isPointData; // 0 no 1 yes
  int numPoints; // number of points in structure (particle or field)
                 // should be the same as the number of 
                 // pointData values 
};


class vizParticleDataType : public vizStructuredFieldDataType
{
public:
  vizParticleDataType();
  vizParticleDataType(unsigned numPts, int ptDataType = ACLVIS_UNKNOWN, 
                      int isIds = 1);
  virtual ~vizParticleDataType();

  int InitData(unsigned numPts, int ptDataType = ACLVIS_UNKNOWN, 
               int isIds = 1);
                                  // Initialize with the number of 
                                  // points to be stored and the 
                                  // type of data stored at each point
                                  // using the above enum values.
                                  // If particle id information will
                                  // be provide, set isIdInfo 1 to
                                  // initialize memory for storing the info.
   
  int InitIdInfo();  // initialize the IdInfo data.
  
  int AddPoint(float pt[3]);              // adds a point  to "points"
  int AddPoint(int index, float pt[3]);   // adds a point  to "points"
  int AddIdInfoVal(int idInf);            // adds a idinf  to "idInfo"
  int AddIdInfoVal(int index, int idInf); // adds a idinf  to "idInfo"


  int InsertParticleData(vtkPolyData *polyData);


  int SetPoints(vtkPolyData *polyData); // add the vtkPoints data structure 
                                        // to the given vtkPolyData

  int SetIdInfo(vtkDataSet *dataSet);

  int GetIsIdInfoFlag() const;
private:
  vtkFloatPoints *points;
  vtkCellArray   *cellArray;

  vizPointData   *idInfo; // To hold index into vtkFloatPoint array
                         // where the corresponding particle point
                         // (position) was stored during prev time
                         // step
  int             isIdInfo;  // 0 no 1 yes
};

#endif // ACLVIS_TOOL_H

/***************************************************************************
 * $RCSfile: Tool.h,v $   $Author: adelmann $
 * $Revision: 1.1.1.1 $   $Date: 2003/01/23 07:40:34 $
 * IPPL_VERSION_ID: $Id: Tool.h,v 1.1.1.1 2003/01/23 07:40:34 adelmann Exp $ 
 ***************************************************************************/

---