vtkStreamer.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkStreamer.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkStreamer_h
#define vtkStreamer_h
 
#include "vtkFiltersFlowPathsModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h"
 
class vtkInitialValueProblemSolver;
class vtkMultiThreader;
 
#define VTK_INTEGRATE_FORWARD 0
#define VTK_INTEGRATE_BACKWARD 1
#define VTK_INTEGRATE_BOTH_DIRECTIONS 2
 
class VTKFILTERSFLOWPATHS_EXPORT vtkStreamer : public vtkPolyDataAlgorithm
{
public:
  vtkTypeMacro(vtkStreamer,vtkPolyDataAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  void SetStartLocation(vtkIdType cellId, int subId, double pcoords[3]);
 
 
  void SetStartLocation(vtkIdType cellId, int subId, double r, double s,
                        double t);
 
  vtkIdType GetStartLocation(int& subId, double pcoords[3]);
 
  void SetStartPosition(double x[3]);
 
  void SetStartPosition(double x, double y, double z);
 
  double *GetStartPosition();
 
 
  void SetSourceData(vtkDataSet *source);
  vtkDataSet *GetSource();
 
  void SetSourceConnection(vtkAlgorithmOutput* algOutput);
 
 
  vtkSetClampMacro(MaximumPropagationTime,double,0.0,VTK_DOUBLE_MAX);
  vtkGetMacro(MaximumPropagationTime,double);
 
 
  vtkSetClampMacro(IntegrationDirection,int,
                   VTK_INTEGRATE_FORWARD,VTK_INTEGRATE_BOTH_DIRECTIONS);
  vtkGetMacro(IntegrationDirection,int);
  void SetIntegrationDirectionToForward()
    {this->SetIntegrationDirection(VTK_INTEGRATE_FORWARD);};
  void SetIntegrationDirectionToBackward()
    {this->SetIntegrationDirection(VTK_INTEGRATE_BACKWARD);};
  void SetIntegrationDirectionToIntegrateBothDirections()
    {this->SetIntegrationDirection(VTK_INTEGRATE_BOTH_DIRECTIONS);};
  const char *GetIntegrationDirectionAsString();
 
 
  vtkSetClampMacro(IntegrationStepLength,double,0.0000001,VTK_DOUBLE_MAX);
  vtkGetMacro(IntegrationStepLength,double);
 
 
  vtkSetMacro(SpeedScalars,int);
  vtkGetMacro(SpeedScalars,int);
  vtkBooleanMacro(SpeedScalars,int);
 
 
  vtkSetMacro(OrientationScalars, int);
  vtkGetMacro(OrientationScalars, int);
  vtkBooleanMacro(OrientationScalars, int);
 
 
  vtkSetClampMacro(TerminalSpeed,double,0.0,VTK_DOUBLE_MAX);
  vtkGetMacro(TerminalSpeed,double);
 
 
  vtkSetMacro(Vorticity,int);
  vtkGetMacro(Vorticity,int);
  vtkBooleanMacro(Vorticity,int);
 
  vtkSetMacro( NumberOfThreads, int );
  vtkGetMacro( NumberOfThreads, int );
 
  vtkSetMacro( SavePointInterval, double );
  vtkGetMacro( SavePointInterval, double );
 
 
  void SetIntegrator(vtkInitialValueProblemSolver *);
  vtkGetObjectMacro ( Integrator, vtkInitialValueProblemSolver );
 
 
  vtkSetMacro(Epsilon,double);
  vtkGetMacro(Epsilon,double);
 
protected:
 
  vtkStreamer();
  ~vtkStreamer();
 
  // Integrate data
  void Integrate(vtkDataSet *input, vtkDataSet *source);
 
  // Controls where streamlines start from (either position or location).
  int StartFrom;
 
  // Starting from cell location
  vtkIdType StartCell;
  int StartSubId;
  double StartPCoords[3];
 
  // starting from global x-y-z position
  double StartPosition[3];
 
  //
  // Special classes for manipulating data
  //
  //BTX - begin tcl exclude
  //
  class StreamPoint {
  public:
    double    x[3];    // position
    vtkIdType cellId;  // cell
    int       subId;   // cell sub id
    double    p[3];    // parametric coords in cell
    double    v[3];    // velocity
    double    speed;   // velocity norm
    double    s;       // scalar value
    double    t;       // time travelled so far
    double    d;       // distance travelled so far
    double    omega;   // stream vorticity, if computed
    double    theta;   // rotation angle, if vorticity is computed
  };
 
  class StreamArray;
  friend class StreamArray;
  class StreamArray { //;prevent man page generation
  public:
    StreamArray();
    ~StreamArray()
      {
        delete [] this->Array;
      };
    vtkIdType GetNumberOfPoints() {return this->MaxId + 1;};
    StreamPoint *GetStreamPoint(vtkIdType i) {return this->Array + i;};
    vtkIdType InsertNextStreamPoint()
      {
        if ( ++this->MaxId >= this->Size )
          {
          this->Resize(this->MaxId);
          }
        return this->MaxId; //return offset from array
      }
    StreamPoint *Resize(vtkIdType sz); //reallocates data
    void Reset() {this->MaxId = -1;};
 
    StreamPoint *Array;     // pointer to data
    vtkIdType MaxId;        // maximum index inserted thus far
    vtkIdType Size;         // allocated size of data
    vtkIdType Extend;       // grow array by this amount
    double Direction;       // integration direction
  };
  //ETX
  //
 
  //array of streamers
  StreamArray *Streamers;
  vtkIdType NumberOfStreamers;
 
  // length of Streamer is generated by time, or by MaximumSteps
  double MaximumPropagationTime;
 
  // integration direction
  int IntegrationDirection;
 
  // the length (fraction of cell size) of integration steps
  double IntegrationStepLength;
 
  // boolean controls whether vorticity is computed
  int Vorticity;
 
  // terminal propagation speed
  double TerminalSpeed;
 
  // boolean controls whether data scalars or velocity magnitude are used
  int SpeedScalars;
 
  // boolean controls whether data scalars or vorticity orientation are used
  int OrientationScalars;
 
  // Prototype showing the integrator type to be set by the user.
  vtkInitialValueProblemSolver* Integrator;
 
  // A positive value, as small as possible for numerical comparison.
  // The initial value is 1E-12.
  double Epsilon;
 
  // Interval with which the stream points will be stored.
  // Useful in reducing the memory footprint. Since the initial
  // value is small, by default, it will store all/most points.
  double SavePointInterval;
 
  static VTK_THREAD_RETURN_TYPE ThreadedIntegrate( void *arg );
 
 
  vtkGetMacro( NumberOfStreamers, vtkIdType );
  StreamArray *GetStreamers() { return this->Streamers; };
 
  void InitializeThreadedIntegrate();
  vtkMultiThreader           *Threader;
  int                        NumberOfThreads;
 
  virtual int FillInputPortInformation(int port, vtkInformation *info);
 
private:
  vtkStreamer(const vtkStreamer&);  // Not implemented.
  void operator=(const vtkStreamer&);  // Not implemented.
};
 
 
inline const char *vtkStreamer::GetIntegrationDirectionAsString()
{
  if ( this->IntegrationDirection == VTK_INTEGRATE_FORWARD )
    {
    return "IntegrateForward";
    }
  else if ( this->IntegrationDirection == VTK_INTEGRATE_BACKWARD )
    {
    return "IntegrateBackward";
    }
  else
    {
    return "IntegrateBothDirections";
    }
}
 
#endif