Graphics/vtkStreamTracer.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkStreamTracer.h,v $
  Language:  C++

  Copyright (c) 1993-2002 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 __vtkStreamTracer_h
#define __vtkStreamTracer_h

#include "vtkDataSetToPolyDataFilter.h"

#include "vtkInitialValueProblemSolver.h" // Needed for constants

class vtkDataArray;
class vtkFloatArray;
class vtkGenericCell;
class vtkIdList;
class vtkIntArray;
class vtkInterpolatedVelocityField;

class VTK_GRAPHICS_EXPORT vtkStreamTracer : public vtkDataSetToPolyDataFilter
{
public:
  vtkTypeRevisionMacro(vtkStreamTracer,vtkDataSetToPolyDataFilter);
  void PrintSelf(ostream& os, vtkIndent indent);

  static vtkStreamTracer *New();
  

  vtkSetVector3Macro(StartPosition, float);
  vtkGetVector3Macro(StartPosition, float);


  void SetSource(vtkDataSet *source);
  vtkDataSet *GetSource();

//BTX
  enum Units
  {
    TIME_UNIT,
    LENGTH_UNIT,
    CELL_LENGTH_UNIT
  };

  enum Solvers
  {
    RUNGE_KUTTA2,
    RUNGE_KUTTA4,
    RUNGE_KUTTA45,
    NONE,
    UNKNOWN
  };

  enum ReasonForTermination
  {
    OUT_OF_DOMAIN = vtkInitialValueProblemSolver::OUT_OF_DOMAIN,
    NOT_INITIALIZED = vtkInitialValueProblemSolver::NOT_INITIALIZED ,
    UNEXPECTED_VALUE = vtkInitialValueProblemSolver::UNEXPECTED_VALUE,
    OUT_OF_TIME = 4,
    OUT_OF_STEPS = 5,
    STAGNATION = 6
  };
//ETX


  void SetIntegrator(vtkInitialValueProblemSolver *);
  vtkGetObjectMacro ( Integrator, vtkInitialValueProblemSolver );
  void SetIntegratorType(int type);
  int GetIntegratorType();
  void SetIntegratorTypeToRungeKutta2()
    {this->SetIntegratorType(RUNGE_KUTTA2);};
  void SetIntegratorTypeToRungeKutta4()
    {this->SetIntegratorType(RUNGE_KUTTA4);};
  void SetIntegratorTypeToRungeKutta45()
    {this->SetIntegratorType(RUNGE_KUTTA45);};


  void SetMaximumPropagation(int unit, float max);
  void SetMaximumPropagation(float max);
  void SetMaximumPropagationUnit(int unit);
  int GetMaximumPropagationUnit();
  float GetMaximumPropagation();
  void SetMaximumPropagationUnitToTimeUnit()
    {this->SetMaximumPropagationUnit(TIME_UNIT);};
  void SetMaximumPropagationUnitToLengthUnit()
    {this->SetMaximumPropagationUnit(LENGTH_UNIT);};
  void SetMaximumPropagationUnitToCellLengthUnit()
    {this->SetMaximumPropagationUnit(CELL_LENGTH_UNIT);};          


  void SetMinimumIntegrationStep(int unit, float step);
  void SetMinimumIntegrationStepUnit(int unit);
  void SetMinimumIntegrationStep(float step);
  int GetMinimumIntegrationStepUnit();
  float GetMinimumIntegrationStep();
  void SetMinimumIntegrationStepUnitToTimeUnit()
    {this->SetMinimumIntegrationStepUnit(TIME_UNIT);};
  void SetMinimumIntegrationStepUnitToLengthUnit()
    {this->SetMinimumIntegrationStepUnit(LENGTH_UNIT);};
  void SetMinimumIntegrationStepUnitToCellLengthUnit()
    {this->SetMinimumIntegrationStepUnit(CELL_LENGTH_UNIT);};


  void SetMaximumIntegrationStep(int unit, float step);
  void SetMaximumIntegrationStepUnit(int unit);
  void SetMaximumIntegrationStep(float step);
  int GetMaximumIntegrationStepUnit();
  float GetMaximumIntegrationStep();
  void SetMaximumIntegrationStepUnitToTimeUnit()
    {this->SetMaximumIntegrationStepUnit(TIME_UNIT);};
  void SetMaximumIntegrationStepUnitToLengthUnit()
    {this->SetMaximumIntegrationStepUnit(LENGTH_UNIT);};
  void SetMaximumIntegrationStepUnitToCellLengthUnit()
    {this->SetMaximumIntegrationStepUnit(CELL_LENGTH_UNIT);};


  void SetInitialIntegrationStep(int unit, float step);
  void SetInitialIntegrationStepUnit(int unit);
  void SetInitialIntegrationStep(float step);
  int GetInitialIntegrationStepUnit();
  float GetInitialIntegrationStep();
  void SetInitialIntegrationStepUnitToTimeUnit()
    {this->SetInitialIntegrationStepUnit(TIME_UNIT);};
  void SetInitialIntegrationStepUnitToLengthUnit()
    {this->SetInitialIntegrationStepUnit(LENGTH_UNIT);};
  void SetInitialIntegrationStepUnitToCellLengthUnit()
    {this->SetInitialIntegrationStepUnit(CELL_LENGTH_UNIT);};


  vtkSetMacro(MaximumError, float);
  vtkGetMacro(MaximumError, float);


  vtkSetMacro(MaximumNumberOfSteps, vtkIdType);
  vtkGetMacro(MaximumNumberOfSteps, vtkIdType);


  vtkSetMacro(TerminalSpeed, float);
  vtkGetMacro(TerminalSpeed, float);

//BTX
  enum
  {
    FORWARD,
    BACKWARD,
    BOTH
  };
//ETX


  vtkSetClampMacro(IntegrationDirection, int, FORWARD, BOTH);
  vtkGetMacro(IntegrationDirection, int);
  void SetIntegrationDirectionToForward()
    {this->SetIntegrationDirection(FORWARD);};
  void SetIntegrationDirectionToBackward()
    {this->SetIntegrationDirection(BACKWARD);};
  void SetIntegrationDirectionToBoth()
    {this->SetIntegrationDirection(BOTH);};  


  vtkSetMacro(ComputeVorticity, int);
  vtkGetMacro(ComputeVorticity, int);
  vtkBooleanMacro(ComputeVorticity, int);


  vtkSetMacro(RotationScale, float);
  vtkGetMacro(RotationScale, float);

  void AddInput(vtkDataSet *in);

protected:

  vtkStreamTracer();
  ~vtkStreamTracer();

  // hide the superclass' AddInput() from the user and the compiler
  void AddInput(vtkDataObject *) 
    { vtkErrorMacro( << "AddInput() must be called with a vtkDataSet not a vtkDataObject."); };
  
  void Execute();
  void CalculateVorticity( vtkGenericCell* cell, float pcoords[3],
                           vtkFloatArray* cellVectors, float vorticity[3] );
  void Integrate(vtkPolyData* output,
                 vtkDataArray* seedSource, 
                 vtkIdList* seedIds,
                 vtkIntArray* integrationDirections,
                 float lastPoint[3]);
  int CheckInputs(vtkInterpolatedVelocityField*& func,
                  int* maxCellSize);

  vtkSetStringMacro(InputVectorsSelection);
  char *InputVectorsSelection;


  // starting from global x-y-z position
  float StartPosition[3];

  static const float EPSILON;
  float TerminalSpeed;

//BTX
  struct IntervalInformation
  {
    float Interval;
    int Unit;
  };

  IntervalInformation MaximumPropagation;
  IntervalInformation MinimumIntegrationStep;
  IntervalInformation MaximumIntegrationStep;
  IntervalInformation InitialIntegrationStep;

  void SetIntervalInformation(int unit, float interval,
                              IntervalInformation& currentValues);
  void SetIntervalInformation(int unit,IntervalInformation& currentValues);
  static float ConvertToTime(IntervalInformation& interval,
                             float cellLength, float speed);
  static float ConvertToLength(IntervalInformation& interval,
                               float cellLength, float speed);
  static float ConvertToCellLength(IntervalInformation& interval,
                                   float cellLength, float speed);
  static float ConvertToUnit(IntervalInformation& interval, int unit,
                             float cellLength, float speed);
  void ConvertIntervals(float& step, float& minStep, float& maxStep,
                        int direction, float cellLength, float speed);
//ETX

  void InitializeSeeds(vtkDataArray*& seeds,
                       vtkIdList*& seedIds,
                       vtkIntArray*& integrationDirections);
  
  int IntegrationDirection;

  // Prototype showing the integrator type to be set by the user.
  vtkInitialValueProblemSolver* Integrator;

  float MaximumError;
  vtkIdType MaximumNumberOfSteps;

  int ComputeVorticity;
  float RotationScale;

private:
  vtkStreamTracer(const vtkStreamTracer&);  // Not implemented.
  void operator=(const vtkStreamTracer&);  // Not implemented.
};


#endif

Generated on Thu Jan 22 15:46:48 2004 for VTK by Doxygen 1.3.4