vtkTensorGlyphColor Class Reference

scale and orient glyph(s) according to eigenvalues and eigenvectors of symmetrical part of tensor More...

#include <vtkTensorGlyphColor.h>

Inheritance diagram for vtkTensorGlyphColor:

Public Types
enum	{ COLOR_BY_SCALARS , COLOR_BY_EIGENVALUES }

Public Member Functions
vtkPolyData *	GetSource ()
void	SetColorModeToEigenvalues ()
void	SetColorModeToScalars ()
void	SetSourceConnection (int id, vtkAlgorithmOutput *algOutput)
void	SetSourceConnection (vtkAlgorithmOutput *algOutput)
void	SetSourceData (vtkPolyData *source)
	vtkBooleanMacro (ClampScaling, vtkTypeBool)
	vtkBooleanMacro (ColorGlyphs, vtkTypeBool)
	vtkBooleanMacro (ExtractEigenvalues, vtkTypeBool)
	vtkBooleanMacro (Scaling, vtkTypeBool)
	vtkBooleanMacro (Symmetric, vtkTypeBool)
	vtkBooleanMacro (ThreeGlyphs, vtkTypeBool)
	vtkGetMacro (ClampScaling, vtkTypeBool)
	vtkGetMacro (ColorGlyphs, vtkTypeBool)
	vtkGetMacro (ColorMode, int)
	vtkGetMacro (ExtractEigenvalues, vtkTypeBool)
	vtkGetMacro (Length, double)
	vtkGetMacro (MaxScaleFactor, double)
	vtkGetMacro (ScaleFactor, double)
	vtkGetMacro (Scaling, vtkTypeBool)
	vtkGetMacro (Symmetric, vtkTypeBool)
	vtkGetMacro (ThreeGlyphs, vtkTypeBool)
	vtkSetClampMacro (ColorMode, int, COLOR_BY_SCALARS, COLOR_BY_EIGENVALUES)
	vtkSetMacro (ClampScaling, vtkTypeBool)
	vtkSetMacro (ColorGlyphs, vtkTypeBool)
	vtkSetMacro (ExtractEigenvalues, vtkTypeBool)
	vtkSetMacro (Length, double)
	vtkSetMacro (MaxScaleFactor, double)
	vtkSetMacro (ScaleFactor, double)
	vtkSetMacro (Scaling, vtkTypeBool)
	vtkSetMacro (Symmetric, vtkTypeBool)
	vtkSetMacro (ThreeGlyphs, vtkTypeBool)
	vtkTypeMacro (vtkTensorGlyphColor, vtkPolyDataAlgorithm) void PrintSelf(ostream &os

Static Public Member Functions
static vtkTensorGlyphColor *	New ()

Data Fields
vtkIndent indent	override

Protected Member Functions
int	FillInputPortInformation (int port, vtkInformation *info) override
int	RequestData (vtkInformation *, vtkInformationVector **, vtkInformationVector *) override
int	RequestUpdateExtent (vtkInformation *, vtkInformationVector **, vtkInformationVector *) override
	vtkTensorGlyphColor ()
	~vtkTensorGlyphColor () override

Protected Attributes
vtkTypeBool	ClampScaling
vtkTypeBool	ColorGlyphs
int	ColorMode
vtkTypeBool	ExtractEigenvalues
double	Length
double	MaxScaleFactor
double	ScaleFactor
vtkTypeBool	Scaling
vtkTypeBool	Symmetric
vtkTypeBool	ThreeGlyphs

Private Member Functions
void	operator= (const vtkTensorGlyphColor &)=delete
	vtkTensorGlyphColor (const vtkTensorGlyphColor &)=delete

Detailed Description

scale and orient glyph(s) according to eigenvalues and eigenvectors of symmetrical part of tensor

vtkTensorGlyphColor is a filter that copies a geometric representation (specified as polygonal data) to every input point. The geometric representation, or glyph, can be scaled and/or rotated according to the tensor at the input point. Scaling and rotation is controlled by the eigenvalues/eigenvectors of the symmetrical part of the tensor as follows: For each tensor, the eigenvalues (and associated eigenvectors) are sorted to determine the major, medium, and minor eigenvalues/eigenvectors. The eigenvalue decomposition only makes sense for symmetric tensors, hence the need to only consider the symmetric part of the tensor, which is 1/2 (T + T.transposed()).

If the boolean variable ThreeGlyphs is not set the major eigenvalue scales the glyph in the x-direction, the medium in the y-direction, and the minor in the z-direction. Then, the glyph is rotated so that the glyph's local x-axis lies along the major eigenvector, y-axis along the medium eigenvector, and z-axis along the minor.

If the boolean variable ThreeGlyphs is set three glyphs are produced, each of them oriented along an eigenvector and scaled according to the corresponding eigenvector.

If the boolean variable Symmetric is set each glyph is mirrored (2 or 6 glyphs will be produced)

The x-axis of the source glyph will correspond to the eigenvector on output. Point (0,0,0) in the source will be placed in the data point. Variable Length will normally correspond to the distance from the origin to the tip of the source glyph along the x-axis, but can be changed to produce other results when Symmetric is on, e.g. glyphs that do not touch or that overlap.

Please note that when Symmetric is false it will generally be better to place the source glyph from (-0.5,0,0) to (0.5,0,0), i.e. centred at the origin. When symmetric is true the placement from (0,0,0) to (1,0,0) will generally be more convenient.

A scale factor is provided to control the amount of scaling. Also, you can turn off scaling completely if desired. The boolean variable ClampScaling controls the maximum scaling (in conjunction with MaxScaleFactor.) This is useful in certain applications where singularities or large order of magnitude differences exist in the eigenvalues.

If the boolean variable ColorGlyphs is set to true the glyphs are colored. The glyphs can be colored using the input scalars (SetColorModeToScalars), which is the default, or colored using the eigenvalues (SetColorModeToEigenvalues).

Another instance variable, ExtractEigenvalues, has been provided to control extraction of eigenvalues/eigenvectors. If this boolean is false, then eigenvalues/eigenvectors are not extracted, and the columns of the tensor are taken as the eigenvectors (the norm of column, always positive, is the eigenvalue). This allows additional capability over the vtkGlyph3D object. That is, the glyph can be oriented in three directions instead of one.

Thanks:

Thanks to Jose Paulo Moitinho de Almeida for enhancements.

See also

vtkGlyph3D vtkPointLoad vtkHyperStreamline

Definition at line 89 of file vtkTensorGlyphColor.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
COLOR_BY_SCALARS
COLOR_BY_EIGENVALUES

Definition at line 191 of file vtkTensorGlyphColor.h.

  {
      COLOR_BY_SCALARS,
      COLOR_BY_EIGENVALUES
  };

Constructor & Destructor Documentation

vtkTensorGlyphColor() [1/2]

vtkTensorGlyphColor::vtkTensorGlyphColor ( )

protected

~vtkTensorGlyphColor()

vtkTensorGlyphColor::~vtkTensorGlyphColor ( )

overrideprotecteddefault

vtkTensorGlyphColor() [2/2]

vtkTensorGlyphColor::vtkTensorGlyphColor ( const vtkTensorGlyphColor &  )

privatedelete

Member Function Documentation

FillInputPortInformation()

int vtkTensorGlyphColor::FillInputPortInformation ( int  port, vtkInformation *  info  )

overrideprotected

Definition at line 538 of file vtkTensorGlyphColor.cxx.

{
  if (port == 1)
  {
    info->Set(vtkAlgorithm::INPUT_REQUIRED_DATA_TYPE(), "vtkPolyData");
    return 1;
  }
  info->Set(vtkAlgorithm::INPUT_REQUIRED_DATA_TYPE(), "vtkDataSet");
  return 1;
}

GetSource()

vtkPolyData * vtkTensorGlyphColor::GetSource

(

)

Definition at line 528 of file vtkTensorGlyphColor.cxx.

{
  if (this->GetNumberOfInputConnections(1) < 1)
  {
    return nullptr;
  }
  return vtkPolyData::SafeDownCast(this->GetExecutive()->GetInputData(1, 0));
}

Referenced by RequestData().

New()

static vtkTensorGlyphColor * vtkTensorGlyphColor::New ( )

static

Construct object with scaling on and scale factor 1.0. Eigenvalues are extracted, glyphs are colored with input scalar data, and logarithmic scaling is turned off.

operator=()

void vtkTensorGlyphColor::operator= ( const vtkTensorGlyphColor &  )

privatedelete

RequestData()

int vtkTensorGlyphColor::RequestData ( vtkInformation *  , vtkInformationVector **  , vtkInformationVector *    )

overrideprotected

Definition at line 97 of file vtkTensorGlyphColor.cxx.

{
  // get the info objects
  vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
  vtkInformation *sourceInfo = inputVector[1]->GetInformationObject(0);
  vtkInformation *outInfo = outputVector->GetInformationObject(0);
 
  // get the input and output
  vtkDataSet *input = vtkDataSet::SafeDownCast(
    inInfo->Get(vtkDataObject::DATA_OBJECT()));
  vtkPolyData *source = vtkPolyData::SafeDownCast(
    sourceInfo->Get(vtkDataObject::DATA_OBJECT()));
  vtkPolyData *output = vtkPolyData::SafeDownCast(
    outInfo->Get(vtkDataObject::DATA_OBJECT()));
 
  vtkDataArray *inTensors;
  double tensor[9];
  vtkDataArray *inScalars;
  vtkIdType numPts, numSourcePts, numSourceCells, inPtId, i;
  int j;
  vtkPoints *sourcePts;
  vtkDataArray *sourceNormals;
  vtkCellArray *sourceCells, *cells;
  vtkPoints *newPts;
  vtkFloatArray *newScalars=nullptr;
  vtkFloatArray *newNormals=nullptr;
  double x[3], s;
  vtkTransform *trans;
  vtkCell *cell;
  vtkIdList *cellPts;
  int npts;
  vtkIdType *pts;
  vtkIdType ptIncr, cellId;
  vtkIdType subIncr;
  int numDirs, dir, eigen_dir, symmetric_dir;
  vtkMatrix4x4 *matrix;
  double *m[3], w[3], *v[3];
  double m0[3], m1[3], m2[3];
  double v0[3], v1[3], v2[3];
  double xv[3], yv[3], zv[3];
  double maxScale;
 
  numDirs = (this->ThreeGlyphs?3:1)*(this->Symmetric+1);
 
  // set up working matrices
  m[0] = m0; m[1] = m1; m[2] = m2;
  v[0] = v0; v[1] = v1; v[2] = v2;
 
  vtkDebugMacro(<<"Generating tensor glyphs");
 
  vtkPointData *outPD = output->GetPointData();
  inTensors = this->GetInputArrayToProcess(0, inputVector);
  inScalars = this->GetInputArrayToProcess(1, inputVector);
  numPts = input->GetNumberOfPoints();
 
  if ( !inTensors || numPts < 1 )
  {
    vtkErrorMacro(<<"No data to glyph!");
    return 1;
  }
 
  pts = new vtkIdType[source->GetMaxCellSize()];
  trans = vtkTransform::New();
  matrix = vtkMatrix4x4::New();
 
  //
  // Allocate storage for output PolyData
  //
  sourcePts = source->GetPoints();
  numSourcePts = sourcePts->GetNumberOfPoints();
  numSourceCells = source->GetNumberOfCells();
 
  newPts = vtkPoints::New();
  newPts->Allocate(numDirs*numPts*numSourcePts);
 
  // Setting up for calls to PolyData::InsertNextCell()
  if ( (sourceCells=source->GetVerts())->GetNumberOfCells() > 0 )
  {
    cells = vtkCellArray::New();
    cells->Allocate(numDirs*numPts*sourceCells->GetSize());
    output->SetVerts(cells);
    cells->Delete();
  }
  if ( (sourceCells=this->GetSource()->GetLines())->GetNumberOfCells() > 0 )
  {
    cells = vtkCellArray::New();
    cells->Allocate(numDirs*numPts*sourceCells->GetSize());
    output->SetLines(cells);
    cells->Delete();
  }
  if ( (sourceCells=this->GetSource()->GetPolys())->GetNumberOfCells() > 0 )
  {
    cells = vtkCellArray::New();
    cells->Allocate(numDirs*numPts*sourceCells->GetSize());
    output->SetPolys(cells);
    cells->Delete();
  }
  if ( (sourceCells=this->GetSource()->GetStrips())->GetNumberOfCells() > 0 )
  {
    cells = vtkCellArray::New();
    cells->Allocate(numDirs*numPts*sourceCells->GetSize());
    output->SetStrips(cells);
    cells->Delete();
  }
 
  // only copy scalar data through
  vtkPointData *pd = this->GetSource()->GetPointData();
  // generate scalars if eigenvalues are chosen or if scalars exist.
  if (this->ColorGlyphs &&
      ((this->ColorMode == COLOR_BY_EIGENVALUES) ||
       (inScalars && (this->ColorMode == COLOR_BY_SCALARS)) ) )
  {
    newScalars = vtkFloatArray::New();
    newScalars->SetNumberOfComponents(4);
    newScalars->Allocate(numDirs*numPts*numSourcePts);
    if (this->ColorMode == COLOR_BY_EIGENVALUES)
    {
      newScalars->SetName("MaxEigenvalue");
    }
    else
    {
      newScalars->SetName(inScalars->GetName());
    }
  }
  else
  {
    outPD->CopyAllOff();
    outPD->CopyScalarsOn();
    outPD->CopyAllocate(pd,numDirs*numPts*numSourcePts);
  }
  if ( (sourceNormals = pd->GetNormals()) )
  {
    newNormals = vtkFloatArray::New();
    newNormals->SetNumberOfComponents(3);
    newNormals->SetName("Normals");
    newNormals->Allocate(numDirs*3*numPts*numSourcePts);
  }
  //
  // First copy all topology (transformation independent)
  //
  for (inPtId=0; inPtId < numPts; inPtId++)
  {
    ptIncr = numDirs * inPtId * numSourcePts;
    for (cellId=0; cellId < numSourceCells; cellId++)
    {
      cell = this->GetSource()->GetCell(cellId);
      cellPts = cell->GetPointIds();
      npts = cellPts->GetNumberOfIds();
      for (dir=0; dir < numDirs; dir++)
      {
        // This variable may be removed, but that
        // will not improve readability
        subIncr = ptIncr + dir*numSourcePts;
        for (i=0; i < npts; i++)
        {
          pts[i] = cellPts->GetId(i) + subIncr;
        }
        output->InsertNextCell(cell->GetCellType(),npts,pts);
      }
    }
  }
  //
  // Traverse all Input points, transforming glyph at Source points
  //
  trans->PreMultiply();
 
  for (inPtId=0; inPtId < numPts; inPtId++)
  {
    ptIncr = numDirs * inPtId * numSourcePts;
 
    // Translation is postponed
    // Symmetric tensor support
    inTensors->GetTuple(inPtId, tensor);
    if (inTensors->GetNumberOfComponents() == 6)
    {
      vtkMath::TensorFromSymmetricTensor(tensor);
    }
 
    // compute orientation vectors and scale factors from tensor
    if ( this->ExtractEigenvalues ) // extract appropriate eigenfunctions
    {
      // We are interested in the symmetrical part of the tensor only, since
      // eigenvalues are real if and only if the matrice of reals is symmetrical
      for (j=0; j<3; j++)
      {
        for (i=0; i<3; i++)
        {
          m[i][j] = 0.5 * (tensor[i + 3 * j] + tensor[j + 3 * i]);
        }
      }
      vtkMath::Jacobi(m, w, v);
 
      //copy eigenvectors
      xv[0] = v[0][0]; xv[1] = v[1][0]; xv[2] = v[2][0];
      yv[0] = v[0][1]; yv[1] = v[1][1]; yv[2] = v[2][1];
      zv[0] = v[0][2]; zv[1] = v[1][2]; zv[2] = v[2][2];
    }
    else //use tensor columns as eigenvectors
    {
      for (i=0; i<3; i++)
      {
        xv[i] = tensor[i];
        yv[i] = tensor[i+3];
        zv[i] = tensor[i+6];
      }
      w[0] = vtkMath::Normalize(xv);
      w[1] = vtkMath::Normalize(yv);
      w[2] = vtkMath::Normalize(zv);
    }
 
    // compute scale factors
    w[0] *= this->ScaleFactor;
    w[1] *= this->ScaleFactor;
    w[2] *= this->ScaleFactor;
 
    if ( this->ClampScaling )
    {
      for (maxScale=0.0, i=0; i<3; i++)
      {
        if ( maxScale < fabs(w[i]) )
        {
          maxScale = fabs(w[i]);
        }
      }
      if ( maxScale > this->MaxScaleFactor )
      {
        maxScale = this->MaxScaleFactor / maxScale;
        for (i=0; i<3; i++)
        {
          w[i] *= maxScale; //preserve overall shape of glyph
        }
      }
    }
 
    // normalization is postponed
 
    // make sure scale is okay (non-zero) and scale data
    for (maxScale=0.0, i=0; i<3; i++)
    {
      if ( w[i] > maxScale )
      {
        maxScale = w[i];
      }
    }
    if ( maxScale == 0.0 )
    {
      maxScale = 1.0;
    }
    for (i=0; i<3; i++)
    {
      if ( w[i] == 0.0 )
      {
        w[i] = maxScale * 1.0e-06;
      }
    }
 
    // Now do the real work for each "direction"
 
    for (dir=0; dir < numDirs; dir++)
    {
      eigen_dir = dir%(this->ThreeGlyphs?3:1);
      symmetric_dir = dir/(this->ThreeGlyphs?3:1);
 
      // Remove previous scales ...
      trans->Identity();
 
      // translate Source to Input point
      input->GetPoint(inPtId, x);
      trans->Translate(x[0], x[1], x[2]);
 
      // normalized eigenvectors rotate object for eigen direction 0
      matrix->Element[0][0] = xv[0];
      matrix->Element[0][1] = yv[0];
      matrix->Element[0][2] = zv[0];
      matrix->Element[1][0] = xv[1];
      matrix->Element[1][1] = yv[1];
      matrix->Element[1][2] = zv[1];
      matrix->Element[2][0] = xv[2];
      matrix->Element[2][1] = yv[2];
      matrix->Element[2][2] = zv[2];
      trans->Concatenate(matrix);
 
      if (eigen_dir == 1)
      {
        trans->RotateZ(90.0);
      }
 
      if (eigen_dir == 2)
      {
        trans->RotateY(-90.0);
      }
 
      if (this->ThreeGlyphs)
      {
        trans->Scale(w[eigen_dir], this->ScaleFactor, this->ScaleFactor);
      }
      else
      {
        trans->Scale(w[0], w[1], w[2]);
      }
 
      // Mirror second set to the symmetric position
      if (symmetric_dir == 1)
      {
        trans->Scale(-1.,1.,1.);
      }
 
      // if the eigenvalue is negative, shift to reverse direction.
      // The && is there to ensure that we do not change the
      // old behaviour of vtkTensorGlyphColors (which only used one dir),
      // in case there is an oriented glyph, e.g. an arrow.
      if (w[eigen_dir] < 0 && numDirs > 1)
      {
        trans->Translate(-this->Length, 0., 0.);
      }
 
      // multiply points (and normals if available) by resulting
      // matrix
      trans->TransformPoints(sourcePts,newPts);
 
      // Apply the transformation to a series of points,
      // and append the results to outPts.
      if ( newNormals )
      {
        // a negative determinant means the transform turns the
        // glyph surface inside out, and its surface normals all
        // point inward. The following scale corrects the surface
        // normals to point outward.
        if (trans->GetMatrix()->Determinant() < 0)
        {
          trans->Scale(-1.0,-1.0,-1.0);
        }
        trans->TransformNormals(sourceNormals,newNormals);
      }
 
        // Copy point data from source
      if ( this->ColorGlyphs && inScalars &&
           (this->ColorMode == COLOR_BY_SCALARS) )
      {
        for (i=0; i < numSourcePts; i++)
        {
          auto st = inScalars->GetTuple(inPtId);
          newScalars->InsertTuple4(ptIncr+i,st[0],st[1],st[2],st[3]);
        }
      }
      else if (this->ColorGlyphs &&
               (this->ColorMode == COLOR_BY_EIGENVALUES) )
      {
        // If ThreeGlyphs is false we use the first (largest)
        // eigenvalue as scalar.
        s = w[eigen_dir];
        for (i=0; i < numSourcePts; i++)
        {
          newScalars->InsertTuple(ptIncr+i, &s);
        }
      }
      else
      {
        for (i=0; i < numSourcePts; i++)
        {
          outPD->CopyData(pd,i,ptIncr+i);
        }
      }
      ptIncr += numSourcePts;
    }
  }
  vtkDebugMacro(<<"Generated " << numPts <<" tensor glyphs");
  //
  // Update output and release memory
  //
  delete [] pts;
 
  output->SetPoints(newPts);
  newPts->Delete();
 
  if ( newScalars )
  {
    int idx = outPD->AddArray(newScalars);
    outPD->SetActiveAttribute(idx, vtkDataSetAttributes::SCALARS);
    newScalars->Delete();
  }
 
  if ( newNormals )
  {
    outPD->SetNormals(newNormals);
    newNormals->Delete();
  }
 
  output->Squeeze();
  trans->Delete();
  matrix->Delete();
 
  return 1;
}

References ClampScaling, COLOR_BY_EIGENVALUES, COLOR_BY_SCALARS, ColorGlyphs, ColorMode, ExtractEigenvalues, GetSource(), Length, m, m2, MaxScaleFactor, s, ScaleFactor, Symmetric, and ThreeGlyphs.

RequestUpdateExtent()

int vtkTensorGlyphColor::RequestUpdateExtent ( vtkInformation *  , vtkInformationVector **  , vtkInformationVector *    )

overrideprotected

Definition at line 65 of file vtkTensorGlyphColor.cxx.

{
  // get the info objects
  vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
  vtkInformation *sourceInfo = inputVector[1]->GetInformationObject(0);
  vtkInformation *outInfo = outputVector->GetInformationObject(0);
 
  if (sourceInfo)
  {
    sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER(),
                    0);
    sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES(),
                    1);
    sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS(),
                    0);
  }
 
  inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER(),
  outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER()));
  inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES(),
  outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES()));
  inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS(),
  outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS()));
  inInfo->Set(vtkStreamingDemandDrivenPipeline::EXACT_EXTENT(), 1);
 
  return 1;
}

SetColorModeToEigenvalues()

void vtkTensorGlyphColor::SetColorModeToEigenvalues ( )

inline

Definition at line 212 of file vtkTensorGlyphColor.h.

    {this->SetColorMode(COLOR_BY_EIGENVALUES);};

SetColorModeToScalars()

void vtkTensorGlyphColor::SetColorModeToScalars ( )

inline

Definition at line 210 of file vtkTensorGlyphColor.h.

    {this->SetColorMode(COLOR_BY_SCALARS);};

SetSourceConnection() [1/2]

void vtkTensorGlyphColor::SetSourceConnection	(	int	id,
		vtkAlgorithmOutput *	algOutput
	)

Specify a source object at a specified table location. New style. Source connection is stored in port 1. This method is equivalent to SetInputConnection(1, id, outputPort).

Definition at line 496 of file vtkTensorGlyphColor.cxx.

{
  if (id < 0)
  {
    vtkErrorMacro("Bad index " << id << " for source.");
    return;
  }
 
  int numConnections = this->GetNumberOfInputConnections(1);
  if (id < numConnections)
  {
    this->SetNthInputConnection(1, id, algOutput);
  }
  else if (id == numConnections && algOutput)
  {
    this->AddInputConnection(1, algOutput);
  }
  else if (algOutput)
  {
    vtkWarningMacro("The source id provided is larger than the maximum "
                    "source id, using " << numConnections << " instead.");
    this->AddInputConnection(1, algOutput);
  }
}

SetSourceConnection() [2/2]

void vtkTensorGlyphColor::SetSourceConnection ( vtkAlgorithmOutput *  algOutput )

inline

Definition at line 120 of file vtkTensorGlyphColor.h.

  {
      this->SetSourceConnection(0, algOutput);
  }

SetSourceData()

void vtkTensorGlyphColor::SetSourceData

(

vtkPolyData *

source

)

Specify the geometry to copy to each point. Note that this method does not connect the pipeline. The algorithm will work on the input data as it is without updating the producer of the data. See SetSourceConnection for connecting the pipeline.

Definition at line 522 of file vtkTensorGlyphColor.cxx.

{
  this->SetInputData(1, source);
}

vtkBooleanMacro() [1/6]

vtkTensorGlyphColor::vtkBooleanMacro	(	ClampScaling	,
		vtkTypeBool
	)

vtkBooleanMacro() [2/6]

vtkTensorGlyphColor::vtkBooleanMacro	(	ColorGlyphs	,
		vtkTypeBool
	)

vtkBooleanMacro() [3/6]

vtkTensorGlyphColor::vtkBooleanMacro	(	ExtractEigenvalues	,
		vtkTypeBool
	)

vtkBooleanMacro() [4/6]

vtkTensorGlyphColor::vtkBooleanMacro	(	Scaling	,
		vtkTypeBool
	)

vtkBooleanMacro() [5/6]

vtkTensorGlyphColor::vtkBooleanMacro	(	Symmetric	,
		vtkTypeBool
	)

vtkBooleanMacro() [6/6]

vtkTensorGlyphColor::vtkBooleanMacro	(	ThreeGlyphs	,
		vtkTypeBool
	)

vtkGetMacro() [1/10]

vtkTensorGlyphColor::vtkGetMacro	(	ClampScaling	,
		vtkTypeBool
	)

vtkGetMacro() [2/10]

vtkTensorGlyphColor::vtkGetMacro	(	ColorGlyphs	,
		vtkTypeBool
	)

vtkGetMacro() [3/10]

vtkTensorGlyphColor::vtkGetMacro	(	ColorMode	,
		int
	)

vtkGetMacro() [4/10]

vtkTensorGlyphColor::vtkGetMacro	(	ExtractEigenvalues	,
		vtkTypeBool
	)

vtkGetMacro() [5/10]

vtkTensorGlyphColor::vtkGetMacro	(	Length	,
		double
	)

vtkGetMacro() [6/10]

vtkTensorGlyphColor::vtkGetMacro	(	MaxScaleFactor	,
		double
	)

vtkGetMacro() [7/10]

vtkTensorGlyphColor::vtkGetMacro	(	ScaleFactor	,
		double
	)

vtkGetMacro() [8/10]

vtkTensorGlyphColor::vtkGetMacro	(	Scaling	,
		vtkTypeBool
	)

vtkGetMacro() [9/10]

vtkTensorGlyphColor::vtkGetMacro	(	Symmetric	,
		vtkTypeBool
	)

vtkGetMacro() [10/10]

vtkTensorGlyphColor::vtkGetMacro	(	ThreeGlyphs	,
		vtkTypeBool
	)

vtkSetClampMacro()

vtkTensorGlyphColor::vtkSetClampMacro	(	ColorMode	,
		int	,
		COLOR_BY_SCALARS	,
		COLOR_BY_EIGENVALUES
	)

Set the color mode to be used for the glyphs. This can be set to use the input scalars (default) or to use the eigenvalues at the point. If ThreeGlyphs is set and the eigenvalues are chosen for coloring then each glyph is colored by the corresponding eigenvalue and if not set the color corresponding to the largest eigenvalue is chosen. The recognized values are: COLOR_BY_SCALARS = 0 (default) COLOR_BY_EIGENVALUES = 1

vtkSetMacro() [1/9]

vtkTensorGlyphColor::vtkSetMacro	(	ClampScaling	,
		vtkTypeBool
	)

Turn on/off scalar clamping. If scalar clamping is on, the ivar MaxScaleFactor is used to control the maximum scale factor. (This is useful to prevent uncontrolled scaling near singularities.)

vtkSetMacro() [2/9]

vtkTensorGlyphColor::vtkSetMacro	(	ColorGlyphs	,
		vtkTypeBool
	)

Turn on/off coloring of glyph with input scalar data or eigenvalues. If false, or input scalar data not present, then the scalars from the source object are passed through the filter.

vtkSetMacro() [3/9]

vtkTensorGlyphColor::vtkSetMacro	(	ExtractEigenvalues	,
		vtkTypeBool
	)

Turn on/off extraction of eigenvalues from tensor.

vtkSetMacro() [4/9]

vtkTensorGlyphColor::vtkSetMacro	(	Length	,
		double
	)

Set/Get the distance, along x, from the origin to the end of the source glyph. It is used to draw the symmetric glyphs.

vtkSetMacro() [5/9]

vtkTensorGlyphColor::vtkSetMacro	(	MaxScaleFactor	,
		double
	)

Set/Get the maximum allowable scale factor. This value is compared to the combination of the scale factor times the eigenvalue. If less, the scale factor is reset to the MaxScaleFactor. The boolean ClampScaling has to be "on" for this to work.

vtkSetMacro() [6/9]

vtkTensorGlyphColor::vtkSetMacro	(	ScaleFactor	,
		double
	)

Specify scale factor to scale object by. (Scale factor always affects output even if scaling is off.)

vtkSetMacro() [7/9]

vtkTensorGlyphColor::vtkSetMacro	(	Scaling	,
		vtkTypeBool
	)

Turn on/off scaling of glyph with eigenvalues.

vtkSetMacro() [8/9]

vtkTensorGlyphColor::vtkSetMacro	(	Symmetric	,
		vtkTypeBool
	)

Turn on/off drawing a mirror of each glyph

vtkSetMacro() [9/9]

vtkTensorGlyphColor::vtkSetMacro	(	ThreeGlyphs	,
		vtkTypeBool
	)

Turn on/off drawing three glyphs

vtkTypeMacro()

vtkTensorGlyphColor::vtkTypeMacro	(	vtkTensorGlyphColor	,
		vtkPolyDataAlgorithm
	)		&

Field Documentation

ClampScaling

vtkTypeBool vtkTensorGlyphColor::ClampScaling

protected

Definition at line 251 of file vtkTensorGlyphColor.h.

Referenced by RequestData(), and vtkStandardNewMacro().

ColorGlyphs

vtkTypeBool vtkTensorGlyphColor::ColorGlyphs

protected

Definition at line 249 of file vtkTensorGlyphColor.h.

Referenced by RequestData(), and vtkStandardNewMacro().

ColorMode

int vtkTensorGlyphColor::ColorMode

protected

Definition at line 250 of file vtkTensorGlyphColor.h.

Referenced by RequestData(), and vtkStandardNewMacro().

ExtractEigenvalues

vtkTypeBool vtkTensorGlyphColor::ExtractEigenvalues

protected

Definition at line 248 of file vtkTensorGlyphColor.h.

Referenced by RequestData(), and vtkStandardNewMacro().

Length

double vtkTensorGlyphColor::Length

protected

Definition at line 255 of file vtkTensorGlyphColor.h.

Referenced by RequestData(), and vtkStandardNewMacro().

MaxScaleFactor

double vtkTensorGlyphColor::MaxScaleFactor

protected

Definition at line 252 of file vtkTensorGlyphColor.h.

Referenced by RequestData(), and vtkStandardNewMacro().

override

vtkIndent indent vtkTensorGlyphColor::override

Definition at line 93 of file vtkTensorGlyphColor.h.

ScaleFactor

double vtkTensorGlyphColor::ScaleFactor

protected

Definition at line 247 of file vtkTensorGlyphColor.h.

Referenced by RequestData(), and vtkStandardNewMacro().

Scaling

vtkTypeBool vtkTensorGlyphColor::Scaling

protected

Definition at line 246 of file vtkTensorGlyphColor.h.

Referenced by vtkStandardNewMacro().

Symmetric

vtkTypeBool vtkTensorGlyphColor::Symmetric

protected

Definition at line 254 of file vtkTensorGlyphColor.h.

Referenced by RequestData(), and vtkStandardNewMacro().

ThreeGlyphs

vtkTypeBool vtkTensorGlyphColor::ThreeGlyphs

protected

Definition at line 253 of file vtkTensorGlyphColor.h.

Referenced by RequestData(), and vtkStandardNewMacro().

---

The documentation for this class was generated from the following files:

• source/visualization/Vtk/include/vtkTensorGlyphColor.h
• source/visualization/Vtk/src/vtkTensorGlyphColor.cxx