NAME
vtkStreamer - abstract object implements integration of massless particle through vector field
SYNOPSIS
#include "/opt/vtk-c++/graphics/vtkStreamer.h"
class VTK_EXPORT vtkStreamer : public vtkDataSetToPolyDataFilter
vtkStreamer();
~vtkStreamer();
static vtkStreamer *New() {return new vtkStreamer;};
const char *GetClassName() {return "vtkStreamer";};
void PrintSelf(ostream& os, vtkIndent indent);
void SetStartLocation(int cellId, int subId, float pcoords[3]);
void SetStartLocation(int cellId, int subId, float r, float s, float t);
int GetStartLocation(int& subId, float pcoords[3]);
void SetStartPosition(float x[3]);
void SetStartPosition(float x, float y, float z);
float *GetStartPosition();
void Update();
void SetSource(vtkDataSet*);
void SetSource(vtkDataSet& );
vtkDataSet *GetSource();
void SetMaximumPropagationTime(float);
float GetMaximumPropagationTime();
void SetIntegrationDirection(int);
VTK_INTEGRATE_FORWARD,VTK_INTEGRATE_BOTH_DIRECTIONS);
int GetIntegrationDirection();
void SetIntegrationDirectionToForward()
{this->SetIntegrationDirection(VTK_INTEGRATE_FORWARD);};
void SetIntegrationDirectionToBackward()
{this->SetIntegrationDirection(VTK_INTEGRATE_BACKWARD);};
void SetIntegrationDirectionToIntegrateBothDirections()
{this->SetIntegrationDirection(VTK_INTEGRATE_BOTH_DIRECTIONS);};
char *GetIntegrationDirectionAsString();
void SetIntegrationStepLength(float);
float GetIntegrationStepLength();
void SetSpeedScalars(int);
int GetSpeedScalars();
void SpeedScalarsOn();
void SpeedScalarsOff();
void SetTerminalSpeed(float);
float GetTerminalSpeed();
void SetVorticity(int);
int GetVorticity();
void VorticityOn();
void VorticityOff();
DESCRIPTION
vtkStreamer is a filter that integrates a massless particle through a vector field. The integration is performed using second order Runge-Kutta method. vtkStreamer often serves as a base class for other classes that perform numerical integration through a vector field (e.g., vtkStreamLine).
Note that vtkStreamer can integrate both forward and backward in time, or in both directions. The length of the streamer is controlled by specifying an elapsed time. (The elapsed time is the time each particle travels.) Otherwise, the integration terminates after exiting the dataset or if the particle speed is reduced to a value less than the terminal speed.
vtkStreamer integrates through any type of dataset. As a result, if the dataset contains 2D cells such as polygons or triangles, the integration is constrained to lie on the surface defined by the 2D cells.
The starting point of streamers may be defined in three different ways. Starting from global x-y-z "position" allows
you to start a single streamer at a specified x-y-z coordinate. Starting from "location" allows you to start at a specified cell, subId, and parametric coordinate. Finally, you may specify a source object to start multiple streamers. If you start streamers using a source object, for each point in the source that is inside the dataset a streamer is created.
vtkStreamer implements the integration process in the Integrate() method. Because vtkStreamer does not implement the Execute() method that its superclass (i.e., Filter) requires, it is an abstract class. Its subclasses implement the execute method and use the Integrate() method, and then build their own representation of the integration path (i.e., lines, dashed lines, points, etc.).
SEE ALSO
vtkStreamLine vtkDashedStreamLine vtkStreamPoints
TYPE DEFINITIONS
struct _vtkStreamPoint {
DEFINED MACROS
VTK_INTEGRATE_FORWARD 0
VTK_INTEGRATE_BACKWARD 1
VTK_INTEGRATE_BOTH_DIRECTIONS 2
SUMMARY
void SetSource(vtkDataSet*)
void SetSource(vtkDataSet& )
Specify the source object used to generate starting points.
void SetMaximumPropagationTime(float)
Specify the maximum length of the Streamer expressed in elapsed time.
void SetIntegrationDirection(int)
Specify the direction in which to integrate the Streamer.
void SetIntegrationStepLength(float)
Specify a nominal integration step size (expressed as a fraction of the size of each cell).
void SetSpeedScalars(int)
Turn on/off the creation of scalar data from velocity magnitude. If off, and input dataset has scalars, input dataset scalars are used.
void SetTerminalSpeed(float)
Set/get terminal speed (i.e., speed is velocity magnitude). Terminal speed is speed at which streamer will
terminate propagation.
void SetVorticity(int)
Turn on/off the computation of vorticity. Vorticity is an indication of the rotation of the flow. In combination with vtkStreamLine and vtkTubeFilter can be used to create rotated tubes.
char *GetIntegrationDirectionAsString(void)
Return the integration direction as a character string.
vtkStreamer()
Construct object to start from position (0,0,0); integrate forward; terminal speed 0.0; vorticity computation off; integrations step length 0.2; and maximum propagation time 100.0.
void SetStartLocation(int cellId, int subId, float pcoords[3])
Specify the start of the streamline in the cell coordinate system. That is, cellId and subId (if composite cell), and parametric coordinates.
void SetStartLocation(int cellId, int subId, float r, float s, float t)
Specify the start of the streamline in the cell coordinate system. That is, cellId and subId (if composite cell), and parametric coordinates.
int GetStartLocation(int& subId, float pcoords[3])
Get the starting location of the streamline in the cell coordinate system.
void SetStartPosition(float x[3])
Specify the start of the streamline in the global coordinate system. Search must be performed to find initial cell to start integration from.
void SetStartPosition(float x, float y, float z)
Specify the start of the streamline in the global coordinate system. Search must be performed to find initial cell to start integration from.
float *GetStartPosition()
Get the start position in global x-y-z coordinates.
void Update()
Override update method because execution can branch two ways (via Input and Source).