Fix various typos

Found via `codespell -q 3 -S ./.git,./ThirdParty,./Utilities/MetaIO,./Utilities/KWSys -L acount,aline,alledges,ans,ba,childs,co-ordinates,contrl,datas,dota,eiter,inout,inouts,lod,lsit,nin,nd,normale,normaly,ot,outout,pard,pres,siz,statics`
HTGFixUnlimitedToRoot
luz paz 6 months ago
parent ed8bd3efb5
commit d4cf58a8c1

@ -64,7 +64,7 @@ dnf install -y --setopt=install_weak_deps=False \
dnf-plugins-core
# Openturns dependencies
# Diabling for now because Fedora 34 is no longer provided by the OpenSuse science team.
# Disabling for now because Fedora 34 is no longer provided by the OpenSuse science team.
#dnf config-manager --add-repo https://download.opensuse.org/repositories/science:/openturns/Fedora_34/science:openturns.repo
#dnf install -y --setopt=install_weak_deps=False \
# openturns-libs openturns-devel

@ -42,7 +42,7 @@ protected:
///
/// Certain input dataset types are not currently supported by vtkm.
/// This information is internally used to determine if this filter should fall back to
/// Superclass implementaion.
/// Superclass implementation.
bool CanProcessInput(vtkDataSet* input);
vtkmSlice();

@ -1567,7 +1567,7 @@ foreach(LANG IN ITEMS C CXX Fortran)
endif()
endif()
# We are on a Cray, environment identfier: PE_ENV is set (CRAY), and
# We are on a Cray, environment identifier: PE_ENV is set (CRAY), and
# have NOT found an mpic++-like compiler wrapper (previous block),
# and we do NOT use the Cray cc/CC compiler wrappers as CC/CXX CMake
# compiler.

@ -20,7 +20,7 @@ set(IOS_DEVICE_ARCHITECTURES "arm64"
list(REMOVE_DUPLICATES IOS_SIMULATOR_ARCHITECTURES)
list(REMOVE_DUPLICATES IOS_DEVICE_ARCHITECTURES)
# Check that at least one architecure is defined
# Check that at least one architecture is defined
list(LENGTH IOS_SIMULATOR_ARCHITECTURES SIMULATOR_ARCHS_NBR)
list(LENGTH IOS_DEVICE_ARCHITECTURES DEVICE_ARCHS_NBR)
math(EXPR IOS_ARCHS_NBR ${DEVICE_ARCHS_NBR}+${SIMULATOR_ARCHS_NBR})

@ -220,7 +220,7 @@ public:
namespace
{
// This is just here for now - quick and dirty historgram calculations...
// This is just here for now - quick and dirty histogram calculations...
bool PopulateHistograms(vtkTable* input, vtkTable* output, vtkStringArray* s, int NumberOfBins)
{
// The output table will have the twice the number of columns, they will be

@ -69,7 +69,7 @@ public:
template <typename t, typename std::enable_if<is_unlimited<t>::value>::type* = nullptr>
int doTest(t* mcur)
{
// For unlimited type, we descend 10 times independantly of the tree shape
// For unlimited type, we descend 10 times independently of the tree shape
// this goes deeper than the lowest child anyway
for (int i = 0; i < 10; i++)
{

@ -233,7 +233,7 @@ def nonOrientedUnlimitedMooreSuperCursor(htg):
htg.InitializeNonOrientedUnlimitedMooreSuperCursor(cursor, treeId)
nb += recursive(cursor, 3)
if nb != 3*512:
print("ERROR Unexcpected value for unlimited cursor")
print("ERROR Unexpected value for unlimited cursor")
return nb

@ -115,7 +115,7 @@ void vtkBezierCurve::InterpolateFunctions(const double pcoords[3], double* weigh
{
vtkBezierInterpolation::Tensor1ShapeFunctions(this->GetOrder(), pcoords, weights);
// If the unit cell has rational weigths: weights_i = weights_i * rationalWeights / sum( weights_i
// If the unit cell has rational weights: weights_i = weights_i * rationalWeights / sum( weights_i
// * rationalWeights )
const bool has_rational_weights = RationalWeights->GetNumberOfTuples() > 0;
if (has_rational_weights)

@ -172,7 +172,7 @@ void vtkBezierHexahedron::InterpolateFunctions(const double pcoords[3], double*
{
vtkBezierInterpolation::Tensor3ShapeFunctions(this->GetOrder(), pcoords, weights);
// If the unit cell has rational weigths: weights_i = weights_i * rationalWeights / sum(
// If the unit cell has rational weights: weights_i = weights_i * rationalWeights / sum(
// weights_i
// * rationalWeights )
const bool has_rational_weights = RationalWeights->GetNumberOfTuples() > 0;

@ -139,7 +139,7 @@ void vtkBezierQuadrilateral::InterpolateFunctions(const double pcoords[3], doubl
{
vtkBezierInterpolation::Tensor2ShapeFunctions(this->GetOrder(), pcoords, weights);
// If the unit cell has rational weigths: weights_i = weights_i * rationalWeights / sum( weights_i
// If the unit cell has rational weights: weights_i = weights_i * rationalWeights / sum( weights_i
// * rationalWeights )
const bool has_rational_weights = RationalWeights->GetNumberOfTuples() > 0;
if (has_rational_weights)

@ -141,7 +141,7 @@ void vtkBezierTetra::InterpolateFunctions(const double pcoords[3], double* weigh
vtkIdType lbv[4] = { bv[0], bv[1], bv[2], deg - bv[0] - bv[1] - bv[2] };
weights[Index(lbv, deg)] = coeffs[i];
}
// If the unit cell has rational weigths: weights_i = weights_i * rationalWeights / sum( weights_i
// If the unit cell has rational weights: weights_i = weights_i * rationalWeights / sum( weights_i
// * rationalWeights )
const bool has_rational_weights = RationalWeights->GetNumberOfTuples() > 0;
if (has_rational_weights)

@ -112,7 +112,7 @@ void vtkBezierTriangle::InterpolateFunctions(const double pcoords[3], double* we
weights[Index(lbv, deg)] = coeffs[i];
}
// If the unit cell has rational weigths: weights_i = weights_i * rationalWeights / sum( weights_i
// If the unit cell has rational weights: weights_i = weights_i * rationalWeights / sum( weights_i
// * rationalWeights )
const bool has_rational_weights = RationalWeights->GetNumberOfTuples() > 0;
if (has_rational_weights)

@ -155,7 +155,7 @@ void vtkBezierWedge::InterpolateFunctions(const double pcoords[3], double* weigh
vtkBezierInterpolation::WedgeShapeFunctions(
this->GetOrder(), this->GetOrder()[3], pcoords, weights);
// If the unit cell has rational weigths: weights_i = weights_i * rationalWeights / sum( weights_i
// If the unit cell has rational weights: weights_i = weights_i * rationalWeights / sum( weights_i
// * rationalWeights )
const bool has_rational_weights = RationalWeights->GetNumberOfTuples() > 0;
if (has_rational_weights)

@ -1124,7 +1124,7 @@ void vtkExplicitStructuredGrid::CheckConnectedFaces(int& nFoundFaces, int foundF
for (int axis = 0; axis < 3; axis++)
{
int foundFace = foundFaces[axis];
// Check if the foundFace point to antoher axis
// Check if the foundFace point to another axis
if (foundFace != -1 && !(foundFace == 2 * axis) && !(foundFace == 2 * axis + 1))
{
// A single foundFace which changes face on multiple axis is incoherent and can't be

@ -397,7 +397,7 @@ public:
/**
* Used to initialize a cursor of the given type.
*
* cursor: the cursor to initalize
* cursor: the cursor to initialize
*
* index: the index of the tree to use in the HTG
*
@ -448,7 +448,7 @@ public:
/**
* Used to initialize a cursor of the given type.
*
* cursor: the cursor to initalize
* cursor: the cursor to initialize
*
* index: the index of the tree to use in the HTG
*

@ -44,7 +44,7 @@ vtkHyperTreeGridGeometryUnlimitedEntry::vtkHyperTreeGridGeometryUnlimitedEntry(
else
{
vtkWarningWithObjectMacro(
nullptr, "Attemp to construct a geometry entry from an invalid index.");
nullptr, "Attempt to construct a geometry entry from an invalid index.");
this->LastRealIndex = vtkHyperTreeGrid::InvalidIndex;
}

@ -25,7 +25,7 @@
*
* Supercursor allows to retrieve various kind of cursor for any childs.
* This class is also a building block for Moore and VonNeumann SuperCursor,
* which have neighboorhood traversal abilities.
* which have neighborhood traversal abilities.
*
* @sa
* vtkHyperTreeCursor vtkHyperTree vtkHyperTreeGrid

@ -14,10 +14,10 @@
=========================================================================*/
/**
* @class vtkHyperTreeGridNonOrientedUnlimitedMooreSuperCursor
* @brief Specific Moore super cursor that can subdivied neighboorhood
* @brief Specific Moore super cursor that can subdivied neighborhood
*
* This supercursor behave like the Moore supercursor but relies on the
* vtkHyperTreeGridNonOrientedUnlimitedSuperCursor so the neighboorhood
* vtkHyperTreeGridNonOrientedUnlimitedSuperCursor so the neighborhood
* can be refined to reach the level of the current cell in any case.
*
* @sa

@ -26,7 +26,7 @@
* @sa
* vtkHyperTreeCursor vtkHyperTree vtkHyperTreeGrid
*
* This supercursor allows to traverse neighboors attached to coface of
* This supercursor allows to traverse neighbors attached to coface of
* the current position.
*
* @par Thanks:

@ -267,7 +267,7 @@ public:
/**
* Merge compatible extents in the list. Extents are compatible
* if they are directly adjacent nad have the same extent along
* if they are directly adjacent and have the same extent along
* the adjacent edge.
*/
static void Merge(std::deque<vtkPixelExtent>& exts);

@ -244,7 +244,7 @@ public:
///@{
/**
* Set/Get an internal variable used to comunicate between the algorithm and
* Set/Get an internal variable used to communicate between the algorithm and
* executive. If the executive sees this value is set, it will initialize
* the output data and pass the ABORTED flag downstream.
*
@ -758,7 +758,7 @@ protected:
/**
* Checks to see if an upstream filter has been aborted. If an abort
* has occured, return true.
* has occurred, return true.
*/
bool CheckUpstreamAbort();

@ -56,7 +56,7 @@
* vtkImplicitArrayTraits header file. These traits use metaprogramming to check the proposed
* backend type at compile time. The decision to use this type of structure was taken for the
* following reasons:
* - static dispatch of the calls to the backend (when combined with the CRTP strcture of
* - static dispatch of the calls to the backend (when combined with the CRTP structure of
* vtkGenericDataArray)
* - flexibility regarding the complexity/simplicity/nature/type... of the backend one would like to
* use
@ -180,7 +180,7 @@ public:
/**
* Specific DeepCopy for implicit arrays
*
* This method should be prefered for two implicit arrays having the same backend. We cannot call
* This method should be preferred for two implicit arrays having the same backend. We cannot call
* the method `DeepCopy` since that conflicts with the virtual function of the same name that
* cannot be templated. The non-interopability of templates and virtual functions is a language
* limitation at the time of writing this documentation. We can call this from the dispatched
@ -271,7 +271,7 @@ private:
///@{
/**
* Static dispatch Initialize for non-default constuctible things
* Static dispatch Initialize for non-default constructible things
*/
template <typename U>
typename std::enable_if<!vtk::detail::implicit_array_traits<U>::default_constructible, void>::type

@ -57,7 +57,7 @@ class VTKCOMMONMATH_EXPORT vtkFFT : public vtkObject
public:
///@{
/**
* Usefull type definitions and utilities.
* Useful type definitions and utilities.
*
* ScalarNumber is defined as a floating point number.
*
@ -350,7 +350,7 @@ protected:
InputIt begin, InputIt end, Scaling scaling, double fs);
/**
* Dispatch the signal to the right FFT fucntion according to the given parameters.
* Dispatch the signal to the right FFT function according to the given parameters.
* Also detrend the signal and multiply it by the window. Used in the `OverlappingFft` function.
*/
template <typename T, typename TW>

@ -1066,7 +1066,7 @@ will be instances of the override class. This behavior is global.
points = vtk.vtkPoints() # returns an instance of CustomPoints
The override can be reversed by setting an override of `None`, but this will
not impact instantions that have already occurred.
not impact instantiations that have already occurred.
vtkPoints.override(None)

@ -153,7 +153,7 @@ Note that same code can be conveniently and compactly defined inline via a C++ l
}
}); // end lambda
```
With alternative signatures for `For()` it is possible to provide a grain parameter. Grain is a hint to the underlying backend about the coarseness of the typical range when parallelizing a for loop. If you dont know what grain will work best for a particular problem, omit the grain specification and let the backend find a suitable grain. TBB in particular does a good job with this. Somethimes, you can eek out a little bit more performance by setting the grain just right. Too small, the task queuing overhead will be too much. Too little, load balancing will suffer.
With alternative signatures for `For()` it is possible to provide a grain parameter. Grain is a hint to the underlying backend about the coarseness of the typical range when parallelizing a for loop. If you dont know what grain will work best for a particular problem, omit the grain specification and let the backend find a suitable grain. TBB in particular does a good job with this. Sometimes, you can eek out a little bit more performance by setting the grain just right. Too small, the task queuing overhead will be too much. Too little, load balancing will suffer.
## Thread Local Storage
Thread local storage is generally referred to memory that is accessed by one thread only. In the SMP framework, vtkSMPThreadLocal and vtkSMPThreadLocalObject enable the creation objects local to executing threads. The main difference between the two is that vtkSMPThreadLocalObject makes it easy to manage vtkObject and subclasses by allocating and deleting them appropriately.
@ -275,7 +275,7 @@ mt->SingleMethodExecute();
std::cout << Total << " " << TotalAtomic.load() << endl;
```
When this program is executed, most of the time `Total` will be different (smaller) than `Target` whereas `TotalAtomic` will be exactly the same as `Target`. For example, a test run on a Mac prints: `999982 1000000`. This is because when the integer is not atomic, both threads can read the same value of `Total`, increment and write out the same value, which leads to losing one increment operation. Whereas, when ++ happens atomically, it is guaranteed that it will read, increment and write out `Total` all in one uninterruptable operation. When atomic operations are supported at hardware level, they are very fast.
When this program is executed, most of the time `Total` will be different (smaller) than `Target` whereas `TotalAtomic` will be exactly the same as `Target`. For example, a test run on a Mac prints: `999982 1000000`. This is because when the integer is not atomic, both threads can read the same value of `Total`, increment and write out the same value, which leads to losing one increment operation. Whereas, when ++ happens atomically, it is guaranteed that it will read, increment and write out `Total` all in one uninterruptible operation. When atomic operations are supported at hardware level, they are very fast.
# Tips
In this section, we provide some tips that we hope will be useful to those that want to develop shared memory parallel algorithms.
@ -309,7 +309,7 @@ Parallel algorithms often require significant bookkeeping to properly partition
A variation of this approach is to use thread local storage to perform computation on a local range of input, store the result in thread local, and then reduce/composite the local storage into the global output. While this is problematic for many reasons (especially since data movement is needed to composite the output data), it still can be used to effectively partition and transform input data to the output, especially if the thread local storage is relatively small in size.
Whatever approach is used, parallel algorithms are often implemened using multiple passes. When designing parallel algorithms, it is important to think in terms of passes, and implement algorithms accordingly.
Whatever approach is used, parallel algorithms are often implemented using multiple passes. When designing parallel algorithms, it is important to think in terms of passes, and implement algorithms accordingly.
## Use Parallel Design Patterns
There are many parallel operations that are used repeatedly. Of course `for` loops and `fill()` are two obvious operations, but the `sort()` operation is more widely used than might be expected. Another is the prefix sum (or inclusive scan, or simply scan) typically used to build indices into data arrays. Become familiar with these and other parallel operations and the task of designing and implementing algorithms will be much easier.

@ -5,7 +5,7 @@ link different versions of VTK into the same runtime without generating
conflicts between VTK symbols.
A limitation to this change is it does _NOT_ prevent conflicts between
third-party symbols, including VTK-m. There is no enforcment in CMake
third-party symbols, including VTK-m. There is no enforcement in CMake
for third-party dependencies needing to be external when using the ABI
namespace, this is left to you to configure. A full known list of known
issues is listed below.

@ -9,5 +9,5 @@ Add support for `vtkHyperTreeGrid` in the resampling filters using the `vtkHyper
## Steps
- refactor exisiting probe functionality into sequential and parallel parts
- refactor existing probe functionality into sequential and parallel parts
- insert support for `vtkHyperTreeGrid` into both sequential and parallel resampling filters

@ -2,5 +2,5 @@
AMR filters now call `CheckAbort` to allow for
safe interruption during execution.
`vtkAMRUtilities::BlankCells` will be skippped
`vtkAMRUtilities::BlankCells` will be skipped
if a filter's `CheckAbort` returns true.

@ -7,5 +7,5 @@ In order to prevent multiple calls to
`CheckAbort`, `vtkSMPTools` has a new function
to create a cheap single scope for all
implementations. The function `GetSingleThread`
retruns true if the thread is the single thread.
returns true if the thread is the single thread.
Otherwise the function returns false.

@ -2,7 +2,7 @@
## Description
VTK now offers new flexible `vtkImplicitArray` template class that implements a **read-only** `vtkGenericDataArray` interface. It essentially transforms an implicit function mapping integers to values into a pratically zero cost `vtkDataArray`. This is helpful in cases where one needs to attach data to data sets and memory efficiency is paramount.
VTK now offers new flexible `vtkImplicitArray` template class that implements a **read-only** `vtkGenericDataArray` interface. It essentially transforms an implicit function mapping integers to values into a practically zero cost `vtkDataArray`. This is helpful in cases where one needs to attach data to data sets and memory efficiency is paramount.
## Usage

@ -1,9 +1,9 @@
# Added more VTK-m accelerated filter overrides
Factory overrides for the following filters have been added:
1. `vtkTableBasedClipDataSet` can be overriden by `vtkmClip`
2. `vtkCutter` can be overriden by `vtkmSlice`
3. `vtkThreshold` can be overriden by `vtkmThreshold`
1. `vtkTableBasedClipDataSet` can be overridden by `vtkmClip`
2. `vtkCutter` can be overridden by `vtkmSlice`
3. `vtkThreshold` can be overridden by `vtkmThreshold`
These overrides are available when the `VTK::AcceleratorsVTKmFilters` is enabled
and the `VTK_ENABLE_VTKM_OVERRIDES` cmake option may be turned on.

@ -2,4 +2,4 @@
Uniformize the `vtkPlot` API for color setters/getter, in order to fit the API of `vtkPen` and `vtkBrush`. \
Methods using floating values as parameters (e.g. `vtkPlot::SetColor(double r, double g, double b)`) are now suffixed with `F`
to avoid confusion with equivalent functions using unigned chars. The former ones are marked as deprecated in VTK 9.3.
to avoid confusion with equivalent functions using unsigned chars. The former ones are marked as deprecated in VTK 9.3.

@ -1,5 +1,5 @@
## Added vtkGradientFilter -> vtkmGradient override
Added `vtkGradientFilter` to the list of filters that are overriden by a VTK-m based
Added `vtkGradientFilter` to the list of filters that are overridden by a VTK-m based
implementation (`vtkmGradient`) when the `VTK::AcceleratorsVTKmFilters` module is
enabled and the CMake option `VTK_ENABLE_VTKM_OVERRIDES` is set.

@ -1629,7 +1629,7 @@
<scalar dataType="xsd:float" dictRef="bo:ionization" units="units:ev">6.1077</scalar>
<scalar dataType="xsd:float" dictRef="bo:electronAffinity" units="units:ev">0.5</scalar>
<scalar dataType="xsd:float" dictRef="bo:electronegativityPauling" units="boUnits:paulingScaleUnit">1.24</scalar>
<scalar dataType="xsd:string" dictRef="bo:nameOrigin" xml:lang="en">Named ofter the Swedish town of Ytterby. Terbium and Ytterbium are also named after this town.</scalar>
<scalar dataType="xsd:string" dictRef="bo:nameOrigin" xml:lang="en">Named after the Swedish town of Ytterby. Terbium and Ytterbium are also named after this town.</scalar>
<scalar dataType="xsd:float" dictRef="bo:radiusCovalent" units="units:ang">1.65</scalar>
<scalar dataType="xsd:float" dictRef="bo:radiusVDW" units="units:ang">2.32</scalar>
<array title="color" dictRef="bo:elementColor" size="3" dataType="xsd:float">0.00 0.90 0.46</array>

@ -58,7 +58,7 @@ int main(int argc, char* argv[])
int i;
vtkXMLStructuredGridReader* reader = vtkXMLStructuredGridReader::New();
// vtkMultiBlockDataSet respresents multi-block datasets. See
// vtkMultiBlockDataSet represents multi-block datasets. See
// the class documentation for more information.
vtkMultiBlockDataSet* mb = vtkMultiBlockDataSet::New();

@ -470,7 +470,7 @@ void vtkAMRSliceFilter::GetSliceCellData(vtkUniformGrid* slice, vtkUniformGrid*
vtkUnsignedCharArray* uca = vtkArrayDownCast<vtkUnsignedCharArray>(array);
if (uca != nullptr && uca == slice->GetCellGhostArray())
{
// initiallize the ghost array
// initialize the ghost array
memset(uca->WritePointer(0, numCells), 0, numCells);
}
array->Delete();

@ -75,7 +75,7 @@ public:
///@{
/**
* Set/Get the Axis normal. The accpetable values are defined in the
* Set/Get the Axis normal. The acceptable values are defined in the
* NormalTag enum.
*/
vtkSetMacro(Normal, int);
@ -84,7 +84,7 @@ public:
///@{
/**
* Set/Get a multiprocess controller for paralle processing.
* Set/Get a multiprocess controller for parallel processing.
* By default this parameter is set to nullptr by the constructor.
*/
virtual void SetController(vtkMultiProcessController*);

@ -46,7 +46,7 @@ public:
///@{
/**
* Set/Get a multiprocess controller for paralle processing.
* Set/Get a multiprocess controller for parallel processing.
* By default this parameter is set to nullptr by the constructor.
*/
virtual void SetController(vtkMultiProcessController*);

@ -15,7 +15,7 @@
// This test was created following the bug reported by Gilles Rougeron.
// Some points were not connected in the output triangulation.
// A fix was added to vtkDelaunay2D. This test exercices the new
// A fix was added to vtkDelaunay2D. This test exercises the new
// functionality.
#include "vtkActor.h"

@ -5,7 +5,7 @@ from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# Test the plane clipper on cell data, point data,
# and when muliple capping loops are involved.
# and when multiple capping loops are involved.
# Control test size
res = 512

@ -333,7 +333,7 @@ struct GCDTraversal
}
}
// Can be optimized to avoid the modulo %, but coded for simplicity
// since the cost of this operation is miniscule compared to everything
// since the cost of this operation is minuscule compared to everything
// else that is going on.
vtkIdType GetPointId(vtkIdType idx) { return ((this->Prime * idx + this->Offset) % this->NPts); }
};

@ -85,7 +85,7 @@ struct UnstructuredGridHelper
// This class implements:
// * AddHitCellIdsAndPointIds: Given an input cell that is hit by an input line,
// add the cell id in a cell id container and the points of the cell in a point id container,
// and update the connectivty size of the output unstructured grid
// and update the connectivity size of the output unstructured grid
// * CopyCell: Given an input input cell id, copy it into the output unstructured grid.
template <class DataSetT>
struct InputCellHandler;

@ -853,7 +853,7 @@ void vtkFlyingEdges2DAlgorithm<T>::ContourImage(vtkFlyingEdges2D* self, T* scala
// PASS 3: Now allocate and generate output. First we have to update the
// x-Edge meta data to partition the output into separate pieces so
// independent threads can write into separate memory partititions. Once
// independent threads can write into separate memory partitions. Once
// allocation is complete, process on a row by row basis and produce
// output points, line primitives, and interpolate point attribute data
// (if necessary).

@ -147,7 +147,8 @@ int vtkHyperTreeGridProbeFilter::RequestUpdateExtent(vtkInformation* vtkNotUsed(
vtkInformation* sourceInfo = inputVector[1]->GetInformationObject(0);
vtkInformation* outInfo = outputVector->GetInformationObject(0);
// the updating of ouput transfers directly into input while the source is entirely updated always
// the updating of output transfers directly into input while the source is entirely updated
// always
vtkDataObject* output = vtkDataObject::GetData(outInfo);
if (output && (output->IsA("vtkUnstructuredGrid") || output->IsA("vtkPolyData")))
{

@ -123,7 +123,7 @@ public:
///@{
/**
* Get/Set tolerance used when finding points in the HTG source.
* Overriden when ComputeTolerance == true.
* Overridden when ComputeTolerance == true.
*
* Default is 0.0
*/
@ -133,7 +133,7 @@ public:
///@{
/**
* Get/Set wether or not to compute the tolerance automatically for
* Get/Set whether or not to compute the tolerance automatically for
* when finding points in the HTG source. If false use the tolerance
* from SetTolerance .
*
@ -181,7 +181,7 @@ protected:
bool PassAttributeData(vtkDataSet* input, vtkDataSet* output);
/**
* Helper method for perfoming the probing
* Helper method for performing the probing
*/
bool DoProbing(
vtkDataSet* input, vtkHyperTreeGrid* source, vtkDataSet* output, vtkIdList* localPointIds);

@ -702,7 +702,7 @@ void vtkQuadricDecimation::AddBoundaryConstraints()
#endif
double d = -vtkMath::Dot(n, t1);
// The above line might merit some review: The same quadric gets added to t1 and t2 and one
// might prefere adding a quadric calculated using t1 at t1 and using t2 at t2
// might prefer adding a quadric calculated using t1 at t1 and using t2 at t2
w = vtkMath::Norm(e0);
if (!this->WeighBoundaryConstraintsByLength)

@ -518,7 +518,7 @@ int vtkStaticCleanUnstructuredGrid::RequestData(vtkInformation* vtkNotUsed(reque
}
// At this point, we need to construct the unstructured grid topology using
// the point map. This means updating the connectivty arrays (including
// the point map. This means updating the connectivity arrays (including
// possibly face connectivity for any polyhedra). Since the types of the
// cells are not changing, offsets and type arrays do not need
// modification.

@ -105,7 +105,7 @@ public:
VTK_DEPRECATED_IN_9_3_0("Please use SetInputArrayToProcess instead.")
vtkSetMacro(AttributeMode, int);
VTK_DEPRECATED_IN_9_3_0("This method is depricated.")
VTK_DEPRECATED_IN_9_3_0("This method is deprecated.")
vtkGetMacro(AttributeMode, int);
VTK_DEPRECATED_IN_9_3_0("Please use SetInputArrayToProcess instead.")
@ -117,7 +117,7 @@ public:
VTK_DEPRECATED_IN_9_3_0("Please use SetInputArrayToProcess instead.")
void SetAttributeModeToUseCellData();
VTK_DEPRECATED_IN_9_3_0("This method is depricated.")
VTK_DEPRECATED_IN_9_3_0("This method is deprecated.")
const char* GetAttributeModeAsString();
///@}

@ -240,7 +240,7 @@ bool vtkTransposeTableInternal::TransposeTable(vtkTable* inTable, vtkTable* outT
else
{
// Set the column name to the (padded) row id.
// We padd ids with 0 to avoid downstream dictionary sort issues.
// We pad ids with 0 to avoid downstream dictionary sort issues.
std::stringstream ss2;
ss2 << std::setw(maxBLen) << std::setfill('0');
ss2 << r;

@ -887,7 +887,7 @@ public:
return Verts[0] == v || Verts[1] == v || Verts[2] == v || Verts[3] == v;
}
// check to see if we can change fromV to toV without changing the orietation
// check to see if we can change fromV to toV without changing the orientation
bool Changeable(vtkUnstructuredGridQuadricDecimationVertex* fromV,
const vtkUnstructuredGridQuadricDecimationVec4& v4)
{

@ -16,7 +16,7 @@
* @class vtkUnstructuredGridToExplicitStructuredGrid
* @brief Filter which converts an unstructured grid data into an explicit structured grid.
* The input grid must have a structured coordinates int cell array.
* Moreover, its cell must be listed in the i-j-k order (k varying more ofter)
* Moreover, its cell must be listed in the i-j-k order (k varying more often)
*/
#ifndef vtkUnstructuredGridToExplicitStructuredGrid_h

@ -52,7 +52,7 @@
* point set. A locator is then used to identify nearby points: each neighbor
* in turn generates a clipping line positioned halfway between the
* generating point and the neighboring point, and orthogonal to the line
* connecting them. Clips are readily performed by evaluationg the vertices
* connecting them. Clips are readily performed by evaluating the vertices
* of the convex Voronoi tile as being on either side (inside,outside) of the
* clip line. If two intersections of the Voronoi tile are found, the portion
* of the tile "outside" the clip line is discarded, resulting in a new

@ -65,7 +65,7 @@ struct Band
Limit Upper;
};
/// Given the FFT frequency array and the bandwidth, constuct the frequency bands
/// Given the FFT frequency array and the bandwidth, construct the frequency bands
/// limits that will be used for generating the fitlered values per band later.
/// Also construct the xAxis which contains the range for each generated bin so
/// that user can plot the bins nicely.

@ -115,7 +115,7 @@ int vtkExtractGrid::RequestUpdateExtent(vtkInformation* vtkNotUsed(request),
vtkLogF(TRACE, "oUExt: %d,%d %d,%d %d,%d", oUExt[0], oUExt[1], oUExt[2], oUExt[3], oUExt[4],
oUExt[5]);
int oWExt[6]; // For parallel parititon this will be different.
int oWExt[6]; // For parallel partition this will be different.
this->Internal->GetOutputWholeExtent(oWExt);
vtkLogF(TRACE, "oWExt: %d,%d %d,%d %d,%d", oWExt[0], oWExt[1], oWExt[2], oWExt[3], oWExt[4],
oWExt[5]);

@ -82,7 +82,7 @@ int vtkExtractRectilinearGrid::RequestUpdateExtent(
int oUExt[6];
outputVector->GetInformationObject(0)->Get(
vtkStreamingDemandDrivenPipeline::UPDATE_EXTENT(), oUExt);
int oWExt[6]; // For parallel parititon this will be different.
int oWExt[6]; // For parallel partition this will be different.
this->Internal->GetOutputWholeExtent(oWExt);
for (i = 0; i < 3; i++)
{

@ -436,21 +436,21 @@ public:
virtual void InitializeParticleData(vtkFieldData* particleData, int maxTuples = 0);
/**
* Method used by the LPT to insert data from the partice into
* Method used by the LPT to insert data from the particle into
* the provided vtkFieldData. It inserts Id, ParentID, SeedID and Termination.
* Reimplement as needed in accordance with InitializePathData.
*/
virtual void InsertPathData(vtkLagrangianParticle* particle, vtkFieldData* data);
/**
* Method used by the LPT to insert data from the partice into
* Method used by the LPT to insert data from the particle into
* the provided vtkFieldData. It inserts Interaction.
* Reimplement as needed in accordance with InitializeInteractionData.
*/
virtual void InsertInteractionData(vtkLagrangianParticle* particle, vtkFieldData* data);
/**
* Method used by the LPT to insert data from the partice into
* Method used by the LPT to insert data from the particle into
* the provided vtkFieldData. It inserts StepNumber, ParticleVelocity, IntegrationTime.
* stepEnum enables to select which data to insert, Prev, Current or Next.
* Reimplement as needed in accordance with InitializeParticleData.
@ -459,7 +459,7 @@ public:
vtkLagrangianParticle* particle, vtkFieldData* data, int stepEnum);
/**
* Method used by the LPT to insert data from the partice into
* Method used by the LPT to insert data from the particle into
* the provided vtkFieldData. It inserts all arrays from the original SeedData.
* Reimplement as needed.
*/

@ -72,7 +72,7 @@ private:
* loop: 1.advect one step at a time
* 2. then form surface strip and add it to existing surface
* 3. then check if points have diverged and insert new ones if necessary
* field is the vecotr values dataset in which the streamsurface is advected
* field is the vector values dataset in which the streamsurface is advected
* seeds is the polydata with the start curve
* output is the final streamsurface
* @param field: vector field in which the surfave is advected

@ -379,7 +379,7 @@ int vtkVectorFieldTopology::ComputeCriticalPoints2D(
{
valueMatrix->Invert();
// barycentric corrdinates of the zero: lambda = f(T)^-1 (-values[0])
// barycentric coordinates of the zero: lambda = f(T)^-1 (-values[0])
double lambda[3] = { -values[0][0], -values[0][1], -values[0][2] };
valueMatrix->MultiplyPoint(lambda, lambda);
@ -651,14 +651,14 @@ int vtkVectorFieldTopology::ComputeBoundarySwitchPoints(
x = vn0 / y;
// if the location is inbwteen the two end points of the line
// if the location is in between the two end points of the line
if (x > 0 && x < 1)
{
InterpolateVector(0, 1, x, vector0, vector1, vector);
double vectorNorm = vtkMath::Norm(vector);
// if the verctor at the boundary switch point is not a zero vector
// if the vector at the boundary switch point is not a zero vector
if (vectorNorm > 1e-16)
{
vtkMath::MultiplyScalar(vector, 1 / vectorNorm);
@ -1147,7 +1147,7 @@ int vtkVectorFieldTopology::ComputeSeparatricesBoundarySwitchLines(vtkPolyData*
normalArray->SetTuple3(i, x[0], x[1], x[2]);
}
// the outputs of the countour filter are potential boundary switch lines.
// the outputs of the contour filter are potential boundary switch lines.
// computed shifted boundary switch lines as seeds for computing separating surfaces
for (int i = 0; i < contourFilter->GetOutput()->GetNumberOfCells(); i++)
{
@ -1197,7 +1197,7 @@ int vtkVectorFieldTopology::ComputeSeparatricesBoundarySwitchLines(vtkPolyData*
}
}
// use probe filter to interpolate the verctors at seeds points and center points of lines
// use probe filter to interpolate the vectors at seeds points and center points of lines
vtkNew<vtkProbeFilter> probe;
probe->SetInputData(offsetPoints);
probe->SetSourceData(dataset);

@ -49,8 +49,8 @@ public:
/**
* Specify a uniform integration step unit for MinimumIntegrationStep,
* InitialIntegrationStep, and MaximumIntegrationStep.
* 1 = LENGTH_UNIT, i.e. all sizes are expresed in coordinate scale or cell scale
* 2 = CELL_LENGTH_UNIT, i.e. all sizes are expresed in cell scale
* 1 = LENGTH_UNIT, i.e. all sizes are expressed in coordinate scale or cell scale
* 2 = CELL_LENGTH_UNIT, i.e. all sizes are expressed in cell scale
*/
vtkSetMacro(IntegrationStepUnit, int);
vtkGetMacro(IntegrationStepUnit, int);