From 80b11afa24bdd4f9095de8c9c16208a412e5fe2e Mon Sep 17 00:00:00 2001 From: "luz.paz" Date: Mon, 29 Jan 2018 19:24:31 -0500 Subject: [PATCH] Misc. typos Found via `codespell -q 3` via downstream VTK --- CMake/FindTBB.cmake | 2 +- CMake/VTKmCheckPyexpander.cmake | 2 +- CMake/VTKmConfigureComponents.cmake | 6 +++--- CMake/VTKmMacros.cmake | 2 +- CMakeLists.txt | 2 +- CONTRIBUTING.md | 2 +- vtkm/Bounds.h | 2 +- vtkm/Matrix.h | 2 +- vtkm/Range.h | 2 +- vtkm/RangeId.h | 2 +- vtkm/RangeId3.h | 2 +- vtkm/Transform3D.h | 2 +- vtkm/TypeTraits.h | 4 ++-- vtkm/Types.h | 4 ++-- vtkm/VecTraits.h | 2 +- vtkm/VectorAnalysis.h | 2 +- vtkm/benchmarking/BenchmarkDeviceAdapter.cxx | 2 +- vtkm/cont/ArrayHandleTransform.h | 2 +- vtkm/cont/ArrayPortalToIterators.h | 4 ++-- vtkm/cont/DeviceAdapterAlgorithm.h | 2 +- vtkm/cont/DynamicArrayHandle.h | 4 ++-- vtkm/cont/Field.h | 2 +- vtkm/cont/MultiBlock.h | 10 +++++----- vtkm/cont/RuntimeDeviceTracker.h | 4 ++-- vtkm/cont/Storage.h | 2 +- vtkm/cont/Timer.h | 2 +- vtkm/cont/cuda/internal/CudaAllocator.h | 2 +- .../cuda/internal/DeviceAdapterAlgorithmThrust.h | 2 +- vtkm/cont/internal/ArrayManagerExecution.h | 2 +- vtkm/cont/internal/DeviceAdapterAlgorithmGeneral.h | 2 +- .../testing/UnitTestArrayPortalFromIterators.cxx | 2 +- .../TestingCellLocatorTwoLevelUniformGrid.h | 2 +- vtkm/exec/CellFace.h | 2 +- vtkm/exec/CellInterpolate.h | 8 ++++---- vtkm/exec/ParametricCoordinates.h | 2 +- vtkm/exec/arg/Fetch.h | 2 +- vtkm/exec/arg/FetchTagArrayDirectIn.h | 2 +- vtkm/exec/arg/FetchTagArrayTopologyMapIn.h | 2 +- vtkm/exec/arg/FetchTagCellSetIn.h | 2 +- vtkm/exec/arg/FetchTagExecObject.h | 2 +- vtkm/exec/arg/ThreadIndicesPointNeighborhood.h | 6 +++--- vtkm/exec/arg/ThreadIndicesTopologyMap.h | 14 +++++++------- vtkm/exec/testing/UnitTestCellDerivative.cxx | 2 +- .../filter/testing/UnitTestExternalFacesFilter.cxx | 4 ++-- vtkm/filter/testing/UnitTestGradient.cxx | 4 ++-- vtkm/internal/ArrayPortalValueReference.h | 2 +- vtkm/internal/Configure.h.in | 4 ++-- vtkm/internal/FunctionInterface.h | 2 +- .../internal/testing/UnitTestFunctionInterface.cxx | 2 +- vtkm/interop/internal/TransferToOpenGL.h | 2 +- vtkm/interop/testing/UnitTestFancyTransferGLUT.cxx | 2 +- vtkm/interop/testing/UnitTestTransferGLUT.cxx | 2 +- vtkm/io/reader/BOVDataSetReader.h | 2 +- vtkm/rendering/CMakeLists.txt | 4 ++-- vtkm/rendering/Camera.h | 2 +- vtkm/rendering/CanvasRayTracer.cxx | 2 +- vtkm/rendering/ColorTable.h | 2 +- vtkm/rendering/DecodePNG.cxx | 4 ++-- vtkm/rendering/Triangulator.h | 2 +- vtkm/rendering/raytracing/ChannelBuffer.h | 4 ++-- vtkm/rendering/raytracing/ConnectivityTracer.h | 2 +- vtkm/rendering/raytracing/ConnectivityTracer.hxx | 6 +++--- .../raytracing/ConnectivityTracerBase.cxx | 2 +- .../rendering/raytracing/MeshConnectivityBuilder.h | 6 +++--- .../raytracing/MeshConnectivityStructures.h | 6 +++--- vtkm/rendering/raytracing/MortonCodes.h | 2 +- vtkm/rendering/raytracing/RayOperations.h | 2 +- .../raytracing/VolumeRendererStructured.cxx | 2 +- vtkm/testing/OptionParser.h | 2 +- vtkm/testing/Testing.h | 2 +- vtkm/testing/UnitTestMatrix.cxx | 8 ++++---- vtkm/testing/UnitTestTransform3D.cxx | 2 +- .../diy/vtkmdiy/include/vtkmdiy/io/block.hpp | 2 +- .../vtkmdiy/include/vtkmdiy/mpi/communicator.hpp | 2 +- vtkm/worklet/Clip.h | 2 +- vtkm/worklet/MarchingCubes.h | 2 +- vtkm/worklet/NDimsHistMarginalization.h | 2 +- vtkm/worklet/RemoveUnusedPoints.h | 6 +++--- vtkm/worklet/internal/DispatcherBase.h | 2 +- vtkm/worklet/splatkernels/Gaussian.h | 2 +- vtkm/worklet/testing/UnitTestCrossProduct.cxx | 2 +- .../testing/UnitTestNDimsHistMarginalization.cxx | 2 +- vtkm/worklet/wavelets/WaveletDWT.h | 6 +++--- vtkm/worklet/wavelets/WaveletTransforms.h | 4 ++-- 84 files changed, 126 insertions(+), 126 deletions(-) diff --git a/CMake/FindTBB.cmake b/CMake/FindTBB.cmake index a0cafc3f9..4bb4accdd 100644 --- a/CMake/FindTBB.cmake +++ b/CMake/FindTBB.cmake @@ -174,7 +174,7 @@ endif () # will never adequately match the user's setup, so there is no feasible way # to detect the "best" version to use. The user will have to manually # select the right files. (Chances are the distributions are shipping their -# custom version of tbb, anyway, so the problem is probably nonexistant.) +# custom version of tbb, anyway, so the problem is probably nonexistent.) if (WIN32 AND MSVC) set(COMPILER_PREFIX "vc7.1") if (MSVC_VERSION EQUAL 1400) diff --git a/CMake/VTKmCheckPyexpander.cmake b/CMake/VTKmCheckPyexpander.cmake index 318eb99b4..c1d00332b 100644 --- a/CMake/VTKmCheckPyexpander.cmake +++ b/CMake/VTKmCheckPyexpander.cmake @@ -70,7 +70,7 @@ if(${diff_result}) # If diff returned non-zero, it failed and the two files are different. get_filename_component(filename ${SOURCE_FILE} NAME) message(SEND_ERROR - "The source file ${filename} does not match the generated file. If you have modified this file directly, then you have messed up. Modify the ${filename}.in file instead and then copy the pyexpander result to ${filename}. If you modified ${filename}.in, then you might just need to copy the pyresult back to the source directory. If you have not modifed either, then you have likely checked out an inappropriate change. Check the git logs to see what changes were made. + "The source file ${filename} does not match the generated file. If you have modified this file directly, then you have messed up. Modify the ${filename}.in file instead and then copy the pyexpander result to ${filename}. If you modified ${filename}.in, then you might just need to copy the pyresult back to the source directory. If you have not modified either, then you have likely checked out an inappropriate change. Check the git logs to see what changes were made. If the changes have resulted from modifying ${filename}.in, then you can finish by moving ${GENERATED_FILE}.save over ${SOURCE_FILE}") else() # Now that we have done the comparison, remove the generated file so there is diff --git a/CMake/VTKmConfigureComponents.cmake b/CMake/VTKmConfigureComponents.cmake index f167b925c..aa2ce9862 100644 --- a/CMake/VTKmConfigureComponents.cmake +++ b/CMake/VTKmConfigureComponents.cmake @@ -111,7 +111,7 @@ macro(vtkm_configure_component_Base) endif() endif() - # Check for the existance of the base vtkm target + # Check for the existence of the base vtkm target if (TARGET vtkm) set(VTKm_base_vtkm_target_FOUND True) endif() @@ -179,7 +179,7 @@ macro(vtkm_configure_component_OpenGL) #setting VTKm_OPENGL_INCLUDE_DIRS when both mesa and #opengl are not present causes cmake to fail to configure - #becase of a percieved dependency in the rendering lib + #because of a perceived dependency in the rendering lib if(VTKm_OSMesa_FOUND OR OPENGL_FOUND) set(VTKm_OPENGL_INCLUDE_DIRS ${vtkm_opengl_includes}) set(VTKm_OPENGL_LIBRARIES ${vtkm_opengl_libraries}) @@ -350,7 +350,7 @@ macro(vtkm_configure_component_CUDA) set(VTKm_CUDA_Architecture "native" CACHE STRING "Which GPU Architecture(s) to compile for") set_property(CACHE VTKm_CUDA_Architecture PROPERTY STRINGS native fermi kepler maxwell pascal volta all) - #detect what the propery is set too + #detect what the property is set too if(VTKm_CUDA_Architecture STREQUAL "native") if(VTKM_CUDA_NATIVE_EXE_PROCESS_RAN_OUTPUT) diff --git a/CMake/VTKmMacros.cmake b/CMake/VTKmMacros.cmake index 87b983452..7fd148734 100644 --- a/CMake/VTKmMacros.cmake +++ b/CMake/VTKmMacros.cmake @@ -186,7 +186,7 @@ function(vtkm_add_header_build_test name dir_prefix use_cuda) vtkm_setup_msvc_properties(TestBuild_${name}) # Send the libraries created for test builds to their own directory so as to - # not polute the directory with useful libraries. + # not pollute the directory with useful libraries. set_target_properties(TestBuild_${name} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${VTKm_LIBRARY_OUTPUT_PATH}/testbuilds LIBRARY_OUTPUT_DIRECTORY ${VTKm_LIBRARY_OUTPUT_PATH}/testbuilds diff --git a/CMakeLists.txt b/CMakeLists.txt index e448826ef..169a84040 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -94,7 +94,7 @@ if(NOT VTKm_Base_FOUND) endif() #----------------------------------------------------------------------------- -# When using C++11 suport make sure you use the standard C++ extensions rather +# When using C++11 support make sure you use the standard C++ extensions rather # than compiler-specific versions of the extensions (to preserve portability). set(CMAKE_CXX_EXTENSIONS False) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 9ff08da21..744a98fad 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -436,7 +436,7 @@ authorized developers may add a comment with a single *trailing* line: Do: merge to ask that the change be merged into the upstream repository. By -convention, only merge if you have recieved `+1` . Do not request a merge +convention, only merge if you have received `+1` . Do not request a merge if any `-1` review comments have not been resolved. ### Merge Success ### diff --git a/vtkm/Bounds.h b/vtkm/Bounds.h index 9e8546e68..354757cae 100644 --- a/vtkm/Bounds.h +++ b/vtkm/Bounds.h @@ -142,7 +142,7 @@ struct Bounds /// \b Expand bounds to include other bounds. /// /// This version of \c Include expands these bounds just enough to include - /// that of another bounds. Esentially it is the union of the two bounds. + /// that of another bounds. Essentially it is the union of the two bounds. /// VTKM_EXEC_CONT void Include(const vtkm::Bounds& bounds) diff --git a/vtkm/Matrix.h b/vtkm/Matrix.h index 03404ce9b..897b43d15 100644 --- a/vtkm/Matrix.h +++ b/vtkm/Matrix.h @@ -329,7 +329,7 @@ VTKM_EXEC_CONT void MatrixLUPFactorFindUpperTriangleElements(vtkm::Matrix Transform3DPoint(const vtkm::Matrix& mat /// transformed by the given matrix in homogeneous coordinates. /// /// Unlike Transform3DPoint, this method honors the fourth component of the -/// transformed homogeneous coordiante. This makes it applicable for perspective +/// transformed homogeneous coordinate. This makes it applicable for perspective /// transformations, but requires some more computations. /// template diff --git a/vtkm/TypeTraits.h b/vtkm/TypeTraits.h index 5b4f258fa..03d01984d 100644 --- a/vtkm/TypeTraits.h +++ b/vtkm/TypeTraits.h @@ -63,7 +63,7 @@ struct TypeTraitsVectorTag }; /// The TypeTraits class provides helpful compile-time information about the -/// basic types used in VTKm (and a few others for convienience). The majority +/// basic types used in VTKm (and a few others for convenience). The majority /// of TypeTraits contents are typedefs to tags that can be used to easily /// override behavior of called functions. /// @@ -71,7 +71,7 @@ template class TypeTraits { public: - /// \brief A tag to determing whether the type is integer or real. + /// \brief A tag to determine whether the type is integer or real. /// /// This tag is either TypeTraitsRealTag or TypeTraitsIntegerTag. using NumericTag = vtkm::TypeTraitsUnknownTag; diff --git a/vtkm/Types.h b/vtkm/Types.h index 85dc460bb..7db5fd940 100644 --- a/vtkm/Types.h +++ b/vtkm/Types.h @@ -48,7 +48,7 @@ * \brief Transportation controls for Control Environment Objects. * * vtkm::cont::arg includes the classes that allows the vtkm::worklet::Dispatchers - * to request Control Environment Objects to be transfered to the Execution Environment. + * to request Control Environment Objects to be transferred to the Execution Environment. * * \namespace vtkm::cont::cuda * \brief CUDA implementation for Control Environment. @@ -790,7 +790,7 @@ protected: /// The \c Vec class is most often used to represent vectors in the /// mathematical sense as a quantity with a magnitude and direction. Vectors /// are, of course, used extensively in computational geometry as well as -/// phyiscal simulations. The \c Vec class can be (and is) repurposed for more +/// physical simulations. The \c Vec class can be (and is) repurposed for more /// general usage of holding a fixed-length sequence of objects. /// /// There is no real limit to the size of the sequence (other than the largest diff --git a/vtkm/VecTraits.h b/vtkm/VecTraits.h index 24059de33..918e64e69 100644 --- a/vtkm/VecTraits.h +++ b/vtkm/VecTraits.h @@ -367,7 +367,7 @@ struct VecTraitsBasic /// \brief VecTraits for Pair types /// -/// Although a pair woudl seem better as a size-2 vector, we treat it as a +/// Although a pair would seem better as a size-2 vector, we treat it as a /// scalar. This is because a \c Vec is assumed to have the same type for /// every component, and a pair in general has a different type for each /// component. Thus we treat a pair as a "scalar" unit. diff --git a/vtkm/VectorAnalysis.h b/vtkm/VectorAnalysis.h index 43a8921a9..65e3757c8 100644 --- a/vtkm/VectorAnalysis.h +++ b/vtkm/VectorAnalysis.h @@ -22,7 +22,7 @@ #ifndef vtk_m_VectorAnalysis_h #define vtk_m_VectorAnalysis_h -// This header file defines math functions that deal with linear albegra funcitons +// This header file defines math functions that deal with linear albegra functions #include #include diff --git a/vtkm/benchmarking/BenchmarkDeviceAdapter.cxx b/vtkm/benchmarking/BenchmarkDeviceAdapter.cxx index a282d4e4c..eb6325c79 100644 --- a/vtkm/benchmarking/BenchmarkDeviceAdapter.cxx +++ b/vtkm/benchmarking/BenchmarkDeviceAdapter.cxx @@ -418,7 +418,7 @@ private: typedef vtkm::cont::ArrayHandle ValueArrayHandle; ValueArrayHandle InputHandle; - // We don't actually use this, but we need it to prevent sufficently + // We don't actually use this, but we need it to prevent sufficiently // smart compilers from optimizing the Reduce call out. Value Result; diff --git a/vtkm/cont/ArrayHandleTransform.h b/vtkm/cont/ArrayHandleTransform.h index 120d8184f..624e8f428 100644 --- a/vtkm/cont/ArrayHandleTransform.h +++ b/vtkm/cont/ArrayHandleTransform.h @@ -436,7 +436,7 @@ public: { throw vtkm::cont::ErrorInternal( "ArrayHandleTransform read only. " - "There should be no occurance of the ArrayHandle trying to pull " + "There should be no occurrence of the ArrayHandle trying to pull " "data from the execution environment."); } diff --git a/vtkm/cont/ArrayPortalToIterators.h b/vtkm/cont/ArrayPortalToIterators.h index 92e9296b2..fa6cf873f 100644 --- a/vtkm/cont/ArrayPortalToIterators.h +++ b/vtkm/cont/ArrayPortalToIterators.h @@ -75,7 +75,7 @@ private: PortalType Portal; }; -/// Convienience function for converting an ArrayPortal to a begin iterator. +/// Convenience function for converting an ArrayPortal to a begin iterator. /// VTKM_SUPPRESS_EXEC_WARNINGS template @@ -86,7 +86,7 @@ ArrayPortalToIteratorBegin(const PortalType& portal) return iterators.GetBegin(); } -/// Convienience function for converting an ArrayPortal to an end iterator. +/// Convenience function for converting an ArrayPortal to an end iterator. /// VTKM_SUPPRESS_EXEC_WARNINGS template diff --git a/vtkm/cont/DeviceAdapterAlgorithm.h b/vtkm/cont/DeviceAdapterAlgorithm.h index 8e83ebd87..9454244bd 100644 --- a/vtkm/cont/DeviceAdapterAlgorithm.h +++ b/vtkm/cont/DeviceAdapterAlgorithm.h @@ -631,7 +631,7 @@ class DeviceAdapterAtomicArrayImplementation; /// \brief Class providing a device-specific support for selecting the optimal /// Task type for a given worklet. /// -/// When worklets are launched inside the execution enviornment we need to +/// When worklets are launched inside the execution environment we need to /// ask the device adapter what is the preferred execution style, be it /// a tiled iteration pattern, or strided. This class /// diff --git a/vtkm/cont/DynamicArrayHandle.h b/vtkm/cont/DynamicArrayHandle.h index bae63cd24..1d8d0b215 100644 --- a/vtkm/cont/DynamicArrayHandle.h +++ b/vtkm/cont/DynamicArrayHandle.h @@ -67,7 +67,7 @@ struct VTKM_CONT_EXPORT PolymorphicArrayHandleContainerBase /// /// The \c PolymorphicArrayHandleContainer is similar to the /// \c SimplePolymorphicContainer in that it can contain an object of an -/// unkown type. However, this class specifically holds ArrayHandle objects +/// unknown type. However, this class specifically holds ArrayHandle objects /// (with different template parameters) so that it can polymorphically answer /// simple questions about the object. /// @@ -289,7 +289,7 @@ public: return this->CastToTypeStorage(); } - /// Given a refernce to an ArrayHandle object, casts this array to the + /// Given a references to an ArrayHandle object, casts this array to the /// ArrayHandle's type and sets the given ArrayHandle to this array. Throws /// \c ErrorBadType if the cast does not work. Use \c /// ArrayHandleType to check if the cast can happen. diff --git a/vtkm/cont/Field.h b/vtkm/cont/Field.h index ee659c295..78c7199eb 100644 --- a/vtkm/cont/Field.h +++ b/vtkm/cont/Field.h @@ -308,7 +308,7 @@ void CastAndCall(const vtkm::cont::Field& field, Functor&& f, Args&&... args) } //@{ -/// Convinience functions to build fields from C style arrays and std::vector +/// Convenience functions to build fields from C style arrays and std::vector template vtkm::cont::Field make_Field(std::string name, Field::AssociationEnum association, diff --git a/vtkm/cont/MultiBlock.h b/vtkm/cont/MultiBlock.h index 3261cb3ec..6b732c336 100644 --- a/vtkm/cont/MultiBlock.h +++ b/vtkm/cont/MultiBlock.h @@ -36,16 +36,16 @@ namespace cont class VTKM_CONT_EXPORT MultiBlock { public: - /// creat a new MultiBlcok containng a single DataSet "ds" + /// create a new MultiBlock containng a single DataSet "ds" VTKM_CONT MultiBlock(const vtkm::cont::DataSet& ds); - /// creat a new MultiBlcok with the exisiting one "src" + /// create a new MultiBlock with the existing one "src" VTKM_CONT MultiBlock(const vtkm::cont::MultiBlock& src); - /// creat a new MultiBlcok with a DataSet vector "mblocks" + /// create a new MultiBlock with a DataSet vector "mblocks" VTKM_CONT MultiBlock(const std::vector& mblocks); - /// creat a new MultiBlcok with the capacity set to be "size" + /// create a new MultiBlock with the capacity set to be "size" VTKM_CONT MultiBlock(vtkm::Id size); @@ -57,7 +57,7 @@ public: VTKM_CONT ~MultiBlock(); - /// get the field "field_name" from blcok "block_index" + /// get the field "field_name" from block "block_index" VTKM_CONT vtkm::cont::Field GetField(const std::string& field_name, const int& block_index); diff --git a/vtkm/cont/RuntimeDeviceTracker.h b/vtkm/cont/RuntimeDeviceTracker.h index bd873076c..a83902bb5 100644 --- a/vtkm/cont/RuntimeDeviceTracker.h +++ b/vtkm/cont/RuntimeDeviceTracker.h @@ -131,7 +131,7 @@ public: /// /// If you want a \c RuntimeDeviceTracker with independent state, just create /// one independently. If you want to start with the state of a source - /// \c RuntimeDeviceTracker but update the state indepenently, you can use + /// \c RuntimeDeviceTracker but update the state independently, you can use /// \c DeepCopy method to get the initial state. Further changes will /// not be shared. /// @@ -152,7 +152,7 @@ public: /// /// If you want a \c RuntimeDeviceTracker with independent state, just create /// one independently. If you want to start with the state of a source - /// \c RuntimeDeviceTracker but update the state indepenently, you can use + /// \c RuntimeDeviceTracker but update the state independently, you can use /// \c DeepCopy method to get the initial state. Further changes will /// not be shared. /// diff --git a/vtkm/cont/Storage.h b/vtkm/cont/Storage.h index d30b9815a..43fae45e3 100644 --- a/vtkm/cont/Storage.h +++ b/vtkm/cont/Storage.h @@ -132,7 +132,7 @@ public: VTKM_CONT PortalConstType GetPortalConst() const; - /// Retuns the number of entries allocated in the array. + /// Returns the number of entries allocated in the array. VTKM_CONT vtkm::Id GetNumberOfValues() const; diff --git a/vtkm/cont/Timer.h b/vtkm/cont/Timer.h index c6dda867a..ac2182dba 100644 --- a/vtkm/cont/Timer.h +++ b/vtkm/cont/Timer.h @@ -27,7 +27,7 @@ namespace vtkm namespace cont { -/// A class that can be used to time operations in VTK-m that might be occuring +/// A class that can be used to time operations in VTK-m that might be occurring /// in parallel. You should make sure that the device adapter for the timer /// matches that being used to execute algorithms to ensure that the thread /// synchronization is correct. diff --git a/vtkm/cont/cuda/internal/CudaAllocator.h b/vtkm/cont/cuda/internal/CudaAllocator.h index 937afda0f..aae81b4c5 100644 --- a/vtkm/cont/cuda/internal/CudaAllocator.h +++ b/vtkm/cont/cuda/internal/CudaAllocator.h @@ -42,7 +42,7 @@ struct VTKM_CONT_EXPORT CudaAllocator /// that can be accessed concurrently by the CPU and GPUs. static VTKM_CONT bool UsingManagedMemory(); - /// Returns true if the pointer is accessable from a CUDA device. + /// Returns true if the pointer is accessible from a CUDA device. static VTKM_CONT bool IsDevicePointer(const void* ptr); /// Returns true if the pointer is a CUDA pointer allocated with diff --git a/vtkm/cont/cuda/internal/DeviceAdapterAlgorithmThrust.h b/vtkm/cont/cuda/internal/DeviceAdapterAlgorithmThrust.h index 6846c4adb..c2b16311c 100644 --- a/vtkm/cont/cuda/internal/DeviceAdapterAlgorithmThrust.h +++ b/vtkm/cont/cuda/internal/DeviceAdapterAlgorithmThrust.h @@ -356,7 +356,7 @@ private: BinaryFunctor binary_functor, std::false_type) { - //The portal type and the initial value ARENT the same type so we have + //The portal type and the initial value AREN'T the same type so we have //to a slower approach, where we wrap the input portal inside a cast //portal using CastFunctor = vtkm::cont::internal::Cast; diff --git a/vtkm/cont/internal/ArrayManagerExecution.h b/vtkm/cont/internal/ArrayManagerExecution.h index 4adc9e1a9..0eb9e0f0d 100644 --- a/vtkm/cont/internal/ArrayManagerExecution.h +++ b/vtkm/cont/internal/ArrayManagerExecution.h @@ -40,7 +40,7 @@ namespace internal /// any resources in its destructor. /// /// This class typically takes on one of two forms. If the control and -/// execution environments have seperate memory spaces, then this class +/// execution environments have separate memory spaces, then this class /// behaves how you would expect. It allocates/deallocates arrays and copies /// data. However, if the control and execution environments share the same /// memory space, this class should delegate all its operations to the diff --git a/vtkm/cont/internal/DeviceAdapterAlgorithmGeneral.h b/vtkm/cont/internal/DeviceAdapterAlgorithmGeneral.h index 54840f01b..f17fa9d31 100644 --- a/vtkm/cont/internal/DeviceAdapterAlgorithmGeneral.h +++ b/vtkm/cont/internal/DeviceAdapterAlgorithmGeneral.h @@ -1007,7 +1007,7 @@ private: /// \brief Class providing a device-specific support for selecting the optimal /// Task type for a given worklet. /// -/// When worklets are launched inside the execution enviornment we need to +/// When worklets are launched inside the execution environment we need to /// ask the device adapter what is the preferred execution style, be it /// a tiled iteration pattern, or strided. This class /// diff --git a/vtkm/cont/internal/testing/UnitTestArrayPortalFromIterators.cxx b/vtkm/cont/internal/testing/UnitTestArrayPortalFromIterators.cxx index 60ffbca3b..89a29e5ad 100644 --- a/vtkm/cont/internal/testing/UnitTestArrayPortalFromIterators.cxx +++ b/vtkm/cont/internal/testing/UnitTestArrayPortalFromIterators.cxx @@ -119,7 +119,7 @@ struct TemplatedTests VTKM_TEST_ASSERT(const_portal.GetNumberOfValues() == ARRAY_SIZE, "Const portal array size wrong."); - std::cout << " Check inital value." << std::endl; + std::cout << " Check initial value." << std::endl; VTKM_TEST_ASSERT(CheckPortal(portal, ORIGINAL_VALUE), "Portal iterator has bad value."); VTKM_TEST_ASSERT(CheckPortal(const_portal, ORIGINAL_VALUE), "Const portal iterator has bad value."); diff --git a/vtkm/cont/testing/TestingCellLocatorTwoLevelUniformGrid.h b/vtkm/cont/testing/TestingCellLocatorTwoLevelUniformGrid.h index 87616ef97..11fd55fb9 100644 --- a/vtkm/cont/testing/TestingCellLocatorTwoLevelUniformGrid.h +++ b/vtkm/cont/testing/TestingCellLocatorTwoLevelUniformGrid.h @@ -128,7 +128,7 @@ vtkm::cont::DataSet MakeTestDataSet(const vtkm::Vec& dims, VTKM_ASSERT(false); } - // It is posible that the warping will result in invalid cells. So use a + // It is possible that the warping will result in invalid cells. So use a // local random generator with a known seed that does not create invalid cells. std::default_random_engine rgen; diff --git a/vtkm/exec/CellFace.h b/vtkm/exec/CellFace.h index 161f97272..1ee78c6e4 100644 --- a/vtkm/exec/CellFace.h +++ b/vtkm/exec/CellFace.h @@ -265,7 +265,7 @@ static inline VTKM_EXEC vtkm::VecCConst CellFaceLocalIndices( numPointsInFace); } -/// \brief Returns a canonical identifer for a cell face +/// \brief Returns a canonical identifier for a cell face /// /// Given information about a cell face and the global point indices for that cell, returns a /// vtkm::Id3 that contains values that are unique to that face. The values for two faces will be diff --git a/vtkm/exec/CellInterpolate.h b/vtkm/exec/CellInterpolate.h index a105463ae..c296c4f69 100644 --- a/vtkm/exec/CellInterpolate.h +++ b/vtkm/exec/CellInterpolate.h @@ -67,8 +67,8 @@ VTKM_EXEC typename WorldCoordVector::ComponentType ReverseInterpolateTriangle( // // In this diagram, the distance between p0 and the point marked x divided by // the length of the edge it is on is equal, by proportionality, to the u - // parametric coordiante. (The v coordinate follows the other edge - // accordingly.) Thus, if we can find the interesection at x (or more + // parametric coordinate. (The v coordinate follows the other edge + // accordingly.) Thus, if we can find the intersection at x (or more // specifically the distance between p0 and x), then we can find that // parametric coordinate. // @@ -94,13 +94,13 @@ VTKM_EXEC typename WorldCoordVector::ComponentType ReverseInterpolateTriangle( // compute it, we are done. We can skip the part about finding the actual // coordinates of the intersection. // - // Solving for the interesection is as simple as substituting the line's + // Solving for the intersection is as simple as substituting the line's // definition of p(d) into p for the plane equation. With some basic algebra // you get: // // d = dot((wcoords - p0), planeNormal)/dot((p1-p0), planeNormal) // - // From here, the u coordiante is simply d. The v coordinate follows + // From here, the u coordinate is simply d. The v coordinate follows // similarly. // diff --git a/vtkm/exec/ParametricCoordinates.h b/vtkm/exec/ParametricCoordinates.h index 9bf5f0361..7946faa47 100644 --- a/vtkm/exec/ParametricCoordinates.h +++ b/vtkm/exec/ParametricCoordinates.h @@ -786,7 +786,7 @@ WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords, VTKM_ASSERT(pointWCoords.GetNumberOfComponents() == 2); success = true; - // Because this is a line, there is only one vaild parametric coordinate. Let + // Because this is a line, there is only one valid parametric coordinate. Let // vec be the vector from the first point to the second point // (pointWCoords[1] - pointWCoords[0]), which is the direction of the line. // dot(vec,wcoords-pointWCoords[0])/mag(vec) is the orthoginal projection of diff --git a/vtkm/exec/arg/Fetch.h b/vtkm/exec/arg/Fetch.h index bbdb74cc3..753ab721e 100644 --- a/vtkm/exec/arg/Fetch.h +++ b/vtkm/exec/arg/Fetch.h @@ -47,7 +47,7 @@ namespace arg /// object associated where the fetch (nominally) gets its data from. This /// execution object is the data provided by the transport. /// -/// There is no generic implementaiton of \c Fetch. There are partial +/// There is no generic implementation of \c Fetch. There are partial /// specializations of \c Fetch for each mechanism (fetch-aspect tag /// combination) supported. If you get a compiler error about an incomplete /// type for \c Fetch, it means you used an invalid \c FetchTag - \c AspectTag diff --git a/vtkm/exec/arg/FetchTagArrayDirectIn.h b/vtkm/exec/arg/FetchTagArrayDirectIn.h index 74e3c6b36..f5df7e34f 100644 --- a/vtkm/exec/arg/FetchTagArrayDirectIn.h +++ b/vtkm/exec/arg/FetchTagArrayDirectIn.h @@ -32,7 +32,7 @@ namespace arg /// \brief \c Fetch tag for getting array values with direct indexing. /// -/// \c FetchTagArrayDirectIn is a tag used with the \c Fetch class to retreive +/// \c FetchTagArrayDirectIn is a tag used with the \c Fetch class to retrieve /// values from an array portal. The fetch uses direct indexing, so the thread /// index given to \c Load is used as the index into the array. /// diff --git a/vtkm/exec/arg/FetchTagArrayTopologyMapIn.h b/vtkm/exec/arg/FetchTagArrayTopologyMapIn.h index 5c6c89eee..873a4460c 100644 --- a/vtkm/exec/arg/FetchTagArrayTopologyMapIn.h +++ b/vtkm/exec/arg/FetchTagArrayTopologyMapIn.h @@ -43,7 +43,7 @@ namespace arg /// \brief \c Fetch tag for getting array values determined by topology connections. /// /// \c FetchTagArrayTopologyMapIn is a tag used with the \c Fetch class to -/// retreive values from an array portal. The fetch uses indexing based on +/// retrieve values from an array portal. The fetch uses indexing based on /// the topology structure used for the input domain. /// struct FetchTagArrayTopologyMapIn diff --git a/vtkm/exec/arg/FetchTagCellSetIn.h b/vtkm/exec/arg/FetchTagCellSetIn.h index 9801d1a0f..60659c623 100644 --- a/vtkm/exec/arg/FetchTagCellSetIn.h +++ b/vtkm/exec/arg/FetchTagCellSetIn.h @@ -33,7 +33,7 @@ namespace arg /// \brief \c Fetch tag for getting topology information. /// -/// \c FetchTagCellSetIn is a tag used with the \c Fetch class to retreive +/// \c FetchTagCellSetIn is a tag used with the \c Fetch class to retrieve /// values from a topology object. This default parameter returns /// the basis topology type, i.e. cell type in a \c WorkletCellMap. /// diff --git a/vtkm/exec/arg/FetchTagExecObject.h b/vtkm/exec/arg/FetchTagExecObject.h index 2bd03ac14..b2127d6ee 100644 --- a/vtkm/exec/arg/FetchTagExecObject.h +++ b/vtkm/exec/arg/FetchTagExecObject.h @@ -36,7 +36,7 @@ namespace arg /// \brief \c Fetch tag for execution objects. /// -/// \c FetchTagExecObject is a tag used with the \c Fetch class to retreive +/// \c FetchTagExecObject is a tag used with the \c Fetch class to retrieve /// execution objects. For safety, execution objects are read-only. \c /// FetchTagExecObject is almost always used in conjunction with \c /// TransportTagExecObject and vice versa. diff --git a/vtkm/exec/arg/ThreadIndicesPointNeighborhood.h b/vtkm/exec/arg/ThreadIndicesPointNeighborhood.h index ed289776f..97aebcc1a 100644 --- a/vtkm/exec/arg/ThreadIndicesPointNeighborhood.h +++ b/vtkm/exec/arg/ThreadIndicesPointNeighborhood.h @@ -198,21 +198,21 @@ struct BoundaryState namespace detail { -/// Given a \c Vec of (semi) aribtrary size, inflate it to a vtkm::Id3 by padding with zeros. +/// Given a \c Vec of (semi) arbitrary size, inflate it to a vtkm::Id3 by padding with zeros. /// inline VTKM_EXEC vtkm::Id3 To3D(vtkm::Id3 index) { return index; } -/// Given a \c Vec of (semi) aribtrary size, inflate it to a vtkm::Id3 by padding with zeros. +/// Given a \c Vec of (semi) arbitrary size, inflate it to a vtkm::Id3 by padding with zeros. /// \overload inline VTKM_EXEC vtkm::Id3 To3D(vtkm::Id2 index) { return vtkm::Id3(index[0], index[1], 1); } -/// Given a \c Vec of (semi) aribtrary size, inflate it to a vtkm::Id3 by padding with zeros. +/// Given a \c Vec of (semi) arbitrary size, inflate it to a vtkm::Id3 by padding with zeros. /// \overload inline VTKM_EXEC vtkm::Id3 To3D(vtkm::Vec index) { diff --git a/vtkm/exec/arg/ThreadIndicesTopologyMap.h b/vtkm/exec/arg/ThreadIndicesTopologyMap.h index 640837490..7c1eb5ab3 100644 --- a/vtkm/exec/arg/ThreadIndicesTopologyMap.h +++ b/vtkm/exec/arg/ThreadIndicesTopologyMap.h @@ -36,7 +36,7 @@ namespace detail { /// Most cell shape tags have a default constructor, but the generic cell shape -/// tag does not to prevent accidently losing the Id, which, unlike the other +/// tag does not to prevent accidentally losing the Id, which, unlike the other /// cell shapes, can vary. /// template @@ -158,42 +158,42 @@ private: namespace detail { -/// Given a \c Vec of (semi) aribtrary size, inflate it to a vtkm::Id3 by padding with zeros. +/// Given a \c Vec of (semi) arbitrary size, inflate it to a vtkm::Id3 by padding with zeros. /// static inline VTKM_EXEC vtkm::Id3 InflateTo3D(vtkm::Id3 index) { return index; } -/// Given a \c Vec of (semi) aribtrary size, inflate it to a vtkm::Id3 by padding with zeros. +/// Given a \c Vec of (semi) arbitrary size, inflate it to a vtkm::Id3 by padding with zeros. /// \overload static inline VTKM_EXEC vtkm::Id3 InflateTo3D(vtkm::Id2 index) { return vtkm::Id3(index[0], index[1], 0); } -/// Given a \c Vec of (semi) aribtrary size, inflate it to a vtkm::Id3 by padding with zeros. +/// Given a \c Vec of (semi) arbitrary size, inflate it to a vtkm::Id3 by padding with zeros. /// \overload static inline VTKM_EXEC vtkm::Id3 InflateTo3D(vtkm::Vec index) { return vtkm::Id3(index[0], 0, 0); } -/// Given a \c Vec of (semi) aribtrary size, inflate it to a vtkm::Id3 by padding with zeros. +/// Given a \c Vec of (semi) arbitrary size, inflate it to a vtkm::Id3 by padding with zeros. /// \overload static inline VTKM_EXEC vtkm::Id3 InflateTo3D(vtkm::Id index) { return vtkm::Id3(index, 0, 0); } -/// Given a vtkm::Id3, reduce down to an identifer of choice. +/// Given a vtkm::Id3, reduce down to an identifier of choice. /// static inline VTKM_EXEC vtkm::Id3 Deflate(const vtkm::Id3& index, vtkm::Id3) { return index; } -/// Given a vtkm::Id3, reduce down to an identifer of choice. +/// Given a vtkm::Id3, reduce down to an identifier of choice. /// \overload static inline VTKM_EXEC vtkm::Id2 Deflate(const vtkm::Id3& index, vtkm::Id2) { diff --git a/vtkm/exec/testing/UnitTestCellDerivative.cxx b/vtkm/exec/testing/UnitTestCellDerivative.cxx index 04c560458..2728fe43f 100644 --- a/vtkm/exec/testing/UnitTestCellDerivative.cxx +++ b/vtkm/exec/testing/UnitTestCellDerivative.cxx @@ -50,7 +50,7 @@ vtkm::Vec WorldToParametric(const vtkm::Vec& wcoord) return T(0.5) * (wcoord + vtkm::Vec(0.25f)); } -/// Simple structure describing a linear field. Has a convienience class +/// Simple structure describing a linear field. Has a convenience class /// for getting values. template struct LinearField diff --git a/vtkm/filter/testing/UnitTestExternalFacesFilter.cxx b/vtkm/filter/testing/UnitTestExternalFacesFilter.cxx index ae7888572..b3b858b10 100644 --- a/vtkm/filter/testing/UnitTestExternalFacesFilter.cxx +++ b/vtkm/filter/testing/UnitTestExternalFacesFilter.cxx @@ -93,8 +93,8 @@ void TestExternalFacesExplicitGrid(const vtkm::cont::DataSet& ds, VTKM_TEST_ASSERT(numOutputExtFaces == numExpectedExtFaces, "Number of External Faces mismatch"); // verify fields - VTKM_TEST_ASSERT(resultds.HasField("pointvar"), "Point field not mapped succesfully"); - VTKM_TEST_ASSERT(resultds.HasField("cellvar"), "Cell field not mapped succesfully"); + VTKM_TEST_ASSERT(resultds.HasField("pointvar"), "Point field not mapped successfully"); + VTKM_TEST_ASSERT(resultds.HasField("cellvar"), "Cell field not mapped successfully"); // verify CompactPoints if (compactPoints) diff --git a/vtkm/filter/testing/UnitTestGradient.cxx b/vtkm/filter/testing/UnitTestGradient.cxx index 8af46cecf..a48b06daa 100644 --- a/vtkm/filter/testing/UnitTestGradient.cxx +++ b/vtkm/filter/testing/UnitTestGradient.cxx @@ -37,8 +37,8 @@ void TestCellGradientUniform3D() vtkm::filter::Gradient gradient; gradient.SetOutputFieldName("Gradient"); - gradient.SetComputeVorticity(true); //this wont work as we have a scalar field - gradient.SetComputeQCriterion(true); //this wont work as we have a scalar field + gradient.SetComputeVorticity(true); //this won't work as we have a scalar field + gradient.SetComputeQCriterion(true); //this won't work as we have a scalar field result = gradient.Execute(dataSet, dataSet.GetField("pointvar")); diff --git a/vtkm/internal/ArrayPortalValueReference.h b/vtkm/internal/ArrayPortalValueReference.h index 55c73ae52..33842fc00 100644 --- a/vtkm/internal/ArrayPortalValueReference.h +++ b/vtkm/internal/ArrayPortalValueReference.h @@ -32,7 +32,7 @@ namespace internal /// \brief A value class for returning setable values of an ArrayPortal /// /// \c ArrayPortal classes have a pair of \c Get and \c Set methods that -/// retreive and store values in the array. This is to make it easy to +/// retrieve and store values in the array. This is to make it easy to /// implement the \c ArrayPortal even it is not really an array. However, there /// are some cases where the code structure expects a reference to a value that /// can be set. For example, the \c IteratorFromArrayPortal class must return diff --git a/vtkm/internal/Configure.h.in b/vtkm/internal/Configure.h.in index 95b166b63..d02a4df80 100644 --- a/vtkm/internal/Configure.h.in +++ b/vtkm/internal/Configure.h.in @@ -307,7 +307,7 @@ #ifdef VTKM_MSVC //With MSVC the types that we generate cause warning C4503 (long symbol names) -//this doesn't affect the resulting binary so we just supress that warning +//this doesn't affect the resulting binary so we just suppress that warning // #pragma warning(disable:4503) @@ -317,7 +317,7 @@ //a valid use is MSVC-specific. Even less fortunate is the fact that if //another header violates the warning, it is impossible to suppress it //because it happens in a system header file (xutility), which was included -//far before the actual offending code occured. Even less fortunate than +//far before the actual offending code occurred. Even less fortunate than //that, a boost header we (indirectly) use sets off this warning, cannot //be suppressed, and is not going to be fixed //(https://svn.boost.org/trac/boost/ticket/11426). The best solution is to diff --git a/vtkm/internal/FunctionInterface.h b/vtkm/internal/FunctionInterface.h index 828231bb2..f979cef4d 100644 --- a/vtkm/internal/FunctionInterface.h +++ b/vtkm/internal/FunctionInterface.h @@ -102,7 +102,7 @@ class FunctionInterfaceDynamicTransformContContinue; /// series of transformations and operations can occur. /// /// Supporting arbitrary function and template arguments is difficult and -/// really requires seperate implementations for ANSI and C++11 versions of +/// really requires separate implementations for ANSI and C++11 versions of /// compilers. Thus, variatic template arguments are, at this point in time, /// something to be avoided when possible. The intention of \c /// FunctionInterface is to collect most of the variatic template code into one diff --git a/vtkm/internal/testing/UnitTestFunctionInterface.cxx b/vtkm/internal/testing/UnitTestFunctionInterface.cxx index 4dfe9a868..e697d3b05 100644 --- a/vtkm/internal/testing/UnitTestFunctionInterface.cxx +++ b/vtkm/internal/testing/UnitTestFunctionInterface.cxx @@ -500,7 +500,7 @@ void TestInvokeTime() vtkm::Float64 invokeCallTime = timer.GetElapsedTime(); std::cout << "Time for invoking function interface: " << invokeCallTime << " seconds" << std::endl; - std::cout << "Pointless result (makeing sure compiler computes it) " << f.Field << std::endl; + std::cout << "Pointless result (making sure compiler computes it) " << f.Field << std::endl; #if !defined(NDEBUG) && defined(VTKM_MSVC) // We expect function calls through the FunctionInterface class to take diff --git a/vtkm/interop/internal/TransferToOpenGL.h b/vtkm/interop/internal/TransferToOpenGL.h index fa742cc9f..5de07d58e 100644 --- a/vtkm/interop/internal/TransferToOpenGL.h +++ b/vtkm/interop/internal/TransferToOpenGL.h @@ -214,7 +214,7 @@ public: //to openGL this works for all storage types. // //Second option is to call PrepareForInput and get a PortalConst in the - //exection environment. + //execution environment. //if we are StorageTagBasic this would allow us the ability to grab //the raw memory value and copy those, which we know are valid and remove //a unneeded copy. diff --git a/vtkm/interop/testing/UnitTestFancyTransferGLUT.cxx b/vtkm/interop/testing/UnitTestFancyTransferGLUT.cxx index 5c97052f7..0fc7c597e 100644 --- a/vtkm/interop/testing/UnitTestFancyTransferGLUT.cxx +++ b/vtkm/interop/testing/UnitTestFancyTransferGLUT.cxx @@ -40,7 +40,7 @@ // 1. Some Linux distributions default linker implicitly enables the as-needed // linking flag. This means that your shared library or executable will only // link to libraries from which they use symbols. So if you explicitly link to -// pthread but don't use any symbols you wont have a 'DT_NEEDED' entry for +// pthread but don't use any symbols you won't have a 'DT_NEEDED' entry for // pthread. // // 2. NVidia libGL (driver version 352 ) uses pthread but doesn't have diff --git a/vtkm/interop/testing/UnitTestTransferGLUT.cxx b/vtkm/interop/testing/UnitTestTransferGLUT.cxx index f8068b6a6..801d65929 100644 --- a/vtkm/interop/testing/UnitTestTransferGLUT.cxx +++ b/vtkm/interop/testing/UnitTestTransferGLUT.cxx @@ -42,7 +42,7 @@ // 1. Some Linux distributions default linker implicitly enables the as-needed // linking flag. This means that your shared library or executable will only // link to libraries from which they use symbols. So if you explicitly link to -// pthread but don't use any symbols you wont have a 'DT_NEEDED' entry for +// pthread but don't use any symbols you won't have a 'DT_NEEDED' entry for // pthread. // // 2. NVidia libGL (driver version 352 ) uses pthread but doesn't have diff --git a/vtkm/io/reader/BOVDataSetReader.h b/vtkm/io/reader/BOVDataSetReader.h index 370513a4d..4ec70566a 100644 --- a/vtkm/io/reader/BOVDataSetReader.h +++ b/vtkm/io/reader/BOVDataSetReader.h @@ -98,7 +98,7 @@ private: std::stringstream strStream(options); - //Format supports both space and "_" seperated tokens... + //Format supports both space and "_" separated tokens... if (token.find("DATA") != std::string::npos && token.find("FILE") != std::string::npos) { strStream >> bovFile >> std::ws; diff --git a/vtkm/rendering/CMakeLists.txt b/vtkm/rendering/CMakeLists.txt index 6ae868734..23c847678 100644 --- a/vtkm/rendering/CMakeLists.txt +++ b/vtkm/rendering/CMakeLists.txt @@ -172,7 +172,7 @@ vtkm_library( WRAP_FOR_CUDA ${device_sources} ) -# EGL Libs are added here to ensure propper linking when statically compiling. +# EGL Libs are added here to ensure proper linking when statically compiling. # This is safe to do even when not using EGL as the values will then be empty. target_link_libraries(vtkm_rendering PUBLIC vtkm_cont @@ -181,7 +181,7 @@ target_link_libraries(vtkm_rendering ${EGL_LIBRARIES} ) -# EGL Dirs are added here to ensure propper linking when statically compiling. +# EGL Dirs are added here to ensure proper linking when statically compiling. # This is safe to do even when not using EGL as the values will then be empty. target_include_directories(vtkm_rendering PRIVATE ${VTKm_OPENGL_INCLUDE_DIRS} diff --git a/vtkm/rendering/Camera.h b/vtkm/rendering/Camera.h index c6dd27c3e..aea6b524d 100644 --- a/vtkm/rendering/Camera.h +++ b/vtkm/rendering/Camera.h @@ -438,7 +438,7 @@ public: /// \brief Rotate the camera about the view up vector centered at the focal point. /// /// Note that the view up vector is whatever was set via SetViewUp, and is - /// not necesarily perpendicular to the direction of projection. The angle is + /// not necessarily perpendicular to the direction of projection. The angle is /// given in degrees. /// /// Azimuth only makes sense for 3D cameras, so the camera mode will be set diff --git a/vtkm/rendering/CanvasRayTracer.cxx b/vtkm/rendering/CanvasRayTracer.cxx index 3c8f49428..bd9c62015 100644 --- a/vtkm/rendering/CanvasRayTracer.cxx +++ b/vtkm/rendering/CanvasRayTracer.cxx @@ -102,7 +102,7 @@ public: { color[i] = vtkm::Min(1.f, vtkm::Max(color[i], 0.f)); } - // The existng depth should already been feed into thge ray mapper + // The existing depth should already been feed into the ray mapper // so no color contribution will exist past the existing depth. depthBuffer.Set(pixelIndex, depth); diff --git a/vtkm/rendering/ColorTable.h b/vtkm/rendering/ColorTable.h index 1796892b0..d8ba4433a 100644 --- a/vtkm/rendering/ColorTable.h +++ b/vtkm/rendering/ColorTable.h @@ -41,7 +41,7 @@ struct ColorTableInternals; /// /// This class provides the basic representation of a color table. This class was /// Ported from EAVL. Originally created by Jeremy Meredith, Dave Pugmire, -/// and Sean Ahern. This class uses seperate RGB and alpha control points and can +/// and Sean Ahern. This class uses separate RGB and alpha control points and can /// be used as a transfer function. /// class VTKM_RENDERING_EXPORT ColorTable diff --git a/vtkm/rendering/DecodePNG.cxx b/vtkm/rendering/DecodePNG.cxx index 249270844..52121c82a 100644 --- a/vtkm/rendering/DecodePNG.cxx +++ b/vtkm/rendering/DecodePNG.cxx @@ -59,13 +59,13 @@ in_size: size of the input PNG file in bytes. convert_to_rgba32: optional parameter, true by default. Set to true to get the output in RGBA 32-bit (8 bit per channel) color format no matter what color type the original PNG image had. This gives predictable, - useable data from any random input PNG. + usable data from any random input PNG. Set to false to do no color conversion at all. The result then has the same data type as the PNG image, which can range from 1 bit to 64 bits per pixel. Information about the color type or palette colors are not provided. You need to know this information yourself to be able to use the data so this only works for trusted PNG files. Use LodePNG instead of picoPNG if you need this information. -return: 0 if success, not 0 if some error occured. +return: 0 if success, not 0 if some error occurred. */ int DecodePNG(std::vector& out_image, unsigned long& image_width, diff --git a/vtkm/rendering/Triangulator.h b/vtkm/rendering/Triangulator.h index cb3fa7376..4225172fd 100644 --- a/vtkm/rendering/Triangulator.h +++ b/vtkm/rendering/Triangulator.h @@ -293,7 +293,7 @@ public: { if (index == 0) return; - //if we are a shared face, mark ourself and neighbor for desctruction + //if we are a shared face, mark ourself and neighbor for destruction if (IsTwin(indices.Get(index), indices.Get(index - 1))) { outputFlags.Set(index, 0); diff --git a/vtkm/rendering/raytracing/ChannelBuffer.h b/vtkm/rendering/raytracing/ChannelBuffer.h index 942f059d7..e8d13ea3b 100644 --- a/vtkm/rendering/raytracing/ChannelBuffer.h +++ b/vtkm/rendering/raytracing/ChannelBuffer.h @@ -40,8 +40,8 @@ namespace raytracing /// \c The ChannelBuffer class is meant to handle a buffer of values with potentially many /// channels. While RGBA values could be placed in a Vec, data with a large number of /// channels (e.g., 100+ energy bins) are better handled by a raw array. Rays can have color, -/// absorption, absorption + emmision, or even track additional scalar values to support -/// standards such as Cinema. This class allows us to treat all of these differnt use cases +/// absorption, absorption + emission, or even track additional scalar values to support +/// standards such as Cinema. This class allows us to treat all of these different use cases /// with the same type. /// /// This class has methods that can be utilized by other VTK-m classes that already have a diff --git a/vtkm/rendering/raytracing/ConnectivityTracer.h b/vtkm/rendering/raytracing/ConnectivityTracer.h index 32701cc73..bdcb32785 100644 --- a/vtkm/rendering/raytracing/ConnectivityTracer.h +++ b/vtkm/rendering/raytracing/ConnectivityTracer.h @@ -48,7 +48,7 @@ struct RenderFunctor; // // Ray tracker manages memory and pointer -// swaping for current cell intersection data +// swapping for current cell intersection data // template class RayTracking diff --git a/vtkm/rendering/raytracing/ConnectivityTracer.hxx b/vtkm/rendering/raytracing/ConnectivityTracer.hxx index 61980cc28..50bccd52e 100644 --- a/vtkm/rendering/raytracing/ConnectivityTracer.hxx +++ b/vtkm/rendering/raytracing/ConnectivityTracer.hxx @@ -559,7 +559,7 @@ public: // // Traditionally, we would only keep track of a single intensity value per ray - // per bin and we would integrate from the begining to end of the ray. In a + // per bin and we would integrate from the beginning to end of the ray. In a // distributed memory setting, we would move cell data around so that the // entire ray could be traced, but in situ, moving that much cell data around // could blow memory. Here we are keeping track of two values. Total absorption @@ -1181,7 +1181,7 @@ void ConnectivityTracer::RenderOnDevice(Ray entryTimer; // - // if ray misses the exteral face it will be marked RAY_EXITED_MESH + // if ray misses the external face it will be marked RAY_EXITED_MESH // MeshConn.FindEntry(rays, Device()); MeshEntryTime += entryTimer.GetElapsedTime(); @@ -1238,7 +1238,7 @@ void ConnectivityTracer::RenderOnDevice(Ray inverseExtent; inverseExtent[0] = 1.f / (BoundingBox[1] - BoundingBox[0]); inverseExtent[1] = 1.f / (BoundingBox[3] - BoundingBox[2]); diff --git a/vtkm/rendering/raytracing/MeshConnectivityStructures.h b/vtkm/rendering/raytracing/MeshConnectivityStructures.h index 45c3d7cba..23341bd80 100644 --- a/vtkm/rendering/raytracing/MeshConnectivityStructures.h +++ b/vtkm/rendering/raytracing/MeshConnectivityStructures.h @@ -65,7 +65,7 @@ public: IdHandle CellConn; IdHandle CellOffsets; UCharHandle Shapes; - // Mesh Boundry + // Mesh Boundary Id4Handle ExternalTriangles; LinearBVH Bvh; @@ -304,7 +304,7 @@ public: IdHandle FaceConnectivity; CountingHandle CellOffsets; IdHandle CellConnectivity; - // Mesh Boundry + // Mesh Boundary LinearBVH Bvh; Id4Handle ExternalTriangles; @@ -547,7 +547,7 @@ public: vtkm::Bounds CoordinateBounds; vtkm::cont::CoordinateSystem Coords; vtkm::cont::CellSetStructured<3> Cellset; - // Mesh Boundry + // Mesh Boundary LinearBVH Bvh; Id4Handle ExternalTriangles; diff --git a/vtkm/rendering/raytracing/MortonCodes.h b/vtkm/rendering/raytracing/MortonCodes.h index 66b26d530..9fd93fd48 100644 --- a/vtkm/rendering/raytracing/MortonCodes.h +++ b/vtkm/rendering/raytracing/MortonCodes.h @@ -207,7 +207,7 @@ public: vtkm::Vec cellFace; cellFace[0] = cellId; - // We must be sure that this calulation is the same for all faces. If we didn't + // We must be sure that this calculation is the same for all faces. If we didn't // then it is possible for the same face to end up in multiple morton "buckets" due to // the wonders of floating point math. This is bad. If we calculate in the same order // for all faces, then at worst, two different faces can enter the same bucket, which diff --git a/vtkm/rendering/raytracing/RayOperations.h b/vtkm/rendering/raytracing/RayOperations.h index 05984a20b..bca874d50 100644 --- a/vtkm/rendering/raytracing/RayOperations.h +++ b/vtkm/rendering/raytracing/RayOperations.h @@ -210,7 +210,7 @@ public: .Invoke(rays.Status, masks); // - // Make empty composite vectors so we dont use up extra storage + // Make empty composite vectors so we don't use up extra storage // vtkm::IdComponent inComp[3]; inComp[0] = 0; diff --git a/vtkm/rendering/raytracing/VolumeRendererStructured.cxx b/vtkm/rendering/raytracing/VolumeRendererStructured.cxx index e02bac968..fd17499f7 100644 --- a/vtkm/rendering/raytracing/VolumeRendererStructured.cxx +++ b/vtkm/rendering/raytracing/VolumeRendererStructured.cxx @@ -134,7 +134,7 @@ public: { // // When searching for points, we consider the max value of the cell - // to be apart of the next cell. If the point falls on the boundry of the + // to be apart of the next cell. If the point falls on the boundary of the // data set, then it is technically inside a cell. This checks for that case // if (point[dim] == MaxPoint[dim]) diff --git a/vtkm/testing/OptionParser.h b/vtkm/testing/OptionParser.h index 6e4c66ecb..638c60c35 100644 --- a/vtkm/testing/OptionParser.h +++ b/vtkm/testing/OptionParser.h @@ -1466,7 +1466,7 @@ struct Parser::Action * options if they have a Descriptor whose Descriptor::check_arg does not return * @ref ARG_ILLEGAL. * - * Returns @c false iff a fatal error has occured and the parse should be aborted. + * Returns @c false iff a fatal error has occurred and the parse should be aborted. */ virtual bool perform(Option&) { return true; } diff --git a/vtkm/testing/Testing.h b/vtkm/testing/Testing.h index 0bd0835d9..8b6fce7e7 100644 --- a/vtkm/testing/Testing.h +++ b/vtkm/testing/Testing.h @@ -398,7 +398,7 @@ static inline VTKM_EXEC_CONT bool test_equal_impl(ScalarType1 scalar1, vtkm::TypeTraitsScalarTag>::type::value), "Trying to compare a scalar with a vector."); - // Do all comparisions using 64-bit floats. + // Do all comparisons using 64-bit floats. vtkm::Float64 value1 = vtkm::Float64(scalar1); vtkm::Float64 value2 = vtkm::Float64(scalar2); diff --git a/vtkm/testing/UnitTestMatrix.cxx b/vtkm/testing/UnitTestMatrix.cxx index 851f16012..0bdd0cd8b 100644 --- a/vtkm/testing/UnitTestMatrix.cxx +++ b/vtkm/testing/UnitTestMatrix.cxx @@ -74,18 +74,18 @@ struct MatrixTest FOR_ROW_COL(matrix) { matrix[row][col] = ComponentType(value(row, col) * 2); } FOR_ROW_COL(matrix) { - VTKM_TEST_ASSERT(test_equal(matrix(row, col), value(row, col) * 2), "Bad set or retreive."); + VTKM_TEST_ASSERT(test_equal(matrix(row, col), value(row, col) * 2), "Bad set or retrieve."); const MatrixType const_matrix = matrix; VTKM_TEST_ASSERT(test_equal(const_matrix(row, col), value(row, col) * 2), - "Bad set or retreive."); + "Bad set or retrieve."); } FOR_ROW_COL(matrix) { matrix(row, col) = value(row, col); } const MatrixType const_matrix = matrix; FOR_ROW_COL(matrix) { - VTKM_TEST_ASSERT(test_equal(matrix[row][col], value(row, col)), "Bad set or retreive."); - VTKM_TEST_ASSERT(test_equal(const_matrix[row][col], value(row, col)), "Bad set or retreive."); + VTKM_TEST_ASSERT(test_equal(matrix[row][col], value(row, col)), "Bad set or retrieve."); + VTKM_TEST_ASSERT(test_equal(const_matrix[row][col], value(row, col)), "Bad set or retrieve."); } VTKM_TEST_ASSERT(matrix == const_matrix, "Equal test operator not working."); VTKM_TEST_ASSERT(!(matrix != const_matrix), "Not-Equal test operator not working."); diff --git a/vtkm/testing/UnitTestTransform3D.cxx b/vtkm/testing/UnitTestTransform3D.cxx index 73c7f14ba..dd5daf462 100644 --- a/vtkm/testing/UnitTestTransform3D.cxx +++ b/vtkm/testing/UnitTestTransform3D.cxx @@ -73,7 +73,7 @@ struct TransformTests VTKM_TEST_ASSERT(test_equal(translated2, startPoint + T(2) * translateAmount), "Bad translation."); - // Vectors should be invarient to translation. + // Vectors should be invariant to translation. translated1 = vtkm::Transform3DVector(translate, startPoint); std::cout << " Translated vector: " << translated1 << std::endl; VTKM_TEST_ASSERT(test_equal(translated1, startPoint), "Bad translation."); diff --git a/vtkm/thirdparty/diy/vtkmdiy/include/vtkmdiy/io/block.hpp b/vtkm/thirdparty/diy/vtkmdiy/include/vtkmdiy/io/block.hpp index 05e45a800..8d530ba96 100644 --- a/vtkm/thirdparty/diy/vtkmdiy/include/vtkmdiy/io/block.hpp +++ b/vtkm/thirdparty/diy/vtkmdiy/include/vtkmdiy/io/block.hpp @@ -41,7 +41,7 @@ namespace io } } -// Serialize GidOffsetCount explicitly, to avoid alignment and unitialized data issues +// Serialize GidOffsetCount explicitly, to avoid alignment and uninitialized data issues // (to get identical output files given the same block input) template<> struct Serialization diff --git a/vtkm/thirdparty/diy/vtkmdiy/include/vtkmdiy/mpi/communicator.hpp b/vtkm/thirdparty/diy/vtkmdiy/include/vtkmdiy/mpi/communicator.hpp index c29b6d033..42b5264af 100644 --- a/vtkm/thirdparty/diy/vtkmdiy/include/vtkmdiy/mpi/communicator.hpp +++ b/vtkm/thirdparty/diy/vtkmdiy/include/vtkmdiy/mpi/communicator.hpp @@ -33,7 +33,7 @@ namespace mpi request isend(int dest, int tag, const T& x) const { return detail::isend()(comm_, dest, tag, x); } //! Non-blocking version of `recv()`. - //! If `T` is an `std::vector<...>`, its size must be big enough to accomodate the sent values. + //! If `T` is an `std::vector<...>`, its size must be big enough to accommodate the sent values. template request irecv(int source, int tag, T& x) const { return detail::irecv()(comm_, source, tag, x); } diff --git a/vtkm/worklet/Clip.h b/vtkm/worklet/Clip.h index 025abcf7b..a0e37b4d1 100644 --- a/vtkm/worklet/Clip.h +++ b/vtkm/worklet/Clip.h @@ -317,7 +317,7 @@ public: { connectivityExplicit.SetConnectivity(connectivityIdx++, indices[entry - 100]); } - else // edge, new point to be generated by cutting the egde + else // edge, new point to be generated by cutting the edge { internal::ClipTables::EdgeVec edge = this->ClipTables.GetEdge(shape.Id, entry); // Sanity check to make sure the edge is valid. diff --git a/vtkm/worklet/MarchingCubes.h b/vtkm/worklet/MarchingCubes.h index a41411a84..dcaa0d88e 100644 --- a/vtkm/worklet/MarchingCubes.h +++ b/vtkm/worklet/MarchingCubes.h @@ -309,7 +309,7 @@ public: const FieldType ivalue = isovalues[i]; // Compute the Marching Cubes case number for this cell. We need to iterate // the isovalues until the sum >= our visit index. But we need to make - // sure the caseNumber is correct before stoping + // sure the caseNumber is correct before stopping caseNumber = ((fieldIn[0] > ivalue) | (fieldIn[1] > ivalue) << 1 | (fieldIn[2] > ivalue) << 2 | (fieldIn[3] > ivalue) << 3 | (fieldIn[4] > ivalue) << 4 | (fieldIn[5] > ivalue) << 5 | diff --git a/vtkm/worklet/NDimsHistMarginalization.h b/vtkm/worklet/NDimsHistMarginalization.h index 7b431c2d0..068e1a6d6 100644 --- a/vtkm/worklet/NDimsHistMarginalization.h +++ b/vtkm/worklet/NDimsHistMarginalization.h @@ -172,7 +172,7 @@ public: vtkm::cont::ArrayHandle freqs; DeviceAlgorithms::Copy(freqsIn, freqs); - vtkm::Id numMarginalVariables = 0; //count num of marginal varaibles + vtkm::Id numMarginalVariables = 0; //count num of marginal variables for (vtkm::Id i = 0; i < numOfVariable; i++) { if (marginalVariables.GetPortalConstControl().Get(i) == true) diff --git a/vtkm/worklet/RemoveUnusedPoints.h b/vtkm/worklet/RemoveUnusedPoints.h index 4a1918fa7..17cbbac76 100644 --- a/vtkm/worklet/RemoveUnusedPoints.h +++ b/vtkm/worklet/RemoveUnusedPoints.h @@ -202,7 +202,7 @@ public: /// \brief Maps a point field from the original points to the new reduced points /// /// Given an array handle that holds the values for a point field of the - /// orignal data set, returns a new array handle containing field values + /// original data set, returns a new array handle containing field values /// rearranged to the new indices of the reduced point set. /// /// This version of point mapping performs a shallow copy by using a @@ -221,7 +221,7 @@ public: /// \brief Maps a point field from the original points to the new reduced points /// /// Given an array handle that holds the values for a point field of the - /// orignal data set, returns a new array handle containing field values + /// original data set, returns a new array handle containing field values /// rearranged to the new indices of the reduced point set. /// /// This version of point mapping performs a deep copy into the destination @@ -244,7 +244,7 @@ public: /// \brief Maps a point field from the original points to the new reduced points /// /// Given an array handle that holds the values for a point field of the - /// orignal data set, returns a new array handle containing field values + /// original data set, returns a new array handle containing field values /// rearranged to the new indices of the reduced point set. /// /// This version of point mapping performs a deep copy into an array that is diff --git a/vtkm/worklet/internal/DispatcherBase.h b/vtkm/worklet/internal/DispatcherBase.h index 7f5d239c4..8d50d3eac 100644 --- a/vtkm/worklet/internal/DispatcherBase.h +++ b/vtkm/worklet/internal/DispatcherBase.h @@ -124,7 +124,7 @@ struct DetermineHasCorrectParameters // control signature as ControlSignature(CellSetIn, ...) and the first argument passed // to Invoke is an ArrayHandle, you will get an error here because you cannot use an // ArrayHandle in place of a CellSetIn argument. (You need to use a CellSet.) See a few - // lines later for some diagnostics to help you trace where the error occured. + // lines later for some diagnostics to help you trace where the error occurred. VTKM_READ_THE_SOURCE_CODE_FOR_HELP(isCorrect); // If you are getting the error described above, the following lines will give you some diff --git a/vtkm/worklet/splatkernels/Gaussian.h b/vtkm/worklet/splatkernels/Gaussian.h index e9639175c..03cd92f8e 100644 --- a/vtkm/worklet/splatkernels/Gaussian.h +++ b/vtkm/worklet/splatkernels/Gaussian.h @@ -24,7 +24,7 @@ // // Gaussian kernel. -// Compact support is achived by truncating the kernel beyond the cutoff radius +// Compact support is achieved by truncating the kernel beyond the cutoff radius // This implementation uses a factor of 5 between smoothing length and cutoff // diff --git a/vtkm/worklet/testing/UnitTestCrossProduct.cxx b/vtkm/worklet/testing/UnitTestCrossProduct.cxx index 694d1b7e0..6d10d275a 100644 --- a/vtkm/worklet/testing/UnitTestCrossProduct.cxx +++ b/vtkm/worklet/testing/UnitTestCrossProduct.cxx @@ -88,7 +88,7 @@ void TestCrossProduct() VTKM_TEST_ASSERT(outputArray.GetNumberOfValues() == inputArray1.GetNumberOfValues(), "Wrong number of results for CrossProduct worklet"); - //Test the cannonical cases. + //Test the canonical cases. VTKM_TEST_ASSERT( test_equal(outputArray.GetPortalConstControl().Get(0), vtkm::make_Vec(0, 0, 1)) && test_equal(outputArray.GetPortalConstControl().Get(1), vtkm::make_Vec(1, 0, 0)) && diff --git a/vtkm/worklet/testing/UnitTestNDimsHistMarginalization.cxx b/vtkm/worklet/testing/UnitTestNDimsHistMarginalization.cxx index 3417a4425..a1c45e844 100644 --- a/vtkm/worklet/testing/UnitTestNDimsHistMarginalization.cxx +++ b/vtkm/worklet/testing/UnitTestNDimsHistMarginalization.cxx @@ -192,7 +192,7 @@ vtkm::cont::DataSet MakeTestDataSet() // marginal histogram // In this example, we have three variable var0, var1, var2 // the condition is P(Var0, Var2 | 1