Commit 80693cb1 authored by Mathieu Westphal's avatar Mathieu Westphal

Adding Angular Periodic Filter and Angular Periodic Array to VTK.

Support of tensor for vtkAngularPeriodicFilter

Adding 2nd Order tensor support ( 9 components array ) for angular periodic filter
via a vtkMatrix3x3
In order to support any type of data, has the array is templated, the data is always copied
back and forth locally to be able to rotate, even when input data is already correct type.

Correcting vtkPoints getBounds to use protected method GetScalarRange
parent 3f83a466
......@@ -106,6 +106,7 @@ include_directories(${VTK_SOURCE_DIR}/ThirdParty/utf8/source)
SET(Module_SRCS
vtkAbstractArray.cxx
vtkAnimationCue.cxx
vtkAngularPeriodicDataArray.txx
vtkArrayCoordinates.cxx
vtkArray.cxx
vtkArrayExtents.cxx
......@@ -235,6 +236,7 @@ SET(Module_SRCS
set(${vtk-module}_HDRS
vtkABI.h
vtkAngularPeriodicDataArray.h
vtkArrayInterpolate.h
vtkArrayInterpolate.txx
vtkArrayIteratorIncludes.h
......@@ -528,6 +530,7 @@ set_source_files_properties(
vtkDataArrayPrivate.txx
vtkABI.h
vtkAngularPeriodicDataArray.txx
vtkArrayInterpolate.h
vtkArrayInterpolate.txx
vtkArrayIteratorIncludes.h
......
......@@ -7,6 +7,7 @@ set(TestXMLFileOutputWindow_ARGS ${CMAKE_BINARY_DIR}/Testing/Temporary/XMLFileOu
vtk_add_test_cxx(${vtk-module}CxxTests tests
NO_DATA NO_VALID NO_OUTPUT
UnitTestMath.cxx
TestAngularPeriodicDataArray.cxx
TestArrayAPI.cxx
TestArrayAPIConvenience.cxx
TestArrayAPIDense.cxx
......
/*=========================================================================
Program: Visualization Toolkit
Module: TestDistancePolyDataFilter.cxx
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.
=========================================================================*/
#include "vtkAngularPeriodicDataArray.h"
#include "vtkDoubleArray.h"
#include "vtkFloatArray.h"
#include "vtkNew.h"
#include <limits>
int TestAngularPeriodicDataArray(int, char * [])
{
vtkNew<vtkDoubleArray> array;
vtkNew<vtkFloatArray> floatArray;
vtkNew<vtkAngularPeriodicDataArray<double> > angularPeriodicDataArray;
vtkNew<vtkAngularPeriodicDataArray<float> > angularPeriodicDataArray2;
array->SetNumberOfComponents(3);
floatArray->SetNumberOfComponents(3);
double tmp[3];
tmp[0] = 7.77777777777;
tmp[1] = 12.3;
tmp[2] = 0.95;
array->InsertNextTuple(tmp);
floatArray->InsertNextTuple(tmp);
angularPeriodicDataArray->InitializeArray(array.Get());
angularPeriodicDataArray->SetAngle(37.8152145);
angularPeriodicDataArray2->InitializeArray(floatArray.Get());
angularPeriodicDataArray2->SetAngle(55.5769061);
angularPeriodicDataArray2->SetAxis(VTK_PERIODIC_ARRAY_AXIS_Y);
double pTmp[3];
angularPeriodicDataArray->GetTupleValue(0, pTmp);
float pTmp2[3];
angularPeriodicDataArray2->GetTupleValue(0, pTmp2);
double dEpsilon = std::numeric_limits<double>::epsilon() * 20.0;
float fEpsilon = std::numeric_limits<float>::epsilon() * 20.f;
double range[6];
angularPeriodicDataArray->GetRange(range, 0);
angularPeriodicDataArray->GetRange(range + 2, 1);
angularPeriodicDataArray->GetRange(range + 4, 2);
if (std::abs(pTmp[0] - 7.77777777777) >= dEpsilon ||
std::abs(pTmp[1] - 9.134443205595016) >= dEpsilon ||
std::abs(pTmp[2] - 8.291829985380172) >= dEpsilon ||
std::abs(pTmp2[0] - 5.180415) >= fEpsilon ||
std::abs(pTmp2[1] - 12.3) >= fEpsilon ||
std::abs(pTmp2[2] - -5.878743) >= fEpsilon ||
std::abs(range[0] - 7.77777777777) >= dEpsilon ||
std::abs(range[2] - 9.134443205595016) >= dEpsilon ||
std::abs(range[4] - 8.291829985380172) >= dEpsilon
)
{
cerr << "Error in vtkAngularPeriodicDataArray : " << endl
<< "Double Array : " << endl << std::abs(pTmp[0] - 7.77777777777) << " "
<< std::abs(pTmp[1] - 9.134443205595016) << " "
<< std::abs(pTmp[2] - 8.291829985380172) << endl << "Float Array : "
<< std::abs(pTmp2[0] - 5.180415) << " "<< std::abs(pTmp2[1] - 12.3)
<< " " << std::abs(pTmp2[2] - -5.878743) << endl;
return 1;
}
tmp[0] = 1.;
tmp[1] = 1.;
tmp[2] = 1.;
angularPeriodicDataArray2->SetCenter(tmp);
angularPeriodicDataArray2->GetTupleValue(0, pTmp2);
if (std::abs(pTmp2[0] - 4.7902297) >= fEpsilon ||
std::abs(pTmp2[1] - 12.3) >= fEpsilon ||
std::abs(pTmp2[2] - -4.6191568) >= fEpsilon
)
{
cerr << "Error in vtkAngularPeriodicDataArray : " << endl
<< "Non Zero origin rotation : " << endl << std::abs(pTmp2[0] - 4.7902297) << " "
<< std::abs(pTmp2[1] - 12.3) << " "
<< std::abs(pTmp2[2] - -4.6191568) << endl;
return 1;
}
vtkNew<vtkDoubleArray> tensorArray;
vtkNew<vtkAngularPeriodicDataArray<double> > tensorPArray;
tensorArray->SetNumberOfComponents(9);
double tmp3[9];
tmp3[0] = 7.77777777777;
tmp3[1] = 12.3;
tmp3[2] = 0.95;
tmp3[3] = -4.325;
tmp3[4] = -0.00023;
tmp3[5] = 17.88;
tmp3[6] = 4030.5;
tmp3[7] = 1.1;
tmp3[8] = 19.19191919;
tensorArray->InsertNextTuple(tmp3);
tensorPArray->InitializeArray(tensorArray.Get());
tensorPArray->SetAngle(32);
tensorPArray->SetAxis(VTK_PERIODIC_ARRAY_AXIS_Z);
tensorPArray->SetCenter(tmp);
double pTmp3[9];
tensorPArray->GetTupleValue(0, pTmp3);
if (std::abs(pTmp3[0] - 2.0096596603995191543) >= dEpsilon ||
std::abs(pTmp3[1] - 13.555918386315806146) >= dEpsilon ||
std::abs(pTmp3[2] - -8.669310802221298573) >= dEpsilon ||
std::abs(pTmp3[3] - -3.0690815099231580909) >= dEpsilon ||
std::abs(pTmp3[4] - 5.7678880688287419432) >= dEpsilon ||
std::abs(pTmp3[5] - 15.666523169279097161) >= dEpsilon ||
std::abs(pTmp3[6] - 3417.474919319152832) >= dEpsilon ||
std::abs(pTmp3[7] - 2136.7724573373793646) >= dEpsilon ||
std::abs(pTmp3[8] - 19.19191919) >= dEpsilon)
{
cerr << "Error while rotating tensor : " << std::abs(pTmp3[0] - 2.0096596603995191543) << " " <<
std::abs(pTmp3[1] - 13.555918386315806146) << " " <<
std::abs(pTmp3[2] - -8.669310802221298573) << " " <<
std::abs(pTmp3[3] - -3.0690815099231580909) << " " <<
std::abs(pTmp3[4] - 5.7678880688287419432) << " " <<
std::abs(pTmp3[5] - 15.666523169279097161) << " " <<
std::abs(pTmp3[6] - 3417.474919319152832) << " " <<
std::abs(pTmp3[7] - 2136.7724573373793646) << " " <<
std::abs(pTmp3[8] - 19.19191919) << " " << dEpsilon << endl;
}
return 0;
}
/*=========================================================================
Program: Visualization Toolkit
Module: vtkAngularPeriodicDataArray.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.
=========================================================================*/
// .NAME vtkAngularPeriodicDataArray - Map native an Array into an angulat
// periodic array
//
// .SECTION Description
// Map an array into a periodic array. Data from the original array aare
// rotated (on the fly) by the specified angle along the specified axis
// around the specified point. Lookup is not implemented.
// Creating the array is virtually free, accessing a tuple require some
// computation.
#ifndef vtkAngularPeriodicDataArray_h
#define vtkAngularPeriodicDataArray_h
#include "vtkPeriodicDataArray.h" // Parent
#define VTK_PERIODIC_ARRAY_AXIS_X 0
#define VTK_PERIODIC_ARRAY_AXIS_Y 1
#define VTK_PERIODIC_ARRAY_AXIS_Z 2
class vtkMatrix3x3;
template <class Scalar>
class vtkAngularPeriodicDataArray: public vtkPeriodicDataArray<Scalar>
{
public:
vtkMappedDataArrayNewInstanceMacro(vtkAngularPeriodicDataArray<Scalar>);
static vtkAngularPeriodicDataArray *New();
virtual void PrintSelf(ostream &os, vtkIndent indent);
// Description:
// Set/Get the rotation angle in degrees. Default is 0.
void SetAngle(double angle);
vtkGetMacro(Angle, double);
// Description:
// Set/Get the rotation center. Default is 0,0,0.
void SetCenter(double* center);
vtkGetVector3Macro(Center, double);
// Description:
// Set/Get the rotation axis. Default is VTK_PERIODIC_ARRAY_AXIS_X axis.
void SetAxis(int axis);
vtkGetMacro(Axis, int);
void SetAxisToX(void) { this->SetAxisType(VTK_PERIODIC_ARRAY_AXIS_X); }
void SetAxisToY(void) { this->SetAxisType(VTK_PERIODIC_ARRAY_AXIS_Y); }
void SetAxisToZ(void) { this->SetAxisType(VTK_PERIODIC_ARRAY_AXIS_Z); }
protected:
vtkAngularPeriodicDataArray();
~vtkAngularPeriodicDataArray();
// Description:
// Transform the provided tuple
virtual void Transform(Scalar* tuple);
// Description:
// Update rotation matrix from Axis, Angle and Center
void UpdateRotationMatrix();
private:
vtkAngularPeriodicDataArray(const vtkAngularPeriodicDataArray &); // Not implemented.
void operator=(const vtkAngularPeriodicDataArray &); // Not implemented.
double Angle; // Rotation angle in degrees
double AngleInRadians; // Rotation angle in radians
double Center[3]; // Rotation center
int Axis; // Rotation Axis
vtkMatrix3x3* RotationMatrix;
};
#include "vtkAngularPeriodicDataArray.txx"
#endif //vtkAngularPeriodicDataArray_h
// VTK-HeaderTest-Exclude: vtkAngularPeriodicDataArray.h
/*=========================================================================
Program: Visualization Toolkit
Module: vtkAngularPeriodicDataArray.txx
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.
=========================================================================*/
#include "vtkMath.h"
#include "vtkMatrix3x3.h"
#include "vtkObjectFactory.h"
#include <algorithm>
//------------------------------------------------------------------------------
// Can't use vtkStandardNewMacro on a templated class.
template <class Scalar> vtkAngularPeriodicDataArray<Scalar>*
vtkAngularPeriodicDataArray<Scalar>::New()
{
VTK_STANDARD_NEW_BODY(vtkAngularPeriodicDataArray<Scalar>);
}
//------------------------------------------------------------------------------
template <class Scalar> void vtkAngularPeriodicDataArray<Scalar>
::PrintSelf(ostream &os, vtkIndent indent)
{
this->vtkAngularPeriodicDataArray<Scalar>::Superclass::PrintSelf(os, indent);
os << indent << "Axis: " << this->Axis << "\n";
os << indent << "Angle: " << this->Angle << "\n";
os << indent << "Center: " <<
this->Center[0] << " " << this->Center[1] << " " << this->Center[2] << "\n";
}
//------------------------------------------------------------------------------
template <class Scalar> void vtkAngularPeriodicDataArray<Scalar>::
SetAngle(double angle)
{
if (this->Angle != angle)
{
this->Angle = angle;
this->AngleInRadians = vtkMath::RadiansFromDegrees(angle);
this->InvalidateRange();
this->UpdateRotationMatrix();
this->Modified();
}
}
//------------------------------------------------------------------------------
template <class Scalar> void vtkAngularPeriodicDataArray<Scalar>::
SetAxis(int axis)
{
if (this->Axis != axis)
{
this->Axis = axis;
this->InvalidateRange();
this->UpdateRotationMatrix();
this->Modified();
}
}
//------------------------------------------------------------------------------
template <class Scalar> void vtkAngularPeriodicDataArray<Scalar>::
SetCenter(double* center)
{
if (center)
{
bool diff = false;
for (int i = 0; i < 3; i++)
{
if (this->Center[i] != center[i])
{
this->Center[i] = center[i];
diff = true;
}
}
if (diff)
{
this->InvalidateRange();
this->Modified();
}
}
}
//------------------------------------------------------------------------------
template <class Scalar> void vtkAngularPeriodicDataArray<Scalar>::
Transform(Scalar* pos)
{
if (this->NumberOfComponents == 3)
{
// Axis rotation
int axis0 = (this->Axis + 1) % this->NumberOfComponents;
int axis1 = (this->Axis + 2) % this->NumberOfComponents;
double posx = static_cast<double>(pos[axis0]) - this->Center[axis0];
double posy = static_cast<double>(pos[axis1]) - this->Center[axis1];
pos[axis0] = this->Center[axis0] +
static_cast<Scalar>(cosf(this->AngleInRadians) * posx - sinf(this->AngleInRadians) * posy);
pos[axis1] = this->Center[axis1] +
static_cast<Scalar>(sinf(this->AngleInRadians) * posx + cosf(this->AngleInRadians) * posy);
}
else if (this->NumberOfComponents == 9)
{
// Template type force a copy to a double array for tensor
double localPos [9];
double tmpMat [9];
double tmpMat2 [9];
std::copy(pos, pos + 9, localPos);
vtkMatrix3x3::Transpose(this->RotationMatrix->GetData(), tmpMat);
vtkMatrix3x3::Multiply3x3(this->RotationMatrix->GetData(), localPos, tmpMat2);
vtkMatrix3x3::Multiply3x3(tmpMat2, tmpMat, localPos);
std::copy(localPos, localPos + 9, pos);
}
}
//------------------------------------------------------------------------------
template <class Scalar> void vtkAngularPeriodicDataArray<Scalar>::
UpdateRotationMatrix()
{
int axis0 = (this->Axis + 1) % 3;
int axis1 = (this->Axis + 2) % 3;
this->RotationMatrix->Identity();
this->RotationMatrix->SetElement(this->Axis, this->Axis, 1.);
this->RotationMatrix->SetElement(axis0, axis0, cosf(this->AngleInRadians));
this->RotationMatrix->SetElement(axis0, axis1, -sinf(this->AngleInRadians));
this->RotationMatrix->SetElement(axis1, axis0, sinf(this->AngleInRadians));
this->RotationMatrix->SetElement(axis1, axis1, cosf(this->AngleInRadians));
}
//------------------------------------------------------------------------------
template <class Scalar> vtkAngularPeriodicDataArray<Scalar>
::vtkAngularPeriodicDataArray()
{
this->Axis = VTK_PERIODIC_ARRAY_AXIS_X;
this->Angle = 0.0;
this->AngleInRadians = 0.0;
this->Center[0] = 0.0;
this->Center[1] = 0.0;
this->Center[2] = 0.0;
this->RotationMatrix = vtkMatrix3x3::New();
this->RotationMatrix->Identity();
}
//------------------------------------------------------------------------------
template <class Scalar> vtkAngularPeriodicDataArray<Scalar>
::~vtkAngularPeriodicDataArray()
{
this->RotationMatrix->Delete();
}
......@@ -41,6 +41,7 @@ class vtkDoubleArray;
class vtkIdList;
class vtkInformationDoubleVectorKey;
class vtkLookupTable;
class vtkPoints;
class VTKCOMMONCORE_EXPORT vtkDataArray : public vtkAbstractArray
{
......@@ -395,6 +396,9 @@ public:
virtual int GetArrayType() { return DataArray; }
protected:
friend class vtkPoints;
// Description:
// Compute the range for a specific component. If comp is set -1
// then L2 norm is computed on all components. Call ClearRange
......
/*=========================================================================
Program: Visualization Toolkit
Module: vtkPeriodicDataArray.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.
=========================================================================*/
// .NAME vtkPeriodicDataArray - Map native an Array into an angulat
// periodic array
//
// .SECTION Description
// Map an array into a periodic array. Data from the original array aare
// rotated (on the fly) by the specified angle along the specified axis
// around the specified point. Lookup is not implemented.
// Creating the array is virtually free, accessing a tuple require some
// computation.
#ifndef vtkPeriodicDataArray_h
#define vtkPeriodicDataArray_h
#include "vtkMappedDataArray.h" // Parent
#include "vtkDataArrayTemplate.h" // Template
template <class Scalar>
class vtkPeriodicDataArray:
public vtkTypeTemplate <vtkPeriodicDataArray <Scalar>, vtkMappedDataArray <Scalar> >
{
public:
virtual void PrintSelf(ostream &os, vtkIndent indent);
// Description:
// Initialize the mapped array with the original input data array.
void InitializeArray(vtkDataArrayTemplate<Scalar>* inputData);
// Description:
// Initialize array with zero values
void Initialize();
// Description:
// Copy tuples values, selected by ptIds into provided array
void GetTuples(vtkIdList *ptIds, vtkAbstractArray *output);
// Description:
// Copy tuples from id p1 to id p2 included into provided array
void GetTuples(vtkIdType p1, vtkIdType p2, vtkAbstractArray *output);
// Description:
// No effect
void Squeeze();
// Description:
// Not implemented
vtkArrayIterator *NewIterator();
// Description:
// Not implemented
vtkIdType LookupValue(vtkVariant value);
// Description:
// Not implemented
void LookupValue(vtkVariant value, vtkIdList *ids);
// Description:
// Not implemented
vtkVariant GetVariantValue(vtkIdType idx);
// Description:
// Not implemented
void ClearLookup();
// Description:
// Return tuple at location i.
// Pointer valid until next call to this object
double* GetTuple(vtkIdType i);
// Description:
// Copy tuple at location i into user provided array
void GetTuple(vtkIdType i, double *tuple);
// Description:
// Not implemented
vtkIdType LookupTypedValue(Scalar value);
// Description:
// Not implemented
void LookupTypedValue(Scalar value, vtkIdList *ids);
// Description:
// Get value at index idx.
// Warning, it internally call GetTupleValue,
// so it is an inneficcient way if reading all data
Scalar GetValue(vtkIdType idx);
// Description:
// Get value at index idx as reference.
// Warning, it internally call GetTupleValue,
// so it is an inneficcient way if reading all data
Scalar& GetValueReference(vtkIdType idx);
// Description:
// Copy tuple value at location idx into provided array
void GetTupleValue(vtkIdType idx, Scalar *t);
// Description:
// Return the memory in kilobytes consumed by this data array.
unsigned long GetActualMemorySize();
// Description:
// Read only container, not supported.
int Allocate(vtkIdType sz, vtkIdType ext);
// Description:
// Read only container, not supported.
int Resize(vtkIdType numTuples);
// Description:
// Read only container, not supported.
void SetNumberOfTuples(vtkIdType number);
// Description:
// Read only container, not supported.
void SetTuple(vtkIdType i, vtkIdType j, vtkAbstractArray *source);
// Description:
// Read only container, not supported.
void SetTuple(vtkIdType i, const float *source);
// Description:
// Read only container, not supported.
void SetTuple(vtkIdType i, const double *source);
// Description:
// Read only container, not supported.
void InsertTuple(vtkIdType i, vtkIdType j, vtkAbstractArray *source);
// Description:
// Read only container, not supported.
void InsertTuple(vtkIdType i, const float *source);
// Description:
// Read only container, not supported.
void InsertTuple(vtkIdType i, const double *source);
// Description:
// Read only container, not supported.
void InsertTuples(vtkIdList *dstIds, vtkIdList *srcIds,
vtkAbstractArray *source);
// Description:
// Read only container, not supported.
void InsertTuples(vtkIdType dstStart, vtkIdType n, vtkIdType srcStart,
vtkAbstractArray* source);
// Description:
// Read only container, error.
vtkIdType InsertNextTuple(vtkIdType j, vtkAbstractArray *source);
// Description:
// Read only container, not supported.
vtkIdType InsertNextTuple(const float *source);
// Description:
// Read only container, not supported.
vtkIdType InsertNextTuple(const double *source);
// Description:
// Read only container, not supported.
void DeepCopy(vtkAbstractArray *aa);
// Description:
// Read only container, not supported.
void DeepCopy(vtkDataArray *da);
// Description:
// Read only container, not supported.
void InterpolateTuple(vtkIdType i, vtkIdList *ptIndices,
vtkAbstractArray* source, double* weights);
// Description:
// Read only container, not supported.
void InterpolateTuple(vtkIdType i, vtkIdType id1, vtkAbstractArray *source1,
vtkIdType id2, vtkAbstractArray *source2, double t);
// Description:
// Read only container, not supported.
void SetVariantValue(vtkIdType idx, vtkVariant value);
// Description:
// Read only container, not supported.
void RemoveTuple(vtkIdType id);
// Description:
// Read only container, not supported.
void RemoveFirstTuple();
// Description:
// Read only container, not supported.
void RemoveLastTuple();
// Description:
// Read only container, not supported.
void SetTupleValue(vtkIdType i, const Scalar *t);
// Description:
// Read only container, not supported.
void InsertTupleValue(vtkIdType i, const Scalar *t);
// Description:
// Read only container, not supported.
vtkIdType InsertNextTupleValue(const Scalar *t);
// Description:
// Read only container, not supported.
void SetValue(vtkIdType idx, Scalar value);
// Description:
// Read only container, not supported.
vtkIdType InsertNextValue(Scalar v);
// Description:
// Read only container, not supported.
void InsertValue(vtkIdType idx, Scalar v);
protected:
vtkPeriodicDataArray();
~vtkPeriodicDataArray();
// Description:
// Transform the provided tuple
virtual void Transform(Scalar* tuple) = 0;
// Description:
// Get The transformed range
virtual void ComputeRange(double range[2], int comp);
// Description:
// Update the transformed periodic range
virtual void ComputePeriodicRange();
// Description:
// Set the invalid range flag to false
void InvalidateRange();
private:
vtkPeriodicDataArray(const vtkPeriodicDataArray &); // Not implemented.
void operator=(const vtkPeriodicDataArray &); // Not implemented.
Scalar* TempScalarArray; // Temporary array used by GetTupleValue methods
double* TempDoubleArray; // Temporary array used by GetTuple vethods
vtkIdType TempTupleIdx; // Location of currently stored Temp Tuple to use as cache
vtkDataArrayTemplate<Scalar>* Data; // Original data
bool InvalidRange;
double PeriodicRange[6]; // Transformed periodic range
};
#include "vtkPeriodicDataArray.txx"
#endif //vtkPeriodicDataArray_h
// VTK-HeaderTest-Exclude: vtkPeriodicDataArray.h
This diff is collapsed.