vtkHyperStreamline.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkHyperStreamline.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 vtkHyperStreamline_h
#define vtkHyperStreamline_h
 
#include "vtkFiltersGeneralModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h"
 
#define VTK_INTEGRATE_FORWARD 0
#define VTK_INTEGRATE_BACKWARD 1
#define VTK_INTEGRATE_BOTH_DIRECTIONS 2
 
#define VTK_INTEGRATE_MAJOR_EIGENVECTOR 0
#define VTK_INTEGRATE_MEDIUM_EIGENVECTOR 1
#define VTK_INTEGRATE_MINOR_EIGENVECTOR 2
 
class vtkHyperArray;
 
class VTKFILTERSGENERAL_EXPORT vtkHyperStreamline : public vtkPolyDataAlgorithm
{
public:
  vtkTypeMacro(vtkHyperStreamline, vtkPolyDataAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkHyperStreamline* New();
 
  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() VTK_SIZEHINT(3);
 
 
  vtkSetClampMacro(MaximumPropagationDistance, double, 0.0, VTK_DOUBLE_MAX);
  vtkGetMacro(MaximumPropagationDistance, double);
 
 
  vtkSetClampMacro(
    IntegrationEigenvector, int, VTK_INTEGRATE_MAJOR_EIGENVECTOR, VTK_INTEGRATE_MINOR_EIGENVECTOR);
  vtkGetMacro(IntegrationEigenvector, int);
  void SetIntegrationEigenvectorToMajor()
  {
    this->SetIntegrationEigenvector(VTK_INTEGRATE_MAJOR_EIGENVECTOR);
  }
  void SetIntegrationEigenvectorToMedium()
  {
    this->SetIntegrationEigenvector(VTK_INTEGRATE_MEDIUM_EIGENVECTOR);
  }
  void SetIntegrationEigenvectorToMinor()
  {
    this->SetIntegrationEigenvector(VTK_INTEGRATE_MINOR_EIGENVECTOR);
  }
 
  void IntegrateMajorEigenvector() { this->SetIntegrationEigenvectorToMajor(); }
 
  void IntegrateMediumEigenvector() { this->SetIntegrationEigenvectorToMedium(); }
 
  void IntegrateMinorEigenvector() { this->SetIntegrationEigenvectorToMinor(); }
 
 
  vtkSetClampMacro(IntegrationStepLength, double, 0.001, 0.5);
  vtkGetMacro(IntegrationStepLength, double);
 
 
  vtkSetClampMacro(StepLength, double, 0.000001, 1.0);
  vtkGetMacro(StepLength, 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);
  }
 
 
  vtkSetClampMacro(TerminalEigenvalue, double, 0.0, VTK_DOUBLE_MAX);
  vtkGetMacro(TerminalEigenvalue, double);
 
 
  vtkSetClampMacro(NumberOfSides, int, 3, VTK_INT_MAX);
  vtkGetMacro(NumberOfSides, int);
 
 
  vtkSetClampMacro(Radius, double, 0.0001, VTK_DOUBLE_MAX);
  vtkGetMacro(Radius, double);
 
 
  vtkSetMacro(LogScaling, vtkTypeBool);
  vtkGetMacro(LogScaling, vtkTypeBool);
  vtkBooleanMacro(LogScaling, vtkTypeBool);
 
protected:
  vtkHyperStreamline();
  ~vtkHyperStreamline() override;
 
  // Integrate data
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int BuildTube(vtkDataSet* input, vtkPolyData* output);
 
  int FillInputPortInformation(int port, vtkInformation* info) override;
 
  // Flag indicates 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];
 
  // array of hyperstreamlines
  vtkHyperArray* Streamers;
  int NumberOfStreamers;
 
  // length of hyperstreamline in absolute distance
  double MaximumPropagationDistance;
 
  // integration direction
  int IntegrationDirection;
 
  // the length (fraction of cell size) of integration steps
  double IntegrationStepLength;
 
  // the length of the tube segments composing the hyperstreamline
  double StepLength;
 
  // terminal propagation speed
  double TerminalEigenvalue;
 
  // number of sides of tube
  int NumberOfSides;
 
  // maximum radius of tube
  double Radius;
 
  // boolean controls whether scaling is clamped
  vtkTypeBool LogScaling;
 
  // which eigenvector to use as integration vector field
  int IntegrationEigenvector;
 
private:
  vtkHyperStreamline(const vtkHyperStreamline&) = delete;
  void operator=(const vtkHyperStreamline&) = delete;
};
 
#endif