VTK
vtkGenericStreamTracer.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkGenericStreamTracer.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
69 #ifndef vtkGenericStreamTracer_h
70 #define vtkGenericStreamTracer_h
71 
72 #include "vtkFiltersGenericModule.h" // For export macro
73 #include "vtkPolyDataAlgorithm.h"
74 
75 #include "vtkInitialValueProblemSolver.h" // Needed for constants
76 
77 class vtkDataArray;
79 class vtkIdList;
80 class vtkIntArray;
82 class vtkDataSet;
84 class vtkGenericDataSet;
85 
86 class VTKFILTERSGENERIC_EXPORT vtkGenericStreamTracer : public vtkPolyDataAlgorithm
87 {
88 public:
90  void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
91 
98  static vtkGenericStreamTracer *New();
99 
101 
106  vtkSetVector3Macro(StartPosition, double);
107  vtkGetVector3Macro(StartPosition, double);
109 
111 
114  void SetSourceData(vtkDataSet *source);
115  vtkDataSet *GetSource();
117 
122  void SetSourceConnection(vtkAlgorithmOutput* algOutput);
123 
124  int FillInputPortInformation(int port, vtkInformation* info) VTK_OVERRIDE;
125 
126  enum Units
127  {
130  CELL_LENGTH_UNIT
131  };
132 
133  enum Solvers
134  {
139  UNKNOWN
140  };
141 
143  {
147  OUT_OF_TIME = 4,
148  OUT_OF_STEPS = 5,
149  STAGNATION = 6
150  };
151 
153 
164  void SetIntegrator(vtkInitialValueProblemSolver *);
165  vtkGetObjectMacro ( Integrator, vtkInitialValueProblemSolver );
166  void SetIntegratorType(int type);
167  int GetIntegratorType();
169  {this->SetIntegratorType(RUNGE_KUTTA2);};
171  {this->SetIntegratorType(RUNGE_KUTTA4);};
173  {this->SetIntegratorType(RUNGE_KUTTA45);};
175 
177 
184  void SetMaximumPropagation(int unit, double max);
185  void SetMaximumPropagation(double max);
186  void SetMaximumPropagationUnit(int unit);
187  int GetMaximumPropagationUnit();
188  double GetMaximumPropagation();
190  {this->SetMaximumPropagationUnit(TIME_UNIT);};
192  {this->SetMaximumPropagationUnit(LENGTH_UNIT);};
194  {this->SetMaximumPropagationUnit(CELL_LENGTH_UNIT);};
196 
198 
206  void SetMinimumIntegrationStep(int unit, double step);
207  void SetMinimumIntegrationStepUnit(int unit);
208  void SetMinimumIntegrationStep(double step);
209  int GetMinimumIntegrationStepUnit();
210  double GetMinimumIntegrationStep();
212  {this->SetMinimumIntegrationStepUnit(TIME_UNIT);};
214  {this->SetMinimumIntegrationStepUnit(LENGTH_UNIT);};
216  {this->SetMinimumIntegrationStepUnit(CELL_LENGTH_UNIT);};
218 
220 
228  void SetMaximumIntegrationStep(int unit, double step);
229  void SetMaximumIntegrationStepUnit(int unit);
230  void SetMaximumIntegrationStep(double step);
231  int GetMaximumIntegrationStepUnit();
232  double GetMaximumIntegrationStep();
234  {this->SetMaximumIntegrationStepUnit(TIME_UNIT);};
236  {this->SetMaximumIntegrationStepUnit(LENGTH_UNIT);};
238  {this->SetMaximumIntegrationStepUnit(CELL_LENGTH_UNIT);};
240 
242 
251  void SetInitialIntegrationStep(int unit, double step);
252  void SetInitialIntegrationStepUnit(int unit);
253  void SetInitialIntegrationStep(double step);
254  int GetInitialIntegrationStepUnit();
255  double GetInitialIntegrationStep();
257  {this->SetInitialIntegrationStepUnit(TIME_UNIT);};
259  {this->SetInitialIntegrationStepUnit(LENGTH_UNIT);};
261  {this->SetInitialIntegrationStepUnit(CELL_LENGTH_UNIT);};
263 
265 
270  vtkSetMacro(MaximumError, double);
271  vtkGetMacro(MaximumError, double);
273 
275 
278  vtkSetMacro(MaximumNumberOfSteps, vtkIdType);
279  vtkGetMacro(MaximumNumberOfSteps, vtkIdType);
281 
283 
287  vtkSetMacro(TerminalSpeed, double);
288  vtkGetMacro(TerminalSpeed, double);
290 
292 
295  void SetIntegrationStepUnit(int unit)
296  {
297  this->SetInitialIntegrationStepUnit(unit);
298  this->SetMinimumIntegrationStepUnit(unit);
299  this->SetMaximumIntegrationStepUnit(unit);
300  }
302 
303  enum
304  {
307  BOTH
308  };
309 
311 
315  vtkSetClampMacro(IntegrationDirection, int, FORWARD, BOTH);
316  vtkGetMacro(IntegrationDirection, int);
318  {this->SetIntegrationDirection(FORWARD);};
320  {this->SetIntegrationDirection(BACKWARD);};
322  {this->SetIntegrationDirection(BOTH);};
324 
326 
331  vtkSetMacro(ComputeVorticity, int);
332  vtkGetMacro(ComputeVorticity, int);
333  vtkBooleanMacro(ComputeVorticity, int);
335 
337 
341  vtkSetMacro(RotationScale, double);
342  vtkGetMacro(RotationScale, double);
344 
346 
351  vtkGetStringMacro(InputVectorsSelection);
352  void SelectInputVectors(const char *fieldName)
353  {this->SetInputVectorsSelection(fieldName);}
355 
360 
365  void SetInterpolatorPrototype(vtkGenericInterpolatedVelocityField* ivf);
366 
367 protected:
369  ~vtkGenericStreamTracer() VTK_OVERRIDE;
370 
371  // hide the superclass' AddInput() from the user and the compiler
373  { vtkErrorMacro( << "AddInput() must be called with a vtkGenericDataSet not a vtkDataObject."); };
374 
376 
384  void CalculateVorticity(vtkGenericAdaptorCell* cell,
385  double pcoords[3],
386  vtkGenericAttribute *attribute,
387  double vorticity[3]);
388 
389  void Integrate(vtkGenericDataSet *input0,
390  vtkPolyData* output,
391  vtkDataArray* seedSource,
392  vtkIdList* seedIds,
393  vtkIntArray* integrationDirections,
394  double lastPoint[3],
396  void SimpleIntegrate(double seed[3],
397  double lastPoint[3],
398  double delt,
400  int CheckInputs(vtkGenericInterpolatedVelocityField*& func,
401  vtkInformationVector **inputVector);
402  void GenerateNormals(vtkPolyData* output, double* firstNormal);
403 
405 
406  vtkSetStringMacro(InputVectorsSelection);
407  char *InputVectorsSelection;
408 
409 
410  // starting from global x-y-z position
411  double StartPosition[3];
412 
413  static const double EPSILON;
415 
417 
419  {
420  double Interval;
421  int Unit;
422  };
423 
428 
429  void SetIntervalInformation(int unit, double interval,
430  IntervalInformation& currentValues);
431  void SetIntervalInformation(int unit,IntervalInformation& currentValues);
432  static double ConvertToTime(IntervalInformation& interval,
433  double cellLength, double speed);
434  static double ConvertToLength(IntervalInformation& interval,
435  double cellLength, double speed);
436  static double ConvertToCellLength(IntervalInformation& interval,
437  double cellLength, double speed);
438  static double ConvertToUnit(IntervalInformation& interval, int unit,
439  double cellLength, double speed);
440  void ConvertIntervals(double& step, double& minStep, double& maxStep,
441  int direction, double cellLength, double speed);
442 
443  void InitializeSeeds(vtkDataArray*& seeds,
444  vtkIdList*& seedIds,
445  vtkIntArray*& integrationDirections);
446 
448 
449  // Prototype showing the integrator type to be set by the user.
451 
452  double MaximumError;
454 
457 
459 
460 private:
461  vtkGenericStreamTracer(const vtkGenericStreamTracer&) VTK_DELETE_FUNCTION;
462  void operator=(const vtkGenericStreamTracer&) VTK_DELETE_FUNCTION;
463 };
464 
465 #endif
void SetMinimumIntegrationStepUnitToLengthUnit()
Specify the minimum step used in the integration expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT =...
void SetMaximumPropagationUnitToTimeUnit()
Specify the maximum length of the streamlines expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT = 1 ...
void SetIntegrationDirectionToBackward()
Specify whether the streamtrace will be generated in the upstream or downstream direction.
void SelectInputVectors(const char *fieldName)
If you want to generate traces using an arbitrary vector array, then set its name here...
vtkGenericInterpolatedVelocityField * InterpolatorPrototype
Store vtkAlgorithm input/output information.
abstract class to specify dataset behavior
Definition: vtkDataSet.h:62
virtual int RequestData(vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector)
This is called by the superclass.
void SetInitialIntegrationStepUnitToTimeUnit()
Specify the initial step used in the integration expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT =...
void SetInitialIntegrationStepUnitToCellLengthUnit()
Specify the initial step used in the integration expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT =...
void SetMinimumIntegrationStepUnitToTimeUnit()
Specify the minimum step used in the integration expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT =...
void AddInputData(vtkDataObject *)
Assign a data object as input.
void SetIntegrationDirectionToBoth()
Specify whether the streamtrace will be generated in the upstream or downstream direction.
vtkInitialValueProblemSolver * Integrator
int vtkIdType
Definition: vtkType.h:345
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:85
abstract class defined API for attribute data
void AddInput(vtkDataObject *)
IntervalInformation MinimumIntegrationStep
Proxy object to connect input/output ports.
static vtkPolyDataAlgorithm * New()
defines cell interface
dynamic, self-adjusting array of int
Definition: vtkIntArray.h:45
Superclass for algorithms that produce only polydata as output.
void SetInitialIntegrationStepUnitToLengthUnit()
Specify the initial step used in the integration expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT =...
a simple class to control print indentation
Definition: vtkIndent.h:39
list of point or cell ids
Definition: vtkIdList.h:36
IntervalInformation MaximumIntegrationStep
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:54
void SetMaximumIntegrationStepUnitToCellLengthUnit()
Specify the maximum step used in the integration expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT =...
vtkGetStringMacro(ExtensionsString)
Returns a string listing all available extensions.
vtkSetMacro(IgnoreDriverBugs, bool)
When set known driver bugs are ignored during driver feature detection.
void SetIntegrationDirectionToForward()
Specify whether the streamtrace will be generated in the upstream or downstream direction.
void SetIntegratorTypeToRungeKutta2()
Set/get the integrator type to be used in the stream line calculation.
boost::graph_traits< vtkGraph * >::vertex_descriptor source(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
void SetIntegratorTypeToRungeKutta4()
Set/get the integrator type to be used in the stream line calculation.
void SetMaximumPropagationUnitToLengthUnit()
Specify the maximum length of the streamlines expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT = 1 ...
Streamline generator.
IntervalInformation MaximumPropagation
int FillInputPortInformation(int port, vtkInformation *info) override
Fill the input port information objects for this algorithm.
void SetIntegratorTypeToRungeKutta45()
Set/get the integrator type to be used in the stream line calculation.
Store zero or more vtkInformation instances.
defines dataset interface
vtkBooleanMacro(IgnoreDriverBugs, bool)
When set known driver bugs are ignored during driver feature detection.
IntervalInformation InitialIntegrationStep
general representation of visualization data
Definition: vtkDataObject.h:64
void SetMaximumPropagationUnitToCellLengthUnit()
Specify the maximum length of the streamlines expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT = 1 ...
void SetMaximumIntegrationStepUnitToLengthUnit()
Specify the maximum step used in the integration expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT =...
#define max(a, b)
Interface for obtaining interpolated velocity values.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
void SetMaximumIntegrationStepUnitToTimeUnit()
Specify the maximum step used in the integration expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT =...
void SetMinimumIntegrationStepUnitToCellLengthUnit()
Specify the minimum step used in the integration expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT =...
Integrate a set of ordinary differential equations (initial value problem) in time.
void SetIntegrationStepUnit(int unit)
Simplified API to set an homogeneous unit across Min/Max/Init IntegrationStepUnit.