Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-08 13:23:51 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

remove fake functors

Browse Source
This commit is contained in:
Matt Larsen 2020-03-15 14:56:02 -07:00
commit 23075d5ff5
33 changed files with 1436 additions and 956 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
vtkm/CMakeLists.txt
View File

@ -27,6 +27,7 @@ set(headers
CellShape.h
CellTraits.h
Deprecated.h
ErrorCode.h
Flags.h
Geometry.h
Hash.h

10
vtkm/CellShape.h
View File

@ -164,7 +164,7 @@ namespace internal
{
template <typename VtkmCellShapeTag>
VTKM_EXEC_CONT inline typename CellShapeTagVtkmToVtkc<VtkmCellShapeTag>::Type make_VtkcCellShapeTag(
VTKM_EXEC_CONT inline typename CellShapeTagVtkmToVtkc<VtkmCellShapeTag>::Type make_LclCellShapeTag(
const VtkmCellShapeTag&,
vtkm::IdComponent numPoints = 0)
{
@ -174,15 +174,15 @@ VTKM_EXEC_CONT inline typename CellShapeTagVtkmToVtkc<VtkmCellShapeTag>::Type ma
}
VTKM_EXEC_CONT
inline lcl::Polygon make_VtkcCellShapeTag(const vtkm::CellShapeTagPolygon&,
vtkm::IdComponent numPoints = 0)
inline lcl::Polygon make_LclCellShapeTag(const vtkm::CellShapeTagPolygon&,
vtkm::IdComponent numPoints = 0)
{
return lcl::Polygon(numPoints);
}
VTKM_EXEC_CONT
inline lcl::Cell make_VtkcCellShapeTag(const vtkm::CellShapeTagGeneric& tag,
vtkm::IdComponent numPoints = 0)
inline lcl::Cell make_LclCellShapeTag(const vtkm::CellShapeTagGeneric& tag,
vtkm::IdComponent numPoints = 0)
{
return lcl::Cell(static_cast<std::int8_t>(tag.Id), numPoints);
}

118
vtkm/ErrorCode.h Normal file
View File

@ -0,0 +1,118 @@
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_exec_ErrorCode_h
#define vtk_m_exec_ErrorCode_h
#include <lcl/ErrorCode.h>
#include <vtkm/internal/ExportMacros.h>
namespace vtkm
{
enum class ErrorCode
{
Success,
InvalidShapeId,
InvalidNumberOfPoints,
WrongShapeIdForTagType,
InvalidPointId,
InvalidEdgeId,
InvalidFaceId,
SolutionDidNotConverge,
MatrixFactorizationFailed,
DegenerateCellDetected,
MalformedCellDetected,
OperationOnEmptyCell,
CellNotFound,
UnknownError
};
VTKM_EXEC_CONT
inline const char* ErrorString(vtkm::ErrorCode code) noexcept
{
switch (code)
{
case vtkm::ErrorCode::Success:
return "Success";
case vtkm::ErrorCode::InvalidShapeId:
return "Invalid shape id";
case vtkm::ErrorCode::InvalidNumberOfPoints:
return "Invalid number of points";
case vtkm::ErrorCode::WrongShapeIdForTagType:
return "Wrong shape id for tag type";
case vtkm::ErrorCode::InvalidPointId:
return "Invalid point id";
case vtkm::ErrorCode::InvalidEdgeId:
return "Invalid edge id";
case vtkm::ErrorCode::InvalidFaceId:
return "Invalid face id";
case vtkm::ErrorCode::SolutionDidNotConverge:
return "Solution did not converge";
case vtkm::ErrorCode::MatrixFactorizationFailed:
return "Matrix factorization failed";
case vtkm::ErrorCode::DegenerateCellDetected:
return "Degenerate cell detected";
case vtkm::ErrorCode::MalformedCellDetected:
return "Malformed cell detected";
case vtkm::ErrorCode::OperationOnEmptyCell:
return "Operation on empty cell";
case vtkm::ErrorCode::CellNotFound:
return "Cell not found";
case vtkm::ErrorCode::UnknownError:
return "Unknown error";
}
return "Invalid error";
}
namespace internal
{
VTKM_EXEC_CONT inline vtkm::ErrorCode LclErrorToVtkmError(lcl::ErrorCode code) noexcept
{
switch (code)
{
case lcl::ErrorCode::SUCCESS:
return vtkm::ErrorCode::Success;
case lcl::ErrorCode::INVALID_SHAPE_ID:
return vtkm::ErrorCode::InvalidShapeId;
case lcl::ErrorCode::INVALID_NUMBER_OF_POINTS:
return vtkm::ErrorCode::InvalidNumberOfPoints;
case lcl::ErrorCode::WRONG_SHAPE_ID_FOR_TAG_TYPE:
return vtkm::ErrorCode::WrongShapeIdForTagType;
case lcl::ErrorCode::INVALID_POINT_ID:
return vtkm::ErrorCode::InvalidPointId;
case lcl::ErrorCode::SOLUTION_DID_NOT_CONVERGE:
return vtkm::ErrorCode::SolutionDidNotConverge;
case lcl::ErrorCode::MATRIX_LUP_FACTORIZATION_FAILED:
return vtkm::ErrorCode::MatrixFactorizationFailed;
case lcl::ErrorCode::DEGENERATE_CELL_DETECTED:
return vtkm::ErrorCode::DegenerateCellDetected;
}
return vtkm::ErrorCode::UnknownError;
}
} // namespace internal
} // namespace vtkm
#define VTKM_RETURN_ON_ERROR(call) \
do \
{ \
auto status = (call); \
if (status != ::vtkm::ErrorCode::Success) \
{ \
return status; \
} \
} while (false)
#endif //vtk_m_exec_ErrorCode_h

42
vtkm/cont/CellLocatorUniformBins.h
View File

@ -108,22 +108,26 @@ private:
// tests are done on the projection of the point on the cell. Extra checks
// should be added to test if the point actually falls on the cell.
template <typename CellShapeTag, typename CoordsType>
VTKM_EXEC static bool PointInsideCell(FloatVec3 point,
CellShapeTag cellShape,
CoordsType cellPoints,
const vtkm::exec::FunctorBase& worklet,
FloatVec3& parametricCoordinates)
VTKM_EXEC static vtkm::ErrorCode PointInsideCell(FloatVec3 point,
CellShapeTag cellShape,
CoordsType cellPoints,
FloatVec3& parametricCoordinates,
bool& inside)
{
auto bounds = vtkm::internal::cl_uniform_bins::ComputeCellBounds(cellPoints);
if (point[0] >= bounds.Min[0] && point[0] <= bounds.Max[0] && point[1] >= bounds.Min[1] &&
point[1] <= bounds.Max[1] && point[2] >= bounds.Min[2] && point[2] <= bounds.Max[2])
{
bool success = false;
parametricCoordinates = vtkm::exec::WorldCoordinatesToParametricCoordinates(
cellPoints, point, cellShape, success, worklet);
return success && vtkm::exec::CellInside(parametricCoordinates, cellShape);
VTKM_RETURN_ON_ERROR(vtkm::exec::WorldCoordinatesToParametricCoordinates(
cellPoints, point, cellShape, parametricCoordinates));
inside = vtkm::exec::CellInside(parametricCoordinates, cellShape);
}
return false;
else
{
inside = false;
}
// Return success error code even point is not inside this cell
return vtkm::ErrorCode::Success;
}
public:
@ -157,10 +161,9 @@ public:
}
VTKM_EXEC
void FindCell(const FloatVec3& point,
vtkm::Id& cellId,
FloatVec3& parametric,
const vtkm::exec::FunctorBase& worklet) const override
vtkm::ErrorCode FindCell(const FloatVec3& point,
vtkm::Id& cellId,
FloatVec3& parametric) const override
{
using namespace vtkm::internal::cl_uniform_bins;
@ -176,7 +179,7 @@ public:
auto ldim = this->LeafDimensions.Get(binId);
if (!ldim[0] || !ldim[1] || !ldim[2])
{
return;
return vtkm::ErrorCode::CellNotFound;
}
auto leafGrid = ComputeLeafGrid(binId3, ldim, this->TopLevel);
@ -196,14 +199,19 @@ public:
auto indices = this->CellSet.GetIndices(cid);
auto pts = vtkm::make_VecFromPortalPermute(&indices, this->Coords);
FloatVec3 pc;
if (PointInsideCell(point, this->CellSet.GetCellShape(cid), pts, worklet, pc))
bool inside;
VTKM_RETURN_ON_ERROR(
PointInsideCell(point, this->CellSet.GetCellShape(cid), pts, pc, inside));
if (inside)
{
cellId = cid;
parametric = pc;
break;
return vtkm::ErrorCode::Success;
}
}
}
return vtkm::ErrorCode::CellNotFound;
}
private:

8
vtkm/cont/testing/TestingCellLocatorRectilinearGrid.h
View File

@ -104,7 +104,13 @@ public:
bool& match) const
{
vtkm::Id calculated = CalculateCellId(pointIn);
locator->FindCell(pointIn, cellId, parametric, (*this));
vtkm::ErrorCode status = locator->FindCell(pointIn, cellId, parametric);
if (status != vtkm::ErrorCode::Success)
{
this->RaiseError(vtkm::ErrorString(status));
match = false;
return;
}
match = (calculated == cellId);
}

12
vtkm/cont/testing/TestingCellLocatorUniformBins.h
View File

@ -60,7 +60,11 @@ public:
const PointType& pc,
PointType& wc) const
{
wc = vtkm::exec::ParametricCoordinatesToWorldCoordinates(points, pc, cellShape, *this);
auto status = vtkm::exec::ParametricCoordinatesToWorldCoordinates(points, pc, cellShape, wc);
if (status != vtkm::ErrorCode::Success)
{
this->RaiseError(vtkm::ErrorString(status));
}
}
};
@ -166,7 +170,11 @@ public:
vtkm::Id& cellId,
vtkm::Vec3f& pcoords) const
{
locator->FindCell(point, cellId, pcoords, *this);
vtkm::ErrorCode status = locator->FindCell(point, cellId, pcoords);
if (status != vtkm::ErrorCode::Success)
{
this->RaiseError(vtkm::ErrorString(status));
}
}
};

8
vtkm/cont/testing/TestingCellLocatorUniformGrid.h
View File

@ -69,7 +69,13 @@ public:
bool& match) const
{
vtkm::Id calculated = CalculateCellId(pointIn);
locator->FindCell(pointIn, cellId, parametric, (*this));
vtkm::ErrorCode status = locator->FindCell(pointIn, cellId, parametric);
if ((status != vtkm::ErrorCode::Success) && (status != vtkm::ErrorCode::CellNotFound))
{
this->RaiseError(vtkm::ErrorString(status));
match = false;
return;
}
match = (calculated == cellId);
}

12
vtkm/cont/testing/UnitTestCellLocatorGeneral.cxx
View File

@ -105,7 +105,11 @@ public:
const PointType& pc,
PointType& wc) const
{
wc = vtkm::exec::CellInterpolate(points, pc, cellShape, *this);
auto status = vtkm::exec::CellInterpolate(points, pc, cellShape, wc);
if (status != vtkm::ErrorCode::Success)
{
this->RaiseError(vtkm::ErrorString(status));
}
}
};
@ -155,7 +159,11 @@ public:
vtkm::Id& cellId,
vtkm::Vec3f& pcoords) const
{
locator->FindCell(point, cellId, pcoords, *this);
vtkm::ErrorCode status = locator->FindCell(point, cellId, pcoords);
if (status != vtkm::ErrorCode::Success)
{
this->RaiseError(vtkm::ErrorString(status));
}
}
};

209
vtkm/exec/CellDerivative.h
View File

@ -12,6 +12,8 @@
#include <vtkm/Assert.h>
#include <vtkm/CellShape.h>
#include <vtkm/Deprecated.h>
#include <vtkm/ErrorCode.h>
#include <vtkm/VecAxisAlignedPointCoordinates.h>
#include <vtkm/VecTraits.h>
@ -25,71 +27,39 @@ namespace vtkm
namespace exec
{
//-----------------------------------------------------------------------------
/// \brief Take the derivative (get the gradient) of a point field in a cell.
///
/// Given the point field values for each node and the parametric coordinates
/// of a point within the cell, finds the derivative with respect to each
/// coordinate (i.e. the gradient) at that point. The derivative is not always
/// constant in some "linear" cells.
///
template <typename FieldVecType, typename WorldCoordType, typename ParametricCoordType>
VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivative(
const FieldVecType& pointFieldValues,
const WorldCoordType& worldCoordinateValues,
const vtkm::Vec<ParametricCoordType, 3>& parametricCoords,
vtkm::CellShapeTagGeneric shape,
const vtkm::exec::FunctorBase& worklet)
{
vtkm::Vec<typename FieldVecType::ComponentType, 3> result;
switch (shape.Id)
{
vtkmGenericCellShapeMacro(
result = CellDerivative(
pointFieldValues, worldCoordinateValues, parametricCoords, CellShapeTag(), worklet));
default:
worklet.RaiseError("Unknown cell shape sent to derivative.");
return vtkm::Vec<typename FieldVecType::ComponentType, 3>();
}
return result;
}
//-----------------------------------------------------------------------------
namespace internal
{
template <typename VtkcCellShapeTag,
template <typename LclCellShapeTag,
typename FieldVecType,
typename WorldCoordType,
typename ParametricCoordType>
VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivativeImpl(
VtkcCellShapeTag tag,
VTKM_EXEC vtkm::ErrorCode CellDerivativeImpl(
LclCellShapeTag tag,
const FieldVecType& field,
const WorldCoordType& wCoords,
const ParametricCoordType& pcoords,
const vtkm::exec::FunctorBase& worklet)
vtkm::Vec<typename FieldVecType::ComponentType, 3>& result)
{
VTKM_ASSERT(field.GetNumberOfComponents() == tag.numberOfPoints());
VTKM_ASSERT(wCoords.GetNumberOfComponents() == tag.numberOfPoints());
result = { 0 };
if ((field.GetNumberOfComponents() != tag.numberOfPoints()) ||
(wCoords.GetNumberOfComponents() != tag.numberOfPoints()))
{
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
using FieldType = typename FieldVecType::ComponentType;
auto fieldNumComponents = vtkm::VecTraits<FieldType>::GetNumberOfComponents(field[0]);
vtkm::Vec<FieldType, 3> derivs;
auto status = lcl::derivative(tag,
lcl::makeFieldAccessorNestedSOA(wCoords, 3),
lcl::makeFieldAccessorNestedSOA(field, fieldNumComponents),
pcoords,
derivs[0],
derivs[1],
derivs[2]);
if (status != lcl::ErrorCode::SUCCESS)
{
worklet.RaiseError(lcl::errorString(status));
derivs = vtkm::TypeTraits<vtkm::Vec<FieldType, 3>>::ZeroInitialization();
}
return derivs;
result[0],
result[1],
result[2]);
return vtkm::internal::LclErrorToVtkmError(status);
}
} // namespace internal
@ -98,47 +68,47 @@ template <typename FieldVecType,
typename WorldCoordType,
typename ParametricCoordType,
typename CellShapeTag>
VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivative(
const FieldVecType& field,
const WorldCoordType& wCoords,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
VTKM_EXEC vtkm::ErrorCode CellDerivative(const FieldVecType& field,
const WorldCoordType& wCoords,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
CellShapeTag shape,
vtkm::Vec<typename FieldVecType::ComponentType, 3>& result)
{
return internal::CellDerivativeImpl(
vtkm::internal::make_VtkcCellShapeTag(shape), field, wCoords, pcoords, worklet);
vtkm::internal::make_LclCellShapeTag(shape), field, wCoords, pcoords, result);
}
template <typename FieldVecType, typename WorldCoordType, typename ParametricCoordType>
VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivative(
const FieldVecType&,
const WorldCoordType&,
const vtkm::Vec<ParametricCoordType, 3>&,
vtkm::CellShapeTagEmpty,
const vtkm::exec::FunctorBase& worklet)
VTKM_EXEC vtkm::ErrorCode CellDerivative(const FieldVecType&,
const WorldCoordType&,
const vtkm::Vec<ParametricCoordType, 3>&,
vtkm::CellShapeTagEmpty,
vtkm::Vec<typename FieldVecType::ComponentType, 3>& result)
{
worklet.RaiseError("Attempted to take derivative in empty cell.");
return vtkm::Vec<typename FieldVecType::ComponentType, 3>();
result = { 0 };
return vtkm::ErrorCode::OperationOnEmptyCell;
}
template <typename FieldVecType, typename WorldCoordType, typename ParametricCoordType>
VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivative(
const FieldVecType& field,
const WorldCoordType& wCoords,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolyLine,
const vtkm::exec::FunctorBase& worklet)
VTKM_EXEC vtkm::ErrorCode CellDerivative(const FieldVecType& field,
const WorldCoordType& wCoords,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolyLine,
vtkm::Vec<typename FieldVecType::ComponentType, 3>& result)
{
vtkm::IdComponent numPoints = field.GetNumberOfComponents();
VTKM_ASSERT(numPoints >= 1);
VTKM_ASSERT(numPoints == wCoords.GetNumberOfComponents());
if (numPoints != wCoords.GetNumberOfComponents())
{
result = { 0 };
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
switch (numPoints)
{
case 1:
return CellDerivative(field, wCoords, pcoords, vtkm::CellShapeTagVertex(), worklet);
return CellDerivative(field, wCoords, pcoords, vtkm::CellShapeTagVertex(), result);
case 2:
return CellDerivative(field, wCoords, pcoords, vtkm::CellShapeTagLine(), worklet);
return CellDerivative(field, wCoords, pcoords, vtkm::CellShapeTagLine(), result);
}
auto dt = static_cast<ParametricCoordType>(1) / static_cast<ParametricCoordType>(numPoints - 1);
@ -155,56 +125,105 @@ VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivative(
auto lineField = vtkm::make_Vec(field[idx - 1], field[idx]);
auto lineWCoords = vtkm::make_Vec(wCoords[idx - 1], wCoords[idx]);
auto pc = (pcoords[0] - static_cast<ParametricCoordType>(idx) * dt) / dt;
return internal::CellDerivativeImpl(lcl::Line{}, lineField, lineWCoords, &pc, worklet);
return internal::CellDerivativeImpl(lcl::Line{}, lineField, lineWCoords, &pc, result);
}
//-----------------------------------------------------------------------------
template <typename FieldVecType, typename WorldCoordType, typename ParametricCoordType>
VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivative(
const FieldVecType& field,
const WorldCoordType& wCoords,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolygon,
const vtkm::exec::FunctorBase& worklet)
VTKM_EXEC vtkm::ErrorCode CellDerivative(const FieldVecType& field,
const WorldCoordType& wCoords,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolygon,
vtkm::Vec<typename FieldVecType::ComponentType, 3>& result)
{
VTKM_ASSERT(field.GetNumberOfComponents() == wCoords.GetNumberOfComponents());
const vtkm::IdComponent numPoints = field.GetNumberOfComponents();
VTKM_ASSERT(numPoints > 0);
if ((numPoints <= 0) || (numPoints != wCoords.GetNumberOfComponents()))
{
result = { 0 };
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
switch (field.GetNumberOfComponents())
{
case 1:
return CellDerivative(field, wCoords, pcoords, vtkm::CellShapeTagVertex(), worklet);
return CellDerivative(field, wCoords, pcoords, vtkm::CellShapeTagVertex(), result);
case 2:
return CellDerivative(field, wCoords, pcoords, vtkm::CellShapeTagLine(), worklet);
return CellDerivative(field, wCoords, pcoords, vtkm::CellShapeTagLine(), result);
default:
return internal::CellDerivativeImpl(
lcl::Polygon(numPoints), field, wCoords, pcoords, worklet);
return internal::CellDerivativeImpl(lcl::Polygon(numPoints), field, wCoords, pcoords, result);
}
}
//-----------------------------------------------------------------------------
template <typename FieldVecType, typename ParametricCoordType>
VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivative(
const FieldVecType& field,
const vtkm::VecAxisAlignedPointCoordinates<2>& wCoords,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagQuad,
const vtkm::exec::FunctorBase& worklet)
VTKM_EXEC vtkm::ErrorCode CellDerivative(const FieldVecType& field,
const vtkm::VecAxisAlignedPointCoordinates<2>& wCoords,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagQuad,
vtkm::Vec<typename FieldVecType::ComponentType, 3>& result)
{
return internal::CellDerivativeImpl(lcl::Pixel{}, field, wCoords, pcoords, worklet);
return internal::CellDerivativeImpl(lcl::Pixel{}, field, wCoords, pcoords, result);
}
template <typename FieldVecType, typename ParametricCoordType>
VTKM_EXEC vtkm::ErrorCode CellDerivative(const FieldVecType& field,
const vtkm::VecAxisAlignedPointCoordinates<3>& wCoords,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagHexahedron,
vtkm::Vec<typename FieldVecType::ComponentType, 3>& result)
{
return internal::CellDerivativeImpl(lcl::Voxel{}, field, wCoords, pcoords, result);
}
//-----------------------------------------------------------------------------
/// \brief Take the derivative (get the gradient) of a point field in a cell.
///
/// Given the point field values for each node and the parametric coordinates
/// of a point within the cell, finds the derivative with respect to each
/// coordinate (i.e. the gradient) at that point. The derivative is not always
/// constant in some "linear" cells.
///
template <typename FieldVecType, typename WorldCoordType, typename ParametricCoordType>
VTKM_EXEC vtkm::ErrorCode CellDerivative(const FieldVecType& pointFieldValues,
const WorldCoordType& worldCoordinateValues,
const vtkm::Vec<ParametricCoordType, 3>& parametricCoords,
vtkm::CellShapeTagGeneric shape,
vtkm::Vec<typename FieldVecType::ComponentType, 3>& result)
{
vtkm::ErrorCode status;
switch (shape.Id)
{
vtkmGenericCellShapeMacro(
status = CellDerivative(
pointFieldValues, worldCoordinateValues, parametricCoords, CellShapeTag(), result));
default:
result = { 0 };
status = vtkm::ErrorCode::InvalidShapeId;
}
return status;
}
template <typename FieldVecType,
typename WorldCoordType,
typename ParametricCoordType,
typename CellShapeTag>
VTKM_DEPRECATED(
1.6,
"Call signature has changed to CellDerivative(field, wCoords, pcoords, shape, result).")
VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivative(
const FieldVecType& field,
const vtkm::VecAxisAlignedPointCoordinates<3>& wCoords,
const WorldCoordType& wCoords,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagHexahedron,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
return internal::CellDerivativeImpl(lcl::Voxel{}, field, wCoords, pcoords, worklet);
vtkm::Vec<typename FieldVecType::ComponentType, 3> result;
vtkm::ErrorCode status = CellDerivative(field, wCoords, pcoords, shape, result);
if (status != vtkm::ErrorCode::Success)
{
worklet.RaiseError(vtkm::ErrorString(status));
}
return result;
}
}
} // namespace vtkm::exec

247
vtkm/exec/CellEdge.h
View File

@ -13,6 +13,8 @@
#include <vtkm/Assert.h>
#include <vtkm/CellShape.h>
#include <vtkm/CellTraits.h>
#include <vtkm/Deprecated.h>
#include <vtkm/ErrorCode.h>
#include <vtkm/Types.h>
#include <vtkm/exec/FunctorBase.h>
#include <vtkm/internal/Assume.h>
@ -116,123 +118,199 @@ public:
} // namespace detail
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::IdComponent CellEdgeNumberOfEdges(vtkm::IdComponent numPoints,
CellShapeTag,
const vtkm::exec::FunctorBase&)
static inline VTKM_EXEC vtkm::ErrorCode CellEdgeNumberOfEdges(vtkm::IdComponent numPoints,
CellShapeTag,
vtkm::IdComponent& numEdges)
{
(void)numPoints; // Silence compiler warnings.
VTKM_ASSERT(numPoints == vtkm::CellTraits<CellShapeTag>::NUM_POINTS);
return detail::CellEdgeTables{}.NumEdges(CellShapeTag::Id);
if (numPoints != vtkm::CellTraits<CellShapeTag>::NUM_POINTS)
{
numEdges = -1;
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
numEdges = detail::CellEdgeTables{}.NumEdges(CellShapeTag::Id);
return vtkm::ErrorCode::Success;
}
static inline VTKM_EXEC vtkm::IdComponent CellEdgeNumberOfEdges(vtkm::IdComponent numPoints,
vtkm::CellShapeTagPolygon,
const vtkm::exec::FunctorBase&)
static inline VTKM_EXEC vtkm::ErrorCode CellEdgeNumberOfEdges(vtkm::IdComponent numPoints,
vtkm::CellShapeTagPolygon,
vtkm::IdComponent& numEdges)
{
VTKM_ASSUME(numPoints > 0);
return numPoints;
if (numPoints <= 0)
{
numEdges = -1;
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
numEdges = numPoints;
return vtkm::ErrorCode::Success;
}
static inline VTKM_EXEC vtkm::IdComponent CellEdgeNumberOfEdges(vtkm::IdComponent numPoints,
vtkm::CellShapeTagPolyLine,
const vtkm::exec::FunctorBase&)
static inline VTKM_EXEC vtkm::ErrorCode CellEdgeNumberOfEdges(vtkm::IdComponent numPoints,
vtkm::CellShapeTagPolyLine,
vtkm::IdComponent& numEdges)
{
(void)numPoints; // Silence compiler warnings.
VTKM_ASSUME(numPoints > 0);
return detail::CellEdgeTables{}.NumEdges(vtkm::CELL_SHAPE_POLY_LINE);
if (numPoints <= 0)
{
numEdges = -1;
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
numEdges = detail::CellEdgeTables{}.NumEdges(vtkm::CELL_SHAPE_POLY_LINE);
return vtkm::ErrorCode::Success;
}
static inline VTKM_EXEC vtkm::IdComponent CellEdgeNumberOfEdges(
vtkm::IdComponent numPoints,
vtkm::CellShapeTagGeneric shape,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode CellEdgeNumberOfEdges(vtkm::IdComponent numPoints,
vtkm::CellShapeTagGeneric shape,
vtkm::IdComponent& numEdges)
{
if (shape.Id == vtkm::CELL_SHAPE_POLYGON)
{
return CellEdgeNumberOfEdges(numPoints, vtkm::CellShapeTagPolygon(), worklet);
return CellEdgeNumberOfEdges(numPoints, vtkm::CellShapeTagPolygon(), numEdges);
}
else if (shape.Id == vtkm::CELL_SHAPE_POLY_LINE)
{
return CellEdgeNumberOfEdges(numPoints, vtkm::CellShapeTagPolyLine(), worklet);
return CellEdgeNumberOfEdges(numPoints, vtkm::CellShapeTagPolyLine(), numEdges);
}
else
{
return detail::CellEdgeTables{}.NumEdges(shape.Id);
numEdges = detail::CellEdgeTables{}.NumEdges(shape.Id);
return vtkm::ErrorCode::Success;
}
}
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::IdComponent CellEdgeLocalIndex(vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::IdComponent edgeIndex,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
VTKM_DEPRECATED(1.6, "Signature changed to CellEdgeNumberOfEdges(numPoints, shape, result).")
static inline VTKM_EXEC vtkm::IdComponent
CellEdgeNumberOfEdges(vtkm::IdComponent numPoints,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
VTKM_ASSUME(pointIndex >= 0);
VTKM_ASSUME(pointIndex < 2);
VTKM_ASSUME(edgeIndex >= 0);
VTKM_ASSUME(edgeIndex < detail::CellEdgeTables::MAX_NUM_EDGES);
if (edgeIndex >= vtkm::exec::CellEdgeNumberOfEdges(numPoints, shape, worklet))
vtkm::IdComponent numEdges;
vtkm::ErrorCode status = CellEdgeNumberOfEdges(numPoints, shape, numEdges);
if (status != vtkm::ErrorCode::Success)
{
worklet.RaiseError("Invalid edge number.");
return 0;
worklet.RaiseError(vtkm::ErrorString(status));
}
return numEdges;
}
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::ErrorCode CellEdgeLocalIndex(vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::IdComponent edgeIndex,
CellShapeTag shape,
vtkm::IdComponent& result)
{
if ((pointIndex < 0) || (pointIndex > 1))
{
result = -1;
return vtkm::ErrorCode::InvalidPointId;
}
if ((edgeIndex < 0) || (edgeIndex >= detail::CellEdgeTables::MAX_NUM_EDGES))
{
result = -1;
return vtkm::ErrorCode::InvalidEdgeId;
}
vtkm::IdComponent numEdges;
VTKM_RETURN_ON_ERROR(vtkm::exec::CellEdgeNumberOfEdges(numPoints, shape, numEdges));
if (edgeIndex >= numEdges)
{
result = -1;
return vtkm::ErrorCode::InvalidEdgeId;
}
detail::CellEdgeTables table;
return table.PointsInEdge(CellShapeTag::Id, edgeIndex, pointIndex);
result = table.PointsInEdge(CellShapeTag::Id, edgeIndex, pointIndex);
return vtkm::ErrorCode::Success;
}
static inline VTKM_EXEC vtkm::IdComponent CellEdgeLocalIndex(vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::IdComponent edgeIndex,
vtkm::CellShapeTagPolygon,
const vtkm::exec::FunctorBase&)
static inline VTKM_EXEC vtkm::ErrorCode CellEdgeLocalIndex(vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::IdComponent edgeIndex,
vtkm::CellShapeTagPolygon,
vtkm::IdComponent& result)
{
VTKM_ASSUME(numPoints >= 3);
VTKM_ASSUME(pointIndex >= 0);
VTKM_ASSUME(pointIndex < 2);
VTKM_ASSUME(edgeIndex >= 0);
VTKM_ASSUME(edgeIndex < numPoints);
if (numPoints < 3)
{
result = -1;
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
if ((pointIndex < 0) || (pointIndex > 1))
{
result = -1;
return vtkm::ErrorCode::InvalidPointId;
}
if ((edgeIndex < 0) || (edgeIndex >= numPoints))
{
result = -1;
return vtkm::ErrorCode::InvalidEdgeId;
}
if (edgeIndex + pointIndex < numPoints)
{
return edgeIndex + pointIndex;
result = edgeIndex + pointIndex;
}
else
{
return 0;
result = 0;
}
return vtkm::ErrorCode::Success;
}
static inline VTKM_EXEC vtkm::IdComponent CellEdgeLocalIndex(vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::IdComponent edgeIndex,
vtkm::CellShapeTagGeneric shape,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode CellEdgeLocalIndex(vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::IdComponent edgeIndex,
vtkm::CellShapeTagGeneric shape,
vtkm::IdComponent& result)
{
VTKM_ASSUME(pointIndex >= 0);
VTKM_ASSUME(pointIndex < 2);
VTKM_ASSUME(edgeIndex >= 0);
VTKM_ASSUME(edgeIndex < detail::CellEdgeTables::MAX_NUM_EDGES);
if ((pointIndex < 0) || (pointIndex > 1))
{
result = -1;
return vtkm::ErrorCode::InvalidPointId;
}
if ((edgeIndex < 0) || (edgeIndex >= detail::CellEdgeTables::MAX_NUM_EDGES))
{
result = -1;
return vtkm::ErrorCode::InvalidEdgeId;
}
if (shape.Id == vtkm::CELL_SHAPE_POLYGON)
{
return CellEdgeLocalIndex(
numPoints, pointIndex, edgeIndex, vtkm::CellShapeTagPolygon(), worklet);
numPoints, pointIndex, edgeIndex, vtkm::CellShapeTagPolygon(), result);
}
else
{
detail::CellEdgeTables table;
if (edgeIndex >= table.NumEdges(shape.Id))
{
worklet.RaiseError("Invalid edge number.");
return 0;
result = -1;
return vtkm::ErrorCode::InvalidEdgeId;
}
return table.PointsInEdge(shape.Id, edgeIndex, pointIndex);
result = table.PointsInEdge(shape.Id, edgeIndex, pointIndex);
return vtkm::ErrorCode::Success;
}
}
template <typename CellShapeTag>
VTKM_DEPRECATED(
1.6,
"Signature changed to CellEdgeLocalIndex(numPoints, pointIndex, edgeIndex, shape, result).")
static inline VTKM_EXEC vtkm::IdComponent CellEdgeLocalIndex(vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::IdComponent edgeIndex,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
vtkm::IdComponent result;
vtkm::ErrorCode status = CellEdgeLocalIndex(numPoints, pointIndex, edgeIndex, shape, result);
if (status != vtkm::ErrorCode::Success)
{
worklet.RaiseError(vtkm::ErrorString(status));
}
return result;
}
/// \brief Returns a canonical identifier for a cell edge
///
/// Given information about a cell edge and the global point indices for that cell, returns a
@ -240,25 +318,54 @@ static inline VTKM_EXEC vtkm::IdComponent CellEdgeLocalIndex(vtkm::IdComponent n
/// the same if and only if the edges contain the same points.
///
template <typename CellShapeTag, typename GlobalPointIndicesVecType>
static inline VTKM_EXEC vtkm::Id2 CellEdgeCanonicalId(
static inline VTKM_EXEC vtkm::ErrorCode CellEdgeCanonicalId(
vtkm::IdComponent numPoints,
vtkm::IdComponent edgeIndex,
CellShapeTag shape,
const GlobalPointIndicesVecType& globalPointIndicesVec,
const vtkm::exec::FunctorBase& worklet)
vtkm::Id2& result)
{
vtkm::Id pointIndex0 =
globalPointIndicesVec[vtkm::exec::CellEdgeLocalIndex(numPoints, 0, edgeIndex, shape, worklet)];
vtkm::Id pointIndex1 =
globalPointIndicesVec[vtkm::exec::CellEdgeLocalIndex(numPoints, 1, edgeIndex, shape, worklet)];
result = { -1, -1 };
vtkm::IdComponent localIndex0;
VTKM_RETURN_ON_ERROR(vtkm::exec::CellEdgeLocalIndex(numPoints, 0, edgeIndex, shape, localIndex0));
vtkm::Id pointIndex0 = globalPointIndicesVec[localIndex0];
vtkm::IdComponent localIndex1;
VTKM_RETURN_ON_ERROR(vtkm::exec::CellEdgeLocalIndex(numPoints, 1, edgeIndex, shape, localIndex1));
vtkm::Id pointIndex1 = globalPointIndicesVec[localIndex1];
if (pointIndex0 < pointIndex1)
{
return vtkm::Id2(pointIndex0, pointIndex1);
result = vtkm::Id2(pointIndex0, pointIndex1);
}
else
{
return vtkm::Id2(pointIndex1, pointIndex0);
result = vtkm::Id2(pointIndex1, pointIndex0);
}
return vtkm::ErrorCode::Success;
}
template <typename CellShapeTag, typename GlobalPointIndicesVecType>
VTKM_DEPRECATED(
1.6,
"Signature changed to CellEdgeCononicalId(numPoints, edgeIndex, shape, globalIds, result).")
static inline VTKM_EXEC vtkm::Id2
CellEdgeCanonicalId(vtkm::IdComponent numPoints,
vtkm::IdComponent edgeIndex,
CellShapeTag shape,
const GlobalPointIndicesVecType& globalPointIndicesVec,
const vtkm::exec::FunctorBase& worklet)
{
vtkm::Id2 result;
vtkm::ErrorCode status =
CellEdgeCanonicalId(numPoints, edgeIndex, shape, globalPointIndicesVec, result);
if (status != vtkm::ErrorCode::Success)
{
worklet.RaiseError(vtkm::ErrorString(status));
}
return result;
}
}
} // namespace vtkm::exec

222
vtkm/exec/CellFace.h
View File

@ -12,6 +12,8 @@
#include <vtkm/Assert.h>
#include <vtkm/CellShape.h>
#include <vtkm/Deprecated.h>
#include <vtkm/ErrorCode.h>
#include <vtkm/Types.h>
#include <vtkm/exec/FunctorBase.h>
#include <vtkm/internal/Assume.h>
@ -140,65 +142,148 @@ public:
} // namespace detail
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::IdComponent CellFaceNumberOfFaces(CellShapeTag shape,
const vtkm::exec::FunctorBase&)
static inline VTKM_EXEC vtkm::ErrorCode CellFaceNumberOfFaces(CellShapeTag shape,
vtkm::IdComponent& result)
{
(void)shape; //C4100 false positive workaround
detail::CellFaceTables table;
return table.NumFaces(shape.Id);
result = table.NumFaces(shape.Id);
return vtkm::ErrorCode::Success;
}
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::IdComponent CellFaceNumberOfPoints(
vtkm::IdComponent faceIndex,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
VTKM_DEPRECATED(1.6, "Signature changed to CellFaceNumberOfFaces(shape, result).")
static inline VTKM_EXEC vtkm::IdComponent
CellFaceNumberOfFaces(CellShapeTag shape, const vtkm::exec::FunctorBase& worklet)
{
VTKM_ASSUME(faceIndex >= 0);
VTKM_ASSUME(faceIndex < detail::CellFaceTables::MAX_NUM_FACES);
if (faceIndex >= vtkm::exec::CellFaceNumberOfFaces(shape, worklet))
vtkm::IdComponent result;
vtkm::ErrorCode status = CellFaceNumberOfFaces(shape, result);
if (status != vtkm::ErrorCode::Success)
{
worklet.RaiseError("Invalid face number.");
return 0;
worklet.RaiseError(vtkm::ErrorString(status));
}
return result;
}
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::ErrorCode CellFaceNumberOfPoints(vtkm::IdComponent faceIndex,
CellShapeTag shape,
vtkm::IdComponent& result)
{
if ((faceIndex < 0) || (faceIndex >= detail::CellFaceTables::MAX_NUM_FACES))
{
result = -1;
return vtkm::ErrorCode::InvalidFaceId;
}
vtkm::IdComponent numFaces;
VTKM_RETURN_ON_ERROR(vtkm::exec::CellFaceNumberOfFaces(shape, numFaces));
if (faceIndex >= numFaces)
{
result = -1;
return vtkm::ErrorCode::InvalidFaceId;
}
detail::CellFaceTables table;
return table.NumPointsInFace(shape.Id, faceIndex);
result = table.NumPointsInFace(shape.Id, faceIndex);
return vtkm::ErrorCode::Success;
}
template <typename CellShapeTag>
VTKM_DEPRECATED(1.6, "Signature changed to CellFaceNumberOfPoints(faceIndex, shape, result).")
static inline VTKM_EXEC vtkm::IdComponent
CellFaceNumberOfPoints(vtkm::IdComponent faceIndex,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
vtkm::IdComponent result;
vtkm::ErrorCode status = CellFaceNumberOfPoints(faceIndex, shape, result);
if (status != vtkm::ErrorCode::Success)
{
worklet.RaiseError(vtkm::ErrorString(status));
}
return result;
}
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::ErrorCode CellFaceShape(vtkm::IdComponent faceIndex,
CellShapeTag shape,
vtkm::UInt8& result)
{
if ((faceIndex < 0) || (faceIndex >= detail::CellFaceTables::MAX_NUM_FACES))
{
result = vtkm::CELL_SHAPE_EMPTY;
return vtkm::ErrorCode::InvalidFaceId;
}
vtkm::IdComponent numFacePoints;
VTKM_RETURN_ON_ERROR(CellFaceNumberOfPoints(faceIndex, shape, numFacePoints));
switch (numFacePoints)
{
case 3:
result = vtkm::CELL_SHAPE_TRIANGLE;
break;
case 4:
result = vtkm::CELL_SHAPE_QUAD;
break;
default:
result = vtkm::CELL_SHAPE_POLYGON;
break;
}
return vtkm::ErrorCode::Success;
}
template <typename CellShapeTag>
VTKM_DEPRECATED(1.6, "Signature changed to CellFaceShape(faceIndex, shape, result).")
static inline VTKM_EXEC vtkm::UInt8 CellFaceShape(vtkm::IdComponent faceIndex,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
VTKM_ASSUME(faceIndex >= 0);
VTKM_ASSUME(faceIndex < detail::CellFaceTables::MAX_NUM_FACES);
switch (CellFaceNumberOfPoints(faceIndex, shape, worklet))
vtkm::UInt8 result;
vtkm::ErrorCode status = CellFaceShape(faceIndex, shape, result);
if (status != vtkm::ErrorCode::Success)
{
case 3:
return vtkm::CELL_SHAPE_TRIANGLE;
case 4:
return vtkm::CELL_SHAPE_QUAD;
default:
return vtkm::CELL_SHAPE_POLYGON;
worklet.RaiseError(vtkm::ErrorString(status));
}
return result;
}
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::ErrorCode CellFaceLocalIndex(vtkm::IdComponent pointIndex,
vtkm::IdComponent faceIndex,
CellShapeTag shape,
vtkm::IdComponent& result)
{
vtkm::IdComponent numPointsInFace;
result = -1;
VTKM_RETURN_ON_ERROR(vtkm::exec::CellFaceNumberOfPoints(faceIndex, shape, numPointsInFace));
if (numPointsInFace < 1)
{
// An invalid face. We should already have gotten an error from
// CellFaceNumberOfPoints.
return vtkm::ErrorCode::InvalidFaceId;
}
detail::CellFaceTables table;
result = table.PointsInFace(shape.Id, faceIndex, pointIndex);
return vtkm::ErrorCode::Success;
}
template <typename CellShapeTag>
VTKM_DEPRECATED(1.6,
"Signature changed to CellFaceLocalIndex(pointIndex, faceIndex, shape, result).")
static inline VTKM_EXEC vtkm::IdComponent CellFaceLocalIndex(vtkm::IdComponent pointIndex,
vtkm::IdComponent faceIndex,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
vtkm::IdComponent numPointsInFace = vtkm::exec::CellFaceNumberOfPoints(faceIndex, shape, worklet);
if (numPointsInFace < 1)
vtkm::IdComponent result;
vtkm::ErrorCode status = CellFaceLocalIndex(pointIndex, faceIndex, shape, result);
if (status != vtkm::ErrorCode::Success)
{
// An invalid face. We should already have gotten an error from
// CellFaceNumberOfPoints.
return -1;
worklet.RaiseError(vtkm::ErrorString(status));
}
detail::CellFaceTables table;
return table.PointsInFace(shape.Id, faceIndex, pointIndex);
return result;
}
/// \brief Returns a canonical identifier for a cell face
@ -212,68 +297,69 @@ static inline VTKM_EXEC vtkm::IdComponent CellFaceLocalIndex(vtkm::IdComponent p
/// than a single point or single edge.
///
template <typename CellShapeTag, typename GlobalPointIndicesVecType>
static inline VTKM_EXEC vtkm::Id3 CellFaceCanonicalId(
static inline VTKM_EXEC vtkm::ErrorCode CellFaceCanonicalId(
vtkm::IdComponent faceIndex,
CellShapeTag shape,
const GlobalPointIndicesVecType& globalPointIndicesVec,
const vtkm::exec::FunctorBase& worklet)
vtkm::Id3& result)
{
const vtkm::IdComponent numPointsInFace =
vtkm::exec::CellFaceNumberOfPoints(faceIndex, shape, worklet);
vtkm::IdComponent numPointsInFace;
result = { -1 };
VTKM_RETURN_ON_ERROR(vtkm::exec::CellFaceNumberOfPoints(faceIndex, shape, numPointsInFace));
if (numPointsInFace == 0)
{
// An invalid face. We should already have gotten an error from
// CellFaceNumberOfPoints.
return vtkm::Id3(0);
return vtkm::ErrorCode::InvalidFaceId;
}
detail::CellFaceTables table;
//Sort the first 3 face points/nodes in ascending order
vtkm::Id3 sorted(globalPointIndicesVec[table.PointsInFace(shape.Id, faceIndex, 0)],
globalPointIndicesVec[table.PointsInFace(shape.Id, faceIndex, 1)],
globalPointIndicesVec[table.PointsInFace(shape.Id, faceIndex, 2)]);
result = vtkm::Id3(globalPointIndicesVec[table.PointsInFace(shape.Id, faceIndex, 0)],
globalPointIndicesVec[table.PointsInFace(shape.Id, faceIndex, 1)],
globalPointIndicesVec[table.PointsInFace(shape.Id, faceIndex, 2)]);
vtkm::Id temp;
if (sorted[0] > sorted[2])
if (result[0] > result[2])
{
temp = sorted[0];
sorted[0] = sorted[2];
sorted[2] = temp;
temp = result[0];
result[0] = result[2];
result[2] = temp;
}
if (sorted[0] > sorted[1])
if (result[0] > result[1])
{
temp = sorted[0];
sorted[0] = sorted[1];
sorted[1] = temp;
temp = result[0];
result[0] = result[1];
result[1] = temp;
}
if (sorted[1] > sorted[2])
if (result[1] > result[2])
{
temp = sorted[1];
sorted[1] = sorted[2];
sorted[2] = temp;
temp = result[1];
result[1] = result[2];
result[2] = temp;
}
// Check the rest of the points to see if they are in the lowest 3
for (vtkm::IdComponent pointIndex = 3; pointIndex < numPointsInFace; pointIndex++)
{
vtkm::Id nextPoint = globalPointIndicesVec[table.PointsInFace(shape.Id, faceIndex, pointIndex)];
if (nextPoint < sorted[2])
if (nextPoint < result[2])
{
if (nextPoint < sorted[1])
if (nextPoint < result[1])
{
sorted[2] = sorted[1];
if (nextPoint < sorted[0])
result[2] = result[1];
if (nextPoint < result[0])
{
sorted[1] = sorted[0];
sorted[0] = nextPoint;
result[1] = result[0];
result[0] = nextPoint;
}
else // nextPoint > P0, nextPoint < P1
{
sorted[1] = nextPoint;
result[1] = nextPoint;
}
}
else // nextPoint > P1, nextPoint < P2
{
sorted[2] = nextPoint;
result[2] = nextPoint;
}
}
else // nextPoint > P2
@ -282,7 +368,25 @@ static inline VTKM_EXEC vtkm::Id3 CellFaceCanonicalId(
}
}
return sorted;
return vtkm::ErrorCode::Success;
}
template <typename CellShapeTag, typename GlobalPointIndicesVecType>
VTKM_DEPRECATED(1.6,
"Signature changed to CellFaceCononicalId(faceIndex, shape, globalIds, result).")
static inline VTKM_EXEC vtkm::Id3
CellFaceCanonicalId(vtkm::IdComponent faceIndex,
CellShapeTag shape,
const GlobalPointIndicesVecType& globalPointIndicesVec,
const vtkm::exec::FunctorBase& worklet)
{
vtkm::Id3 result;
vtkm::ErrorCode status = CellFaceCanonicalId(faceIndex, shape, globalPointIndicesVec, result);
if (status != vtkm::ErrorCode::Success)
{
worklet.RaiseError(vtkm::ErrorString(status));
}
return result;
}
}
} // namespace vtkm::exec

183
vtkm/exec/CellInterpolate.h
View File

@ -12,6 +12,8 @@
#include <vtkm/Assert.h>
#include <vtkm/CellShape.h>
#include <vtkm/Deprecated.h>
#include <vtkm/ErrorCode.h>
#include <vtkm/VecAxisAlignedPointCoordinates.h>
#include <vtkm/exec/FunctorBase.h>
@ -31,92 +33,65 @@ namespace internal
{
template <typename VtkcCellShapeTag, typename FieldVecType, typename ParametricCoordType>
VTKM_EXEC typename FieldVecType::ComponentType CellInterpolateImpl(
VtkcCellShapeTag tag,
const FieldVecType& field,
const ParametricCoordType& pcoords,
const vtkm::exec::FunctorBase& worklet)
VTKM_EXEC vtkm::ErrorCode CellInterpolateImpl(VtkcCellShapeTag tag,
const FieldVecType& field,
const ParametricCoordType& pcoords,
typename FieldVecType::ComponentType& result)
{
VTKM_ASSERT(tag.numberOfPoints() == field.GetNumberOfComponents());
if (tag.numberOfPoints() != field.GetNumberOfComponents())
{
result = { 0 };
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
using FieldValueType = typename FieldVecType::ComponentType;
IdComponent numComponents = vtkm::VecTraits<FieldValueType>::GetNumberOfComponents(field[0]);
FieldValueType result(0);
auto status =
lcl::interpolate(tag, lcl::makeFieldAccessorNestedSOA(field, numComponents), pcoords, result);
if (status != lcl::ErrorCode::SUCCESS)
{
worklet.RaiseError(lcl::errorString(status));
}
return result;
return vtkm::internal::LclErrorToVtkmError(status);
}
} // namespace internal
//-----------------------------------------------------------------------------
/// \brief Interpolate a point field in a cell.
///
/// Given the point field values for each node and the parametric coordinates
/// of a point within the cell, interpolates the field to that point.
///
template <typename FieldVecType, typename ParametricCoordType>
VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate(
const FieldVecType& pointFieldValues,
const vtkm::Vec<ParametricCoordType, 3>& parametricCoords,
vtkm::CellShapeTagGeneric shape,
const vtkm::exec::FunctorBase& worklet)
{
typename FieldVecType::ComponentType result;
switch (shape.Id)
{
vtkmGenericCellShapeMacro(
result = CellInterpolate(pointFieldValues, parametricCoords, CellShapeTag(), worklet));
default:
worklet.RaiseError("Unknown cell shape sent to interpolate.");
return typename FieldVecType::ComponentType();
}
return result;
}
//-----------------------------------------------------------------------------
template <typename FieldVecType, typename ParametricCoordType, typename CellShapeTag>
VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate(
const FieldVecType& pointFieldValues,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
CellShapeTag tag,
const vtkm::exec::FunctorBase& worklet)
VTKM_EXEC vtkm::ErrorCode CellInterpolate(const FieldVecType& pointFieldValues,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
CellShapeTag tag,
typename FieldVecType::ComponentType& result)
{
auto lclTag =
vtkm::internal::make_VtkcCellShapeTag(tag, pointFieldValues.GetNumberOfComponents());
return internal::CellInterpolateImpl(lclTag, pointFieldValues, pcoords, worklet);
auto lclTag = vtkm::internal::make_LclCellShapeTag(tag, pointFieldValues.GetNumberOfComponents());
return internal::CellInterpolateImpl(lclTag, pointFieldValues, pcoords, result);
}
//-----------------------------------------------------------------------------
template <typename FieldVecType, typename ParametricCoordType>
VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate(
const FieldVecType&,
const vtkm::Vec<ParametricCoordType, 3>&,
vtkm::CellShapeTagEmpty,
const vtkm::exec::FunctorBase& worklet)
VTKM_EXEC vtkm::ErrorCode CellInterpolate(const FieldVecType&,
const vtkm::Vec<ParametricCoordType, 3>&,
vtkm::CellShapeTagEmpty,
typename FieldVecType::ComponentType& result)
{
worklet.RaiseError("Attempted to interpolate an empty cell.");
return typename FieldVecType::ComponentType();
result = { 0 };
return vtkm::ErrorCode::OperationOnEmptyCell;
}
//-----------------------------------------------------------------------------
template <typename FieldVecType, typename ParametricCoordType>
VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate(
const FieldVecType& field,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolyLine,
const vtkm::exec::FunctorBase& worklet)
VTKM_EXEC vtkm::ErrorCode CellInterpolate(const FieldVecType& field,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolyLine,
typename FieldVecType::ComponentType& result)
{
const vtkm::IdComponent numPoints = field.GetNumberOfComponents();
VTKM_ASSERT(numPoints >= 1);
if (numPoints < 1)
{
result = { 0 };
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
if (numPoints == 1)
{
return CellInterpolate(field, pcoords, vtkm::CellShapeTagVertex(), worklet);
return CellInterpolate(field, pcoords, vtkm::CellShapeTagVertex(), result);
}
using T = ParametricCoordType;
@ -125,53 +100,101 @@ VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate(
vtkm::IdComponent idx = static_cast<vtkm::IdComponent>(pcoords[0] / dt);
if (idx == numPoints - 1)
{
return field[numPoints - 1];
result = field[numPoints - 1];
return vtkm::ErrorCode::Success;
}
T pc = (pcoords[0] - static_cast<T>(idx) * dt) / dt;
return internal::CellInterpolateImpl(
lcl::Line{}, vtkm::make_Vec(field[idx], field[idx + 1]), &pc, worklet);
lcl::Line{}, vtkm::make_Vec(field[idx], field[idx + 1]), &pc, result);
}
//-----------------------------------------------------------------------------
template <typename FieldVecType, typename ParametricCoordType>
VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate(
const FieldVecType& field,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolygon,
const vtkm::exec::FunctorBase& worklet)
VTKM_EXEC vtkm::ErrorCode CellInterpolate(const FieldVecType& field,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolygon,
typename FieldVecType::ComponentType& result)
{
const vtkm::IdComponent numPoints = field.GetNumberOfComponents();
VTKM_ASSERT(numPoints > 0);
if (numPoints < 1)
{
result = { 0 };
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
switch (numPoints)
{
case 1:
return CellInterpolate(field, pcoords, vtkm::CellShapeTagVertex(), worklet);
return CellInterpolate(field, pcoords, vtkm::CellShapeTagVertex(), result);
case 2:
return CellInterpolate(field, pcoords, vtkm::CellShapeTagLine(), worklet);
return CellInterpolate(field, pcoords, vtkm::CellShapeTagLine(), result);
default:
return internal::CellInterpolateImpl(lcl::Polygon(numPoints), field, pcoords, worklet);
return internal::CellInterpolateImpl(lcl::Polygon(numPoints), field, pcoords, result);
}
}
//-----------------------------------------------------------------------------
template <typename ParametricCoordType>
VTKM_EXEC vtkm::Vec3f CellInterpolate(const vtkm::VecAxisAlignedPointCoordinates<2>& field,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagQuad,
const vtkm::exec::FunctorBase& worklet)
VTKM_EXEC vtkm::ErrorCode CellInterpolate(const vtkm::VecAxisAlignedPointCoordinates<2>& field,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagQuad,
vtkm::Vec3f& result)
{
return internal::CellInterpolateImpl(lcl::Pixel{}, field, pcoords, worklet);
return internal::CellInterpolateImpl(lcl::Pixel{}, field, pcoords, result);
}
//-----------------------------------------------------------------------------
template <typename ParametricCoordType>
VTKM_EXEC vtkm::Vec3f CellInterpolate(const vtkm::VecAxisAlignedPointCoordinates<3>& field,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagHexahedron,
const vtkm::exec::FunctorBase& worklet)
VTKM_EXEC vtkm::ErrorCode CellInterpolate(const vtkm::VecAxisAlignedPointCoordinates<3>& field,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagHexahedron,
vtkm::Vec3f& result)
{
return internal::CellInterpolateImpl(lcl::Voxel{}, field, pcoords, worklet);
return internal::CellInterpolateImpl(lcl::Voxel{}, field, pcoords, result);
}
//-----------------------------------------------------------------------------
/// \brief Interpolate a point field in a cell.
///
/// Given the point field values for each node and the parametric coordinates
/// of a point within the cell, interpolates the field to that point.
///
template <typename FieldVecType, typename ParametricCoordType>
VTKM_EXEC vtkm::ErrorCode CellInterpolate(const FieldVecType& pointFieldValues,
const vtkm::Vec<ParametricCoordType, 3>& parametricCoords,
vtkm::CellShapeTagGeneric shape,
typename FieldVecType::ComponentType& result)
{
vtkm::ErrorCode status;
switch (shape.Id)
{
vtkmGenericCellShapeMacro(
status = CellInterpolate(pointFieldValues, parametricCoords, CellShapeTag(), result));
default:
result = { 0 };
status = vtkm::ErrorCode::InvalidShapeId;
}
return status;
}
//-----------------------------------------------------------------------------
template <typename FieldVecType, typename ParametricCoordType, typename CellShapeTag>
VTKM_DEPRECATED(1.6,
"Signature changed to CellInterpolate(pointFieldValues, pcoords, shape, result).")
VTKM_EXEC typename FieldVecType::ComponentType
CellInterpolate(const FieldVecType& pointFieldValues,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
typename FieldVecType::ComponentType result;
vtkm::ErrorCode status = CellInterpolate(pointFieldValues, pcoords, shape, result);
if (status != vtkm::ErrorCode::Success)
{
worklet.RaiseError(vtkm::ErrorString(status));
}
return result;
}
}
} // namespace vtkm::exec

23
vtkm/exec/CellLocator.h
View File

@ -10,6 +10,8 @@
#ifndef vtk_m_exec_CellLocator_h
#define vtk_m_exec_CellLocator_h
#include <vtkm/Deprecated.h>
#include <vtkm/ErrorCode.h>
#include <vtkm/Types.h>
#include <vtkm/VirtualObjectBase.h>
#include <vtkm/exec/FunctorBase.h>
@ -29,10 +31,23 @@ public:
}
VTKM_EXEC
virtual void FindCell(const vtkm::Vec3f& point,
vtkm::Id& cellId,
vtkm::Vec3f& parametric,
const vtkm::exec::FunctorBase& worklet) const = 0;
virtual vtkm::ErrorCode FindCell(const vtkm::Vec3f& point,
vtkm::Id& cellId,
vtkm::Vec3f& parametric) const = 0;
VTKM_EXEC
VTKM_DEPRECATED(1.6, "FindCell no longer takes worklet argument.")
void FindCell(const vtkm::Vec3f& point,
vtkm::Id& cellId,
vtkm::Vec3f& parametric,
const vtkm::exec::FunctorBase& worklet) const
{
vtkm::ErrorCode status = this->FindCell(point, cellId, parametric);
if (status != vtkm::ErrorCode::Success)
{
worklet.RaiseError(vtkm::ErrorString(status));
}
}
};
} // namespace exec

71
vtkm/exec/CellLocatorBoundingIntervalHierarchyExec.h
View File

@ -95,10 +95,9 @@ public:
}
VTKM_EXEC
void FindCell(const vtkm::Vec3f& point,
vtkm::Id& cellId,
vtkm::Vec3f& parametric,
const vtkm::exec::FunctorBase& worklet) const override
vtkm::ErrorCode FindCell(const vtkm::Vec3f& point,
vtkm::Id& cellId,
vtkm::Vec3f& parametric) const override
{
cellId = -1;
vtkm::Id nodeIndex = 0;
@ -109,7 +108,7 @@ public:
switch (state)
{
case FindCellState::EnterNode:
this->EnterNode(state, point, cellId, nodeIndex, parametric, worklet);
VTKM_RETURN_ON_ERROR(this->EnterNode(state, point, cellId, nodeIndex, parametric));
break;
case FindCellState::AscendFromNode:
this->AscendFromNode(state, nodeIndex);
@ -122,6 +121,15 @@ public:
break;
}
}
if (cellId >= 0)
{
return vtkm::ErrorCode::Success;
}
else
{
return vtkm::ErrorCode::CellNotFound;
}
}
private:
@ -134,12 +142,11 @@ private:
};
VTKM_EXEC
void EnterNode(FindCellState& state,
const vtkm::Vec3f& point,
vtkm::Id& cellId,
vtkm::Id nodeIndex,
vtkm::Vec3f& parametric,
const vtkm::exec::FunctorBase& worklet) const
vtkm::ErrorCode EnterNode(FindCellState& state,
const vtkm::Vec3f& point,
vtkm::Id& cellId,
vtkm::Id nodeIndex,
vtkm::Vec3f& parametric) const
{
VTKM_ASSERT(state == FindCellState::EnterNode);
@ -148,13 +155,14 @@ private:
if (node.ChildIndex < 0)
{
// In a leaf node. Look for a containing cell.
cellId = this->FindInLeaf(point, parametric, node, worklet);
VTKM_RETURN_ON_ERROR(this->FindInLeaf(point, parametric, node, cellId));
state = FindCellState::AscendFromNode;
}
else
{
state = FindCellState::DescendLeftChild;
}
return vtkm::ErrorCode::Success;
}
VTKM_EXEC
@ -221,10 +229,11 @@ private:
}
}
VTKM_EXEC vtkm::Id FindInLeaf(const vtkm::Vec3f& point,
vtkm::Vec3f& parametric,
const vtkm::exec::CellLocatorBoundingIntervalHierarchyNode& node,
const vtkm::exec::FunctorBase& worklet) const
VTKM_EXEC vtkm::ErrorCode FindInLeaf(
const vtkm::Vec3f& point,
vtkm::Vec3f& parametric,
const vtkm::exec::CellLocatorBoundingIntervalHierarchyNode& node,
vtkm::Id& containingCellId) const
{
using IndicesType = typename CellSetPortal::IndicesType;
for (vtkm::Id i = node.Leaf.Start; i < node.Leaf.Start + node.Leaf.Size; ++i)
@ -233,25 +242,31 @@ private:
IndicesType cellPointIndices = this->CellSet.GetIndices(cellId);
vtkm::VecFromPortalPermute<IndicesType, CoordsPortal> cellPoints(&cellPointIndices,
this->Coords);
if (IsPointInCell(point, parametric, this->CellSet.GetCellShape(cellId), cellPoints, worklet))
bool found;
VTKM_RETURN_ON_ERROR(this->IsPointInCell(
point, parametric, this->CellSet.GetCellShape(cellId), cellPoints, found));
if (found)
{
return cellId;
containingCellId = cellId;
return vtkm::ErrorCode::Success;
}
}
return -1;
containingCellId = -1;
return vtkm::ErrorCode::Success;
}
template <typename CoordsType, typename CellShapeTag>
VTKM_EXEC static bool IsPointInCell(const vtkm::Vec3f& point,
vtkm::Vec3f& parametric,
CellShapeTag cellShape,
const CoordsType& cellPoints,
const vtkm::exec::FunctorBase& worklet)
VTKM_EXEC static vtkm::ErrorCode IsPointInCell(const vtkm::Vec3f& point,
vtkm::Vec3f& parametric,
CellShapeTag cellShape,
const CoordsType& cellPoints,
bool& isInside)
{
bool success = false;
parametric = vtkm::exec::WorldCoordinatesToParametricCoordinates(
cellPoints, point, cellShape, success, worklet);
return success && vtkm::exec::CellInside(parametric, cellShape);
isInside = false;
VTKM_RETURN_ON_ERROR(vtkm::exec::WorldCoordinatesToParametricCoordinates(
cellPoints, point, cellShape, parametric));
isInside = vtkm::exec::CellInside(parametric, cellShape);
return vtkm::ErrorCode::Success;
}
using VisitType = vtkm::TopologyElementTagCell;

12
vtkm/exec/CellLocatorRectilinearGrid.h
View File

@ -95,16 +95,14 @@ public:
}
VTKM_EXEC
void FindCell(const vtkm::Vec3f& point,
vtkm::Id& cellId,
vtkm::Vec3f& parametric,
const vtkm::exec::FunctorBase& worklet) const override
vtkm::ErrorCode FindCell(const vtkm::Vec3f& point,
vtkm::Id& cellId,
vtkm::Vec3f& parametric) const override
{
(void)worklet; //suppress unused warning
if (!this->IsInside(point))
{
cellId = -1;
return;
return vtkm::ErrorCode::CellNotFound;
}
// Get the Cell Id from the point.
@ -148,6 +146,8 @@ public:
}
// Get the actual cellId, from the logical cell index of the cell
cellId = logicalCell[2] * this->PlaneSize + logicalCell[1] * this->RowSize + logicalCell[0];
return vtkm::ErrorCode::Success;
}
private:

12
vtkm/exec/CellLocatorUniformGrid.h
View File

@ -75,16 +75,14 @@ public:
}
VTKM_EXEC
void FindCell(const vtkm::Vec3f& point,
vtkm::Id& cellId,
vtkm::Vec3f& parametric,
const vtkm::exec::FunctorBase& worklet) const override
vtkm::ErrorCode FindCell(const vtkm::Vec3f& point,
vtkm::Id& cellId,
vtkm::Vec3f& parametric) const override
{
(void)worklet; //suppress unused warning
if (!this->IsInside(point))
{
cellId = -1;
return;
return vtkm::ErrorCode::CellNotFound;
}
// Get the Cell Id from the point.
vtkm::Id3 logicalCell(0, 0, 0);
@ -112,6 +110,8 @@ public:
cellId =
(logicalCell[2] * this->CellDims[1] + logicalCell[1]) * this->CellDims[0] + logicalCell[0];
parametric = temp - logicalCell;
return vtkm::ErrorCode::Success;
}
private:

628
vtkm/exec/ParametricCoordinates.h
View File

@ -27,81 +27,90 @@ namespace exec
//-----------------------------------------------------------------------------
template <typename ParametricCoordType, typename CellShapeTag>
static inline VTKM_EXEC void ParametricCoordinatesCenter(vtkm::IdComponent numPoints,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
CellShapeTag,
const vtkm::exec::FunctorBase&)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesCenter(
vtkm::IdComponent numPoints,
CellShapeTag,
vtkm::Vec<ParametricCoordType, 3>& pcoords)
{
auto lclTag = typename vtkm::internal::CellShapeTagVtkmToVtkc<CellShapeTag>::Type{};
(void)numPoints; // Silence compiler warnings.
VTKM_ASSERT(numPoints == lclTag.numberOfPoints());
pcoords = vtkm::TypeTraits<vtkm::Vec<ParametricCoordType, 3>>::ZeroInitialization();
lcl::parametricCenter(lclTag, pcoords);
if (numPoints != lclTag.numberOfPoints())
{
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
return vtkm::internal::LclErrorToVtkmError(lcl::parametricCenter(lclTag, pcoords));
}
template <typename ParametricCoordType>
static inline VTKM_EXEC void ParametricCoordinatesCenter(vtkm::IdComponent numPoints,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagEmpty,
const vtkm::exec::FunctorBase&)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesCenter(
vtkm::IdComponent numPoints,
vtkm::CellShapeTagEmpty,
vtkm::Vec<ParametricCoordType, 3>& pcoords)
{
(void)numPoints; // Silence compiler warnings.
VTKM_ASSERT(numPoints == 0);
pcoords = vtkm::TypeTraits<vtkm::Vec<ParametricCoordType, 3>>::ZeroInitialization();
if (numPoints != 0)
{
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
return vtkm::ErrorCode::Success;
}
template <typename ParametricCoordType>
static inline VTKM_EXEC void ParametricCoordinatesCenter(vtkm::IdComponent numPoints,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagVertex,
const vtkm::exec::FunctorBase&)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesCenter(
vtkm::IdComponent numPoints,
vtkm::CellShapeTagVertex,
vtkm::Vec<ParametricCoordType, 3>& pcoords)
{
(void)numPoints; // Silence compiler warnings.
VTKM_ASSERT(numPoints == 1);
pcoords = vtkm::TypeTraits<vtkm::Vec<ParametricCoordType, 3>>::ZeroInitialization();
if (numPoints != 1)
{
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
return vtkm::ErrorCode::Success;
}
template <typename ParametricCoordType>
static inline VTKM_EXEC void ParametricCoordinatesCenter(vtkm::IdComponent numPoints,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolyLine,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesCenter(
vtkm::IdComponent numPoints,
vtkm::CellShapeTagPolyLine,
vtkm::Vec<ParametricCoordType, 3>& pcoords)
{
switch (numPoints)
{
case 1:
ParametricCoordinatesCenter(numPoints, pcoords, vtkm::CellShapeTagVertex(), worklet);
return;
return ParametricCoordinatesCenter(numPoints, vtkm::CellShapeTagVertex(), pcoords);
case 2:
ParametricCoordinatesCenter(numPoints, pcoords, vtkm::CellShapeTagLine(), worklet);
return;
return ParametricCoordinatesCenter(numPoints, vtkm::CellShapeTagLine(), pcoords);
}
pcoords[0] = 0.5;
pcoords[1] = 0;
pcoords[2] = 0;
return vtkm::ErrorCode::Success;
}
template <typename ParametricCoordType>
static inline VTKM_EXEC void ParametricCoordinatesCenter(vtkm::IdComponent numPoints,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolygon,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesCenter(
vtkm::IdComponent numPoints,
vtkm::CellShapeTagPolygon,
vtkm::Vec<ParametricCoordType, 3>& pcoords)
{
VTKM_ASSERT(numPoints > 0);
if (numPoints < 1)
{
pcoords = { 0 };
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
switch (numPoints)
{
case 1:
ParametricCoordinatesCenter(numPoints, pcoords, vtkm::CellShapeTagVertex(), worklet);
break;
return ParametricCoordinatesCenter(numPoints, vtkm::CellShapeTagVertex(), pcoords);
case 2:
ParametricCoordinatesCenter(numPoints, pcoords, vtkm::CellShapeTagLine(), worklet);
break;
return ParametricCoordinatesCenter(numPoints, vtkm::CellShapeTagLine(), pcoords);
default:
pcoords = vtkm::TypeTraits<vtkm::Vec<ParametricCoordType, 3>>::ZeroInitialization();
lcl::parametricCenter(lcl::Polygon(numPoints), pcoords);
break;
return vtkm::internal::LclErrorToVtkmError(
lcl::parametricCenter(lcl::Polygon(numPoints), pcoords));
}
}
@ -110,19 +119,34 @@ static inline VTKM_EXEC void ParametricCoordinatesCenter(vtkm::IdComponent numPo
/// of points.
///
template <typename ParametricCoordType>
static inline VTKM_EXEC void ParametricCoordinatesCenter(vtkm::IdComponent numPoints,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagGeneric shape,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesCenter(
vtkm::IdComponent numPoints,
vtkm::CellShapeTagGeneric shape,
vtkm::Vec<ParametricCoordType, 3>& pcoords)
{
vtkm::ErrorCode status;
switch (shape.Id)
{
vtkmGenericCellShapeMacro(
ParametricCoordinatesCenter(numPoints, pcoords, CellShapeTag(), worklet));
vtkmGenericCellShapeMacro(status =
ParametricCoordinatesCenter(numPoints, CellShapeTag(), pcoords));
default:
worklet.RaiseError("Bad shape given to ParametricCoordinatesCenter.");
pcoords[0] = pcoords[1] = pcoords[2] = 0;
break;
pcoords = { 0 };
status = vtkm::ErrorCode::InvalidShapeId;
}
return status;
}
template <typename ParametricCoordType, typename CellShapeTag>
VTKM_DEPRECATED(1.6, "Signature changed to ParametricCoordinatesCenter(numPoints, shape, result).")
static inline VTKM_EXEC void ParametricCoordinatesCenter(vtkm::IdComponent numPoints,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
vtkm::ErrorCode status = ParametricCoordinatesCenter(numPoints, shape, pcoords);
if (status != vtkm::ErrorCode::Success)
{
worklet.RaiseError(vtkm::ErrorString(status));
}
}
@ -130,105 +154,119 @@ static inline VTKM_EXEC void ParametricCoordinatesCenter(vtkm::IdComponent numPo
/// of points.
///
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::Vec3f ParametricCoordinatesCenter(
vtkm::IdComponent numPoints,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
VTKM_DEPRECATED(1.6, "Signature changed to ParametricCoordinatesCenter(numPoints, shape, result).")
static inline VTKM_EXEC vtkm::Vec3f
ParametricCoordinatesCenter(vtkm::IdComponent numPoints,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
vtkm::Vec3f pcoords(0.0f);
ParametricCoordinatesCenter(numPoints, pcoords, shape, worklet);
vtkm::ErrorCode status = ParametricCoordinatesCenter(numPoints, shape, pcoords);
if (status != vtkm::ErrorCode::Success)
{
worklet.RaiseError(vtkm::ErrorString(status));
}
return pcoords;
}
//-----------------------------------------------------------------------------
template <typename ParametricCoordType, typename CellShapeTag>
static inline VTKM_EXEC void ParametricCoordinatesPoint(vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
CellShapeTag,
const vtkm::exec::FunctorBase&)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesPoint(
vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
CellShapeTag,
vtkm::Vec<ParametricCoordType, 3>& pcoords)
{
auto lclTag = typename vtkm::internal::CellShapeTagVtkmToVtkc<CellShapeTag>::Type{};
(void)numPoints; // Silence compiler warnings.
VTKM_ASSUME(numPoints == lclTag.numberOfPoints());
VTKM_ASSUME((pointIndex >= 0) && (pointIndex < numPoints));
if (numPoints != lclTag.numberOfPoints())
{
pcoords = { 0 };
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
if ((pointIndex < 0) || (pointIndex >= numPoints))
{
pcoords = { 0 };
return vtkm::ErrorCode::InvalidPointId;
}
pcoords = vtkm::TypeTraits<vtkm::Vec<ParametricCoordType, 3>>::ZeroInitialization();
lcl::parametricPoint(lclTag, pointIndex, pcoords);
return vtkm::internal::LclErrorToVtkmError(lcl::parametricPoint(lclTag, pointIndex, pcoords));
}
template <typename ParametricCoordType>
static inline VTKM_EXEC void ParametricCoordinatesPoint(vtkm::IdComponent,
vtkm::IdComponent,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagEmpty,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesPoint(
vtkm::IdComponent,
vtkm::IdComponent,
vtkm::CellShapeTagEmpty,
vtkm::Vec<ParametricCoordType, 3>& pcoords)
{
worklet.RaiseError("Empty cell has no points.");
pcoords[0] = pcoords[1] = pcoords[2] = 0;
return vtkm::ErrorCode::OperationOnEmptyCell;
}
template <typename ParametricCoordType>
static inline VTKM_EXEC void ParametricCoordinatesPoint(vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagVertex,
const vtkm::exec::FunctorBase&)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesPoint(
vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::CellShapeTagVertex,
vtkm::Vec<ParametricCoordType, 3>& pcoords)
{
(void)numPoints; // Silence compiler warnings.
(void)pointIndex; // Silence compiler warnings.
VTKM_ASSUME(numPoints == 1);
VTKM_ASSUME(pointIndex == 0);
pcoords = vtkm::TypeTraits<vtkm::Vec<ParametricCoordType, 3>>::ZeroInitialization();
if (numPoints != 1)
{
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
if (pointIndex != 0)
{
return vtkm::ErrorCode::InvalidPointId;
}
return vtkm::ErrorCode::Success;
}
template <typename ParametricCoordType>
static inline VTKM_EXEC void ParametricCoordinatesPoint(vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolyLine,
const vtkm::exec::FunctorBase& functor)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesPoint(
vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::CellShapeTagPolyLine,
vtkm::Vec<ParametricCoordType, 3>& pcoords)
{
if (numPoints < 1)
{
pcoords = { 0 };
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
switch (numPoints)
{
case 1:
ParametricCoordinatesPoint(
numPoints, pointIndex, pcoords, vtkm::CellShapeTagVertex(), functor);
return;
return ParametricCoordinatesPoint(numPoints, pointIndex, vtkm::CellShapeTagVertex(), pcoords);
case 2:
ParametricCoordinatesPoint(numPoints, pointIndex, pcoords, vtkm::CellShapeTagLine(), functor);
return;
return ParametricCoordinatesPoint(numPoints, pointIndex, vtkm::CellShapeTagLine(), pcoords);
}
pcoords[0] =
static_cast<ParametricCoordType>(pointIndex) / static_cast<ParametricCoordType>(numPoints - 1);
pcoords[1] = 0;
pcoords[2] = 0;
return vtkm::ErrorCode::Success;
}
template <typename ParametricCoordType>
static inline VTKM_EXEC void ParametricCoordinatesPoint(vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolygon,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesPoint(
vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::CellShapeTagPolygon,
vtkm::Vec<ParametricCoordType, 3>& pcoords)
{
VTKM_ASSUME((numPoints > 0));
VTKM_ASSUME((pointIndex >= 0) && (pointIndex < numPoints));
switch (numPoints)
{
case 1:
ParametricCoordinatesPoint(
numPoints, pointIndex, pcoords, vtkm::CellShapeTagVertex(), worklet);
return;
return ParametricCoordinatesPoint(numPoints, pointIndex, vtkm::CellShapeTagVertex(), pcoords);
case 2:
ParametricCoordinatesPoint(numPoints, pointIndex, pcoords, vtkm::CellShapeTagLine(), worklet);
return;
return ParametricCoordinatesPoint(numPoints, pointIndex, vtkm::CellShapeTagLine(), pcoords);
default:
pcoords = vtkm::TypeTraits<vtkm::Vec<ParametricCoordType, 3>>::ZeroInitialization();
lcl::parametricPoint(lcl::Polygon(numPoints), pointIndex, pcoords);
return;
return vtkm::internal::LclErrorToVtkmError(
lcl::parametricPoint(lcl::Polygon(numPoints), pointIndex, pcoords));
}
}
@ -237,20 +275,38 @@ static inline VTKM_EXEC void ParametricCoordinatesPoint(vtkm::IdComponent numPoi
/// the given number of points.
///
template <typename ParametricCoordType>
static inline VTKM_EXEC void ParametricCoordinatesPoint(vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagGeneric shape,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesPoint(
vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::CellShapeTagGeneric shape,
vtkm::Vec<ParametricCoordType, 3>& pcoords)
{
vtkm::ErrorCode status;
switch (shape.Id)
{
vtkmGenericCellShapeMacro(
ParametricCoordinatesPoint(numPoints, pointIndex, pcoords, CellShapeTag(), worklet));
status = ParametricCoordinatesPoint(numPoints, pointIndex, CellShapeTag(), pcoords));
default:
worklet.RaiseError("Bad shape given to ParametricCoordinatesPoint.");
pcoords[0] = pcoords[1] = pcoords[2] = 0;
break;
status = vtkm::ErrorCode::InvalidShapeId;
}
return status;
}
template <typename ParametricCoordType, typename CellShapeTag>
VTKM_DEPRECATED(
1.6,
"Signature changed to ParametricCoordinatesPoint(numPoints, pointIndex, shape, result).")
static inline VTKM_EXEC void ParametricCoordinatesPoint(vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
vtkm::ErrorCode status = ParametricCoordinatesPoint(numPoints, pointIndex, shape, pcoords);
if (status != vtkm::ErrorCode::Success)
{
worklet.RaiseError(vtkm::ErrorString(status));
}
}
@ -258,14 +314,21 @@ static inline VTKM_EXEC void ParametricCoordinatesPoint(vtkm::IdComponent numPoi
/// the given number of points.
///
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::Vec3f ParametricCoordinatesPoint(
vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
VTKM_DEPRECATED(
1.6,
"Signature changed to ParametricCoordinatesPoint(numPoints, pointIndex, shape, result).")
static inline VTKM_EXEC vtkm::Vec3f
ParametricCoordinatesPoint(vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
vtkm::Vec3f pcoords(0.0f);
ParametricCoordinatesPoint(numPoints, pointIndex, pcoords, shape, worklet);
vtkm::Vec3f pcoords;
vtkm::ErrorCode status = ParametricCoordinatesPoint(numPoints, pointIndex, shape, pcoords);
if (status != vtkm::ErrorCode::Success)
{
worklet.RaiseError(vtkm::ErrorString(status));
}
return pcoords;
}
@ -273,211 +336,218 @@ static inline VTKM_EXEC vtkm::Vec3f ParametricCoordinatesPoint(
namespace internal
{
template <typename VtkcCellShapeTag, typename WorldCoordVector, typename PCoordType>
static inline VTKM_EXEC typename WorldCoordVector::ComponentType
ParametricCoordinatesToWorldCoordinatesImpl(VtkcCellShapeTag tag,
const WorldCoordVector& pointWCoords,
const PCoordType& pcoords,
const vtkm::exec::FunctorBase& worklet)
template <typename LclCellShapeTag, typename WorldCoordVector, typename PCoordType>
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesToWorldCoordinatesImpl(
LclCellShapeTag tag,
const WorldCoordVector& pointWCoords,
const PCoordType& pcoords,
typename WorldCoordVector::ComponentType& wcoords)
{
typename WorldCoordVector::ComponentType wcoords(0);
auto status =
lcl::parametricToWorld(tag, lcl::makeFieldAccessorNestedSOA(pointWCoords, 3), pcoords, wcoords);
if (status != lcl::ErrorCode::SUCCESS)
{
worklet.RaiseError(lcl::errorString(status));
}
return wcoords;
return vtkm::internal::LclErrorToVtkmError(lcl::parametricToWorld(
tag, lcl::makeFieldAccessorNestedSOA(pointWCoords, 3), pcoords, wcoords));
}
} // namespace internal
template <typename WorldCoordVector, typename PCoordType, typename CellShapeTag>
static inline VTKM_EXEC typename WorldCoordVector::ComponentType
ParametricCoordinatesToWorldCoordinates(const WorldCoordVector& pointWCoords,
const vtkm::Vec<PCoordType, 3>& pcoords,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesToWorldCoordinates(
const WorldCoordVector& pointWCoords,
const vtkm::Vec<PCoordType, 3>& pcoords,
CellShapeTag shape,
typename WorldCoordVector::ComponentType& result)
{
auto numPoints = pointWCoords.GetNumberOfComponents();
return internal::ParametricCoordinatesToWorldCoordinatesImpl(
vtkm::internal::make_VtkcCellShapeTag(shape, numPoints), pointWCoords, pcoords, worklet);
vtkm::internal::make_LclCellShapeTag(shape, numPoints), pointWCoords, pcoords, result);
}
template <typename WorldCoordVector, typename PCoordType>
static inline VTKM_EXEC typename WorldCoordVector::ComponentType
ParametricCoordinatesToWorldCoordinates(const WorldCoordVector& pointWCoords,
const vtkm::Vec<PCoordType, 3>& pcoords,
vtkm::CellShapeTagEmpty empty,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesToWorldCoordinates(
const WorldCoordVector& pointWCoords,
const vtkm::Vec<PCoordType, 3>& pcoords,
vtkm::CellShapeTagEmpty empty,
typename WorldCoordVector::ComponentType& result)
{
return vtkm::exec::CellInterpolate(pointWCoords, pcoords, empty, worklet);
return vtkm::exec::CellInterpolate(pointWCoords, pcoords, empty, result);
}
template <typename WorldCoordVector, typename PCoordType>
static inline VTKM_EXEC typename WorldCoordVector::ComponentType
ParametricCoordinatesToWorldCoordinates(const WorldCoordVector& pointWCoords,
const vtkm::Vec<PCoordType, 3>& pcoords,
vtkm::CellShapeTagPolyLine polyLine,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesToWorldCoordinates(
const WorldCoordVector& pointWCoords,
const vtkm::Vec<PCoordType, 3>& pcoords,
vtkm::CellShapeTagPolyLine polyLine,
typename WorldCoordVector::ComponentType& result)
{
return vtkm::exec::CellInterpolate(pointWCoords, pcoords, polyLine, worklet);
return vtkm::exec::CellInterpolate(pointWCoords, pcoords, polyLine, result);
}
template <typename WorldCoordVector, typename PCoordType>
static inline VTKM_EXEC typename WorldCoordVector::ComponentType
ParametricCoordinatesToWorldCoordinates(const WorldCoordVector& pointWCoords,
const vtkm::Vec<PCoordType, 3>& pcoords,
vtkm::CellShapeTagPolygon,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesToWorldCoordinates(
const WorldCoordVector& pointWCoords,
const vtkm::Vec<PCoordType, 3>& pcoords,
vtkm::CellShapeTagPolygon,
typename WorldCoordVector::ComponentType& result)
{
auto numPoints = pointWCoords.GetNumberOfComponents();
switch (numPoints)
{
case 1:
return ParametricCoordinatesToWorldCoordinates(
pointWCoords, pcoords, vtkm::CellShapeTagVertex{}, worklet);
pointWCoords, pcoords, vtkm::CellShapeTagVertex{}, result);
case 2:
return ParametricCoordinatesToWorldCoordinates(
pointWCoords, pcoords, vtkm::CellShapeTagLine{}, worklet);
pointWCoords, pcoords, vtkm::CellShapeTagLine{}, result);
default:
return internal::ParametricCoordinatesToWorldCoordinatesImpl(
lcl::Polygon(numPoints), pointWCoords, pcoords, worklet);
lcl::Polygon(numPoints), pointWCoords, pcoords, result);
}
}
template <typename WorldCoordVector, typename PCoordType>
static inline VTKM_EXEC typename WorldCoordVector::ComponentType
ParametricCoordinatesToWorldCoordinates(const vtkm::VecAxisAlignedPointCoordinates<2>& pointWCoords,
const vtkm::Vec<PCoordType, 3>& pcoords,
vtkm::CellShapeTagQuad,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesToWorldCoordinates(
const vtkm::VecAxisAlignedPointCoordinates<2>& pointWCoords,
const vtkm::Vec<PCoordType, 3>& pcoords,
vtkm::CellShapeTagQuad,
typename WorldCoordVector::ComponentType& result)
{
return internal::ParametricCoordinatesToWorldCoordinatesImpl(
lcl::Pixel{}, pointWCoords, pcoords, worklet);
lcl::Pixel{}, pointWCoords, pcoords, result);
}
template <typename WorldCoordVector, typename PCoordType>
static inline VTKM_EXEC typename WorldCoordVector::ComponentType
ParametricCoordinatesToWorldCoordinates(const vtkm::VecAxisAlignedPointCoordinates<3>& pointWCoords,
const vtkm::Vec<PCoordType, 3>& pcoords,
vtkm::CellShapeTagHexahedron,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesToWorldCoordinates(
const vtkm::VecAxisAlignedPointCoordinates<3>& pointWCoords,
const vtkm::Vec<PCoordType, 3>& pcoords,
vtkm::CellShapeTagHexahedron,
typename WorldCoordVector::ComponentType& result)
{
return internal::ParametricCoordinatesToWorldCoordinatesImpl(
lcl::Voxel{}, pointWCoords, pcoords, worklet);
lcl::Voxel{}, pointWCoords, pcoords, result);
}
//-----------------------------------------------------------------------------
/// Returns the world coordinate corresponding to the given parametric coordinate of a cell.
///
template <typename WorldCoordVector, typename PCoordType>
static inline VTKM_EXEC typename WorldCoordVector::ComponentType
ParametricCoordinatesToWorldCoordinates(const WorldCoordVector& pointWCoords,
const vtkm::Vec<PCoordType, 3>& pcoords,
vtkm::CellShapeTagGeneric shape,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode ParametricCoordinatesToWorldCoordinates(
const WorldCoordVector& pointWCoords,
const vtkm::Vec<PCoordType, 3>& pcoords,
vtkm::CellShapeTagGeneric shape,
typename WorldCoordVector::ComponentType& result)
{
typename WorldCoordVector::ComponentType wcoords(0);
vtkm::ErrorCode status;
switch (shape.Id)
{
vtkmGenericCellShapeMacro(wcoords = ParametricCoordinatesToWorldCoordinates(
pointWCoords, pcoords, CellShapeTag(), worklet));
vtkmGenericCellShapeMacro(status = ParametricCoordinatesToWorldCoordinates(
pointWCoords, pcoords, CellShapeTag(), result));
default:
worklet.RaiseError("Bad shape given to ParametricCoordinatesPoint.");
break;
result = { 0 };
status = vtkm::ErrorCode::InvalidShapeId;
}
return wcoords;
return status;
}
template <typename WorldCoordVector, typename PCoordType, typename CellShapeTag>
VTKM_DEPRECATED(1.6,
"Signature changed to "
"ParametricCoordinatesToWorldCoordinates(pointWCoords, pcoords, shape, result).")
static inline VTKM_EXEC typename WorldCoordVector::ComponentType
ParametricCoordinatesToWorldCoordinates(const WorldCoordVector& pointWCoords,
const vtkm::Vec<PCoordType, 3>& pcoords,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
typename WorldCoordVector::ComponentType result;
vtkm::ErrorCode status =
ParametricCoordinatesToWorldCoordinates(pointWCoords, pcoords, shape, result);
if (status != vtkm::ErrorCode::Success)
{
worklet.RaiseError(vtkm::ErrorString(status));
}
return result;
}
//-----------------------------------------------------------------------------
namespace internal
{
template <typename VtkcCellShapeTag, typename WorldCoordVector>
static inline VTKM_EXEC typename WorldCoordVector::ComponentType
WorldCoordinatesToParametricCoordinatesImpl(VtkcCellShapeTag tag,
const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType& wcoords,
bool& success,
const vtkm::exec::FunctorBase& worklet)
template <typename LclCellShapeTag, typename WorldCoordVector>
static inline VTKM_EXEC vtkm::ErrorCode WorldCoordinatesToParametricCoordinatesImpl(
LclCellShapeTag tag,
const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType& wcoords,
typename WorldCoordVector::ComponentType& result)
{
VTKM_ASSERT(pointWCoords.GetNumberOfComponents() == tag.numberOfPoints());
auto pcoords = vtkm::TypeTraits<typename WorldCoordVector::ComponentType>::ZeroInitialization();
auto status =
lcl::worldToParametric(tag, lcl::makeFieldAccessorNestedSOA(pointWCoords, 3), wcoords, pcoords);
success = true;
if (status != lcl::ErrorCode::SUCCESS)
if (pointWCoords.GetNumberOfComponents() != tag.numberOfPoints())
{
worklet.RaiseError(lcl::errorString(status));
success = false;
result = { 0 };
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
return pcoords;
result = vtkm::TypeTraits<typename WorldCoordVector::ComponentType>::ZeroInitialization();
return vtkm::internal::LclErrorToVtkmError(
lcl::worldToParametric(tag, lcl::makeFieldAccessorNestedSOA(pointWCoords, 3), wcoords, result));
}
} // namespace internal
template <typename WorldCoordVector, typename CellShapeTag>
static inline VTKM_EXEC typename WorldCoordVector::ComponentType
WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType& wcoords,
CellShapeTag shape,
bool& success,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode WorldCoordinatesToParametricCoordinates(
const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType& wcoords,
CellShapeTag shape,
typename WorldCoordVector::ComponentType& result)
{
auto numPoints = pointWCoords.GetNumberOfComponents();
return internal::WorldCoordinatesToParametricCoordinatesImpl(
vtkm::internal::make_VtkcCellShapeTag(shape, numPoints),
pointWCoords,
wcoords,
success,
worklet);
vtkm::internal::make_LclCellShapeTag(shape, numPoints), pointWCoords, wcoords, result);
}
template <typename WorldCoordVector>
static inline VTKM_EXEC typename WorldCoordVector::ComponentType
WorldCoordinatesToParametricCoordinates(const WorldCoordVector&,
const typename WorldCoordVector::ComponentType&,
vtkm::CellShapeTagEmpty,
bool& success,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode WorldCoordinatesToParametricCoordinates(
const WorldCoordVector&,
const typename WorldCoordVector::ComponentType&,
vtkm::CellShapeTagEmpty,
typename WorldCoordVector::ComponentType& result)
{
worklet.RaiseError("Attempted to find point coordinates in empty cell.");
success = false;
return typename WorldCoordVector::ComponentType();
result = { 0 };
return vtkm::ErrorCode::OperationOnEmptyCell;
}
template <typename WorldCoordVector>
static inline VTKM_EXEC typename WorldCoordVector::ComponentType
WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType&,
vtkm::CellShapeTagVertex,
bool& success,
const vtkm::exec::FunctorBase& vtkmNotUsed(worklet))
static inline VTKM_EXEC vtkm::ErrorCode WorldCoordinatesToParametricCoordinates(
const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType&,
vtkm::CellShapeTagVertex,
typename WorldCoordVector::ComponentType& result)
{
(void)pointWCoords; // Silence compiler warnings.
VTKM_ASSERT(pointWCoords.GetNumberOfComponents() == 1);
success = true;
return typename WorldCoordVector::ComponentType(0, 0, 0);
if (pointWCoords.GetNumberOfComponents() != 1)
{
result = { 0 };
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
result = typename WorldCoordVector::ComponentType(0, 0, 0);
return vtkm::ErrorCode::Success;
}
template <typename WorldCoordVector>
static inline VTKM_EXEC typename WorldCoordVector::ComponentType
WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType& wcoords,
vtkm::CellShapeTagPolyLine,
bool& success,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode WorldCoordinatesToParametricCoordinates(
const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType& wcoords,
vtkm::CellShapeTagPolyLine,
typename WorldCoordVector::ComponentType& result)
{
vtkm::IdComponent numPoints = pointWCoords.GetNumberOfComponents();
VTKM_ASSERT(pointWCoords.GetNumberOfComponents() >= 1);
if (numPoints < 1)
{
result = { 0 };
return vtkm::ErrorCode::InvalidNumberOfPoints;
}
if (numPoints == 1)
{
return WorldCoordinatesToParametricCoordinates(
pointWCoords, wcoords, vtkm::CellShapeTagVertex(), success, worklet);
pointWCoords, wcoords, vtkm::CellShapeTagVertex(), result);
}
using Vector3 = typename WorldCoordVector::ComponentType;
@ -507,84 +577,106 @@ WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords,
}
vtkm::Vec<Vector3, 2> line(pointWCoords[idx - 1], pointWCoords[idx]);
auto lpc = WorldCoordinatesToParametricCoordinates(
line, wcoords, vtkm::CellShapeTagLine{}, success, worklet);
Vector3 lpc;
VTKM_RETURN_ON_ERROR(
WorldCoordinatesToParametricCoordinates(line, wcoords, vtkm::CellShapeTagLine{}, lpc));
//Segment param is [0,1] on that segment.
//Map that onto the param for the entire segment.
T dParam = static_cast<T>(1) / static_cast<T>(numPoints - 1);
T polyLineParam = static_cast<T>(idx - 1) * dParam + lpc[0] * dParam;
return Vector3(polyLineParam, 0, 0);
result = Vector3(polyLineParam, 0, 0);
return vtkm::ErrorCode::Success;
}
template <typename WorldCoordVector>
static inline VTKM_EXEC typename WorldCoordVector::ComponentType
WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType& wcoords,
vtkm::CellShapeTagPolygon,
bool& success,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode WorldCoordinatesToParametricCoordinates(
const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType& wcoords,
vtkm::CellShapeTagPolygon,
typename WorldCoordVector::ComponentType& result)
{
auto numPoints = pointWCoords.GetNumberOfComponents();
switch (numPoints)
{
case 1:
return WorldCoordinatesToParametricCoordinates(
pointWCoords, wcoords, vtkm::CellShapeTagVertex{}, success, worklet);
pointWCoords, wcoords, vtkm::CellShapeTagVertex{}, result);
case 2:
return WorldCoordinatesToParametricCoordinates(
pointWCoords, wcoords, vtkm::CellShapeTagLine{}, success, worklet);
pointWCoords, wcoords, vtkm::CellShapeTagLine{}, result);
default:
return internal::WorldCoordinatesToParametricCoordinatesImpl(
lcl::Polygon(numPoints), pointWCoords, wcoords, success, worklet);
lcl::Polygon(numPoints), pointWCoords, wcoords, result);
}
}
static inline VTKM_EXEC vtkm::Vec3f WorldCoordinatesToParametricCoordinates(
static inline VTKM_EXEC vtkm::ErrorCode WorldCoordinatesToParametricCoordinates(
const vtkm::VecAxisAlignedPointCoordinates<2>& pointWCoords,
const vtkm::Vec3f& wcoords,
vtkm::CellShapeTagQuad,
bool& success,
const FunctorBase& worklet)
vtkm::Vec3f& result)
{
return internal::WorldCoordinatesToParametricCoordinatesImpl(
lcl::Pixel{}, pointWCoords, wcoords, success, worklet);
lcl::Pixel{}, pointWCoords, wcoords, result);
}
static inline VTKM_EXEC vtkm::Vec3f WorldCoordinatesToParametricCoordinates(
static inline VTKM_EXEC vtkm::ErrorCode WorldCoordinatesToParametricCoordinates(
const vtkm::VecAxisAlignedPointCoordinates<3>& pointWCoords,
const vtkm::Vec3f& wcoords,
vtkm::CellShapeTagHexahedron,
bool& success,
const FunctorBase& worklet)
vtkm::Vec3f& result)
{
return internal::WorldCoordinatesToParametricCoordinatesImpl(
lcl::Voxel{}, pointWCoords, wcoords, success, worklet);
lcl::Voxel{}, pointWCoords, wcoords, result);
}
//-----------------------------------------------------------------------------
/// Returns the world paramteric corresponding to the given world coordinate for a cell.
///
template <typename WorldCoordVector>
static inline VTKM_EXEC typename WorldCoordVector::ComponentType
WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType& wcoords,
vtkm::CellShapeTagGeneric shape,
bool& success,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::ErrorCode WorldCoordinatesToParametricCoordinates(
const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType& wcoords,
vtkm::CellShapeTagGeneric shape,
typename WorldCoordVector::ComponentType& result)
{
typename WorldCoordVector::ComponentType result;
vtkm::ErrorCode status;
switch (shape.Id)
{
vtkmGenericCellShapeMacro(result = WorldCoordinatesToParametricCoordinates(
pointWCoords, wcoords, CellShapeTag(), success, worklet));
vtkmGenericCellShapeMacro(status = WorldCoordinatesToParametricCoordinates(
pointWCoords, wcoords, CellShapeTag(), result));
default:
success = false;
worklet.RaiseError("Unknown cell shape sent to world 2 parametric.");
return typename WorldCoordVector::ComponentType();
result = { 0 };
status = vtkm::ErrorCode::InvalidShapeId;
}
return status;
}
template <typename WorldCoordVector, typename CellShapeTag>
VTKM_DEPRECATED(1.6,
"Signature changed to "
"WorldCoordinatesToParametricCoordinates(pointWCoords, wcoords, shape, result).")
static inline VTKM_EXEC typename WorldCoordVector::ComponentType
WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType& wcoords,
CellShapeTag shape,
bool& success,
const vtkm::exec::FunctorBase& worklet)
{
typename WorldCoordVector::ComponentType result;
vtkm::ErrorCode status =
WorldCoordinatesToParametricCoordinates(pointWCoords, wcoords, shape, result);
if (status != vtkm::ErrorCode::Success)
{
success = false;
worklet.RaiseError(vtkm::ErrorString(status));
}
else
{
success = true;
}
return result;
}
}

34
vtkm/exec/testing/UnitTestCellDerivative.cxx
View File

@ -22,6 +22,9 @@
#include <ctime>
#include <random>
#define CHECK_CALL(call) \
VTKM_TEST_ASSERT((call) == vtkm::ErrorCode::Success, "Call resulted in error.")
namespace
{
@ -91,13 +94,6 @@ struct TestDerivativeFunctor
LinearField<FieldType> field,
vtkm::Vec<FieldType, 3> expectedGradient) const
{
// Stuff to fake running in the execution environment.
char messageBuffer[256];
messageBuffer[0] = '\0';
vtkm::exec::internal::ErrorMessageBuffer errorMessage(messageBuffer, 256);
vtkm::exec::FunctorBase workletProxy;
workletProxy.SetErrorMessageBuffer(errorMessage);
vtkm::IdComponent numPoints = worldCoordinates.GetNumberOfComponents();
vtkm::VecVariable<FieldType, MAX_POINTS> fieldValues;
@ -119,9 +115,9 @@ struct TestDerivativeFunctor
vtkm::FloatDefault totalWeight = 0;
for (vtkm::IdComponent pointIndex = 0; pointIndex < numPoints; pointIndex++)
{
vtkm::Vec3f pointPcoords =
vtkm::exec::ParametricCoordinatesPoint(numPoints, pointIndex, shape, workletProxy);
VTKM_TEST_ASSERT(!errorMessage.IsErrorRaised(), messageBuffer);
vtkm::Vec3f pointPcoords;
CHECK_CALL(
vtkm::exec::ParametricCoordinatesPoint(numPoints, pointIndex, shape, pointPcoords));
vtkm::FloatDefault weight = randomDist(g_RandomGenerator);
pcoords = pcoords + weight * pointPcoords;
totalWeight += weight;
@ -130,9 +126,9 @@ struct TestDerivativeFunctor
std::cout << " Test derivative at " << pcoords << std::endl;
vtkm::Vec<FieldType, 3> computedGradient =
vtkm::exec::CellDerivative(fieldValues, worldCoordinates, pcoords, shape, workletProxy);
VTKM_TEST_ASSERT(!errorMessage.IsErrorRaised(), messageBuffer);
vtkm::Vec<FieldType, 3> computedGradient;
CHECK_CALL(vtkm::exec::CellDerivative(
fieldValues, worldCoordinates, pcoords, shape, computedGradient));
std::cout << " Computed: " << computedGradient << std::endl;
// Note that some gradients (particularly those near the center of
@ -149,19 +145,11 @@ struct TestDerivativeFunctor
LinearField<FieldType> field,
vtkm::Vec<FieldType, 3> expectedGradient) const
{
// Stuff to fake running in the execution environment.
char messageBuffer[256];
messageBuffer[0] = '\0';
vtkm::exec::internal::ErrorMessageBuffer errorMessage(messageBuffer, 256);
vtkm::exec::FunctorBase workletProxy;
workletProxy.SetErrorMessageBuffer(errorMessage);
vtkm::VecVariable<vtkm::Vec3f, MAX_POINTS> worldCoordinates;
for (vtkm::IdComponent pointIndex = 0; pointIndex < numPoints; pointIndex++)
{
vtkm::Vec3f pcoords =
vtkm::exec::ParametricCoordinatesPoint(numPoints, pointIndex, shape, workletProxy);
VTKM_TEST_ASSERT(!errorMessage.IsErrorRaised(), messageBuffer);
vtkm::Vec3f pcoords;
CHECK_CALL(vtkm::exec::ParametricCoordinatesPoint(numPoints, pointIndex, shape, pcoords));
vtkm::Vec3f wcoords = ParametricToWorld(pcoords);
VTKM_TEST_ASSERT(test_equal(pcoords, WorldToParametric(wcoords)),
"Test world/parametric conversion broken.");

85
vtkm/exec/testing/UnitTestCellEdgeFace.cxx
View File

@ -21,6 +21,9 @@
#include <set>
#include <vector>
#define CHECK_CALL(call) \
VTKM_TEST_ASSERT((call) == vtkm::ErrorCode::Success, "Call resulted in error.")
namespace
{
@ -41,13 +44,6 @@ struct TestCellFacesFunctor
CellShapeTag shape,
vtkm::CellTopologicalDimensionsTag<3>) const
{
// Stuff to fake running in the execution environment.
char messageBuffer[256];
messageBuffer[0] = '\0';
vtkm::exec::internal::ErrorMessageBuffer errorMessage(messageBuffer, 256);
vtkm::exec::FunctorBase workletProxy;
workletProxy.SetErrorMessageBuffer(errorMessage);
std::vector<vtkm::Id> pointIndexProxyBuffer(static_cast<std::size_t>(numPoints));
for (std::size_t index = 0; index < pointIndexProxyBuffer.size(); ++index)
{
@ -55,14 +51,16 @@ struct TestCellFacesFunctor
}
vtkm::VecCConst<vtkm::Id> pointIndexProxy(&pointIndexProxyBuffer.at(0), numPoints);
vtkm::IdComponent numEdges = vtkm::exec::CellEdgeNumberOfEdges(numPoints, shape, workletProxy);
vtkm::IdComponent numEdges;
CHECK_CALL(vtkm::exec::CellEdgeNumberOfEdges(numPoints, shape, numEdges));
VTKM_TEST_ASSERT(numEdges > 0, "No edges?");
std::set<EdgeType> edgeSet;
for (vtkm::IdComponent edgeIndex = 0; edgeIndex < numEdges; edgeIndex++)
{
EdgeType edge(vtkm::exec::CellEdgeLocalIndex(numPoints, 0, edgeIndex, shape, workletProxy),
vtkm::exec::CellEdgeLocalIndex(numPoints, 1, edgeIndex, shape, workletProxy));
EdgeType edge;
CHECK_CALL(vtkm::exec::CellEdgeLocalIndex(numPoints, 0, edgeIndex, shape, edge[0]));
CHECK_CALL(vtkm::exec::CellEdgeLocalIndex(numPoints, 1, edgeIndex, shape, edge[1]));
VTKM_TEST_ASSERT(edge[0] >= 0, "Bad index in edge.");
VTKM_TEST_ASSERT(edge[0] < numPoints, "Bad index in edge.");
VTKM_TEST_ASSERT(edge[1] >= 0, "Bad index in edge.");
@ -73,49 +71,50 @@ struct TestCellFacesFunctor
VTKM_TEST_ASSERT(edgeSet.find(edge) == edgeSet.end(), "Found duplicate edge");
edgeSet.insert(edge);
vtkm::Id2 canonicalEdgeId =
vtkm::exec::CellEdgeCanonicalId(numPoints, edgeIndex, shape, pointIndexProxy, workletProxy);
vtkm::Id2 canonicalEdgeId;
CHECK_CALL(vtkm::exec::CellEdgeCanonicalId(
numPoints, edgeIndex, shape, pointIndexProxy, canonicalEdgeId));
VTKM_TEST_ASSERT(canonicalEdgeId[0] > 0, "Not using global ids?");
VTKM_TEST_ASSERT(canonicalEdgeId[0] < canonicalEdgeId[1], "Bad order.");
}
vtkm::IdComponent numFaces = vtkm::exec::CellFaceNumberOfFaces(shape, workletProxy);
vtkm::IdComponent numFaces;
CHECK_CALL(vtkm::exec::CellFaceNumberOfFaces(shape, numFaces));
VTKM_TEST_ASSERT(numFaces > 0, "No faces?");
std::set<EdgeType> edgesFoundInFaces;
for (vtkm::IdComponent faceIndex = 0; faceIndex < numFaces; faceIndex++)
{
const vtkm::IdComponent numPointsInFace =
vtkm::exec::CellFaceNumberOfPoints(faceIndex, shape, workletProxy);
vtkm::IdComponent numPointsInFace;
CHECK_CALL(vtkm::exec::CellFaceNumberOfPoints(faceIndex, shape, numPointsInFace));
VTKM_TEST_ASSERT(numPointsInFace >= 3, "Face has fewer points than a triangle.");
for (vtkm::IdComponent pointIndex = 0; pointIndex < numPointsInFace; pointIndex++)
{
vtkm::IdComponent localFaceIndex =
vtkm::exec::CellFaceLocalIndex(pointIndex, faceIndex, shape, workletProxy);
vtkm::IdComponent localFaceIndex;
CHECK_CALL(vtkm::exec::CellFaceLocalIndex(pointIndex, faceIndex, shape, localFaceIndex));
VTKM_TEST_ASSERT(localFaceIndex >= 0, "Invalid point index for face.");
VTKM_TEST_ASSERT(localFaceIndex < numPoints, "Invalid point index for face.");
EdgeType edge;
if (pointIndex < numPointsInFace - 1)
{
edge = EdgeType(
vtkm::exec::CellFaceLocalIndex(pointIndex, faceIndex, shape, workletProxy),
vtkm::exec::CellFaceLocalIndex(pointIndex + 1, faceIndex, shape, workletProxy));
CHECK_CALL(vtkm::exec::CellFaceLocalIndex(pointIndex, faceIndex, shape, edge[0]));
CHECK_CALL(vtkm::exec::CellFaceLocalIndex(pointIndex + 1, faceIndex, shape, edge[1]));
}
else
{
edge =
EdgeType(vtkm::exec::CellFaceLocalIndex(0, faceIndex, shape, workletProxy),
vtkm::exec::CellFaceLocalIndex(pointIndex, faceIndex, shape, workletProxy));
CHECK_CALL(vtkm::exec::CellFaceLocalIndex(0, faceIndex, shape, edge[0]));
CHECK_CALL(vtkm::exec::CellFaceLocalIndex(pointIndex, faceIndex, shape, edge[1]));
}
MakeEdgeCanonical(edge);
VTKM_TEST_ASSERT(edgeSet.find(edge) != edgeSet.end(), "Edge in face not in cell's edges");
edgesFoundInFaces.insert(edge);
}
vtkm::Id3 canonicalFaceId =
vtkm::exec::CellFaceCanonicalId(faceIndex, shape, pointIndexProxy, workletProxy);
vtkm::Id3 canonicalFaceId;
CHECK_CALL(
vtkm::exec::CellFaceCanonicalId(faceIndex, shape, pointIndexProxy, canonicalFaceId));
VTKM_TEST_ASSERT(canonicalFaceId[0] > 0, "Not using global ids?");
VTKM_TEST_ASSERT(canonicalFaceId[0] < canonicalFaceId[1], "Bad order.");
VTKM_TEST_ASSERT(canonicalFaceId[1] < canonicalFaceId[2], "Bad order.");
@ -130,13 +129,6 @@ struct TestCellFacesFunctor
CellShapeTag shape,
vtkm::CellTopologicalDimensionsTag<2>) const
{
// Stuff to fake running in the execution environment.
char messageBuffer[256];
messageBuffer[0] = '\0';
vtkm::exec::internal::ErrorMessageBuffer errorMessage(messageBuffer, 256);
vtkm::exec::FunctorBase workletProxy;
workletProxy.SetErrorMessageBuffer(errorMessage);
std::vector<vtkm::Id> pointIndexProxyBuffer(static_cast<std::size_t>(numPoints));
for (std::size_t index = 0; index < pointIndexProxyBuffer.size(); ++index)
{
@ -144,14 +136,16 @@ struct TestCellFacesFunctor
}
vtkm::VecCConst<vtkm::Id> pointIndexProxy(&pointIndexProxyBuffer.at(0), numPoints);
vtkm::IdComponent numEdges = vtkm::exec::CellEdgeNumberOfEdges(numPoints, shape, workletProxy);
vtkm::IdComponent numEdges;
CHECK_CALL(vtkm::exec::CellEdgeNumberOfEdges(numPoints, shape, numEdges));
VTKM_TEST_ASSERT(numEdges == numPoints, "Polygons should have same number of points and edges");
std::set<EdgeType> edgeSet;
for (vtkm::IdComponent edgeIndex = 0; edgeIndex < numEdges; edgeIndex++)
{
EdgeType edge(vtkm::exec::CellEdgeLocalIndex(numPoints, 0, edgeIndex, shape, workletProxy),
vtkm::exec::CellEdgeLocalIndex(numPoints, 1, edgeIndex, shape, workletProxy));
EdgeType edge;
CHECK_CALL(vtkm::exec::CellEdgeLocalIndex(numPoints, 0, edgeIndex, shape, edge[0]));
CHECK_CALL(vtkm::exec::CellEdgeLocalIndex(numPoints, 1, edgeIndex, shape, edge[1]));
VTKM_TEST_ASSERT(edge[0] >= 0, "Bad index in edge.");
VTKM_TEST_ASSERT(edge[0] < numPoints, "Bad index in edge.");
VTKM_TEST_ASSERT(edge[1] >= 0, "Bad index in edge.");
@ -162,13 +156,15 @@ struct TestCellFacesFunctor
VTKM_TEST_ASSERT(edgeSet.find(edge) == edgeSet.end(), "Found duplicate edge");
edgeSet.insert(edge);
vtkm::Id2 canonicalEdgeId =
vtkm::exec::CellEdgeCanonicalId(numPoints, edgeIndex, shape, pointIndexProxy, workletProxy);
vtkm::Id2 canonicalEdgeId;
CHECK_CALL(vtkm::exec::CellEdgeCanonicalId(
numPoints, edgeIndex, shape, pointIndexProxy, canonicalEdgeId));
VTKM_TEST_ASSERT(canonicalEdgeId[0] > 0, "Not using global ids?");
VTKM_TEST_ASSERT(canonicalEdgeId[0] < canonicalEdgeId[1], "Bad order.");
}
vtkm::IdComponent numFaces = vtkm::exec::CellFaceNumberOfFaces(shape, workletProxy);
vtkm::IdComponent numFaces;
CHECK_CALL(vtkm::exec::CellFaceNumberOfFaces(shape, numFaces));
VTKM_TEST_ASSERT(numFaces == 0, "Non 3D shape should have no faces");
}
@ -179,17 +175,12 @@ struct TestCellFacesFunctor
CellShapeTag shape,
vtkm::CellTopologicalDimensionsTag<NumDimensions>) const
{
// Stuff to fake running in the execution environment.
char messageBuffer[256];
messageBuffer[0] = '\0';
vtkm::exec::internal::ErrorMessageBuffer errorMessage(messageBuffer, 256);
vtkm::exec::FunctorBase workletProxy;
workletProxy.SetErrorMessageBuffer(errorMessage);
vtkm::IdComponent numEdges = vtkm::exec::CellEdgeNumberOfEdges(numPoints, shape, workletProxy);
vtkm::IdComponent numEdges;
CHECK_CALL(vtkm::exec::CellEdgeNumberOfEdges(numPoints, shape, numEdges));
VTKM_TEST_ASSERT(numEdges == 0, "0D or 1D shape should have no edges");
vtkm::IdComponent numFaces = vtkm::exec::CellFaceNumberOfFaces(shape, workletProxy);
vtkm::IdComponent numFaces;
CHECK_CALL(vtkm::exec::CellFaceNumberOfFaces(shape, numFaces));
VTKM_TEST_ASSERT(numFaces == 0, "Non 3D shape should have no faces");
}

29
vtkm/exec/testing/UnitTestCellInterpolate.cxx
View File

@ -20,6 +20,9 @@
#include <vtkm/testing/Testing.h>
#define CHECK_CALL(call) \
VTKM_TEST_ASSERT((call) == vtkm::ErrorCode::Success, "Call resulted in error.")
namespace
{
@ -63,22 +66,13 @@ struct TestInterpolateFunctor
}
averageValue = static_cast<ComponentType>(1.0 / numPoints) * averageValue;
// Stuff to fake running in the execution environment.
char messageBuffer[256];
messageBuffer[0] = '\0';
vtkm::exec::internal::ErrorMessageBuffer errorMessage(messageBuffer, 256);
vtkm::exec::FunctorBase workletProxy;
workletProxy.SetErrorMessageBuffer(errorMessage);
std::cout << " Test interpolated value at each cell node." << std::endl;
for (vtkm::IdComponent pointIndex = 0; pointIndex < numPoints; pointIndex++)
{
vtkm::Vec3f pcoord =
vtkm::exec::ParametricCoordinatesPoint(numPoints, pointIndex, shape, workletProxy);
VTKM_TEST_ASSERT(!errorMessage.IsErrorRaised(), messageBuffer);
FieldType interpolatedValue =
vtkm::exec::CellInterpolate(fieldValues, pcoord, shape, workletProxy);
VTKM_TEST_ASSERT(!errorMessage.IsErrorRaised(), messageBuffer);
vtkm::Vec3f pcoord;
CHECK_CALL(vtkm::exec::ParametricCoordinatesPoint(numPoints, pointIndex, shape, pcoord));
FieldType interpolatedValue;
CHECK_CALL(vtkm::exec::CellInterpolate(fieldValues, pcoord, shape, interpolatedValue));
VTKM_TEST_ASSERT(test_equal(fieldValues[pointIndex], interpolatedValue),
"Interpolation at point not point value.");
@ -87,11 +81,10 @@ struct TestInterpolateFunctor
if (numPoints > 0)
{
std::cout << " Test interpolated value at cell center." << std::endl;
vtkm::Vec3f pcoord = vtkm::exec::ParametricCoordinatesCenter(numPoints, shape, workletProxy);
VTKM_TEST_ASSERT(!errorMessage.IsErrorRaised(), messageBuffer);
FieldType interpolatedValue =
vtkm::exec::CellInterpolate(fieldValues, pcoord, shape, workletProxy);
VTKM_TEST_ASSERT(!errorMessage.IsErrorRaised(), messageBuffer);
vtkm::Vec3f pcoord;
CHECK_CALL(vtkm::exec::ParametricCoordinatesCenter(numPoints, shape, pcoord));
FieldType interpolatedValue;
CHECK_CALL(vtkm::exec::CellInterpolate(fieldValues, pcoord, shape, interpolatedValue));
std::cout << "AVG= " << averageValue << " interp= " << interpolatedValue << std::endl;
VTKM_TEST_ASSERT(test_equal(averageValue, interpolatedValue),

73
vtkm/exec/testing/UnitTestParametricCoordinates.cxx
View File

@ -20,6 +20,9 @@
#include <ctime>
#include <random>
#define CHECK_CALL(call) \
VTKM_TEST_ASSERT((call) == vtkm::ErrorCode::Success, "Call resulted in error.")
namespace
{
@ -57,23 +60,15 @@ static void CompareCoordinates(const PointWCoordsType& pointWCoords,
{
using Vector3 = vtkm::Vec<T, 3>;
// Stuff to fake running in the execution environment.
char messageBuffer[256];
messageBuffer[0] = '\0';
vtkm::exec::internal::ErrorMessageBuffer errorMessage(messageBuffer, 256);
vtkm::exec::FunctorBase workletProxy;
workletProxy.SetErrorMessageBuffer(errorMessage);
Vector3 computedWCoords = vtkm::exec::ParametricCoordinatesToWorldCoordinates(
pointWCoords, truePCoords, shape, workletProxy);
VTKM_TEST_ASSERT(!errorMessage.IsErrorRaised(), messageBuffer);
Vector3 computedWCoords;
CHECK_CALL(vtkm::exec::ParametricCoordinatesToWorldCoordinates(
pointWCoords, truePCoords, shape, computedWCoords));
VTKM_TEST_ASSERT(test_equal(computedWCoords, trueWCoords, 0.01),
"Computed wrong world coords from parametric coords.");
bool success = false;
Vector3 computedPCoords = vtkm::exec::WorldCoordinatesToParametricCoordinates(
pointWCoords, trueWCoords, shape, success, workletProxy);
VTKM_TEST_ASSERT(!errorMessage.IsErrorRaised(), messageBuffer);
Vector3 computedPCoords;
CHECK_CALL(vtkm::exec::WorldCoordinatesToParametricCoordinates(
pointWCoords, trueWCoords, shape, computedPCoords));
VTKM_TEST_ASSERT(test_equal(computedPCoords, truePCoords, 0.01),
"Computed wrong parametric coords from world coords.");
}
@ -84,21 +79,13 @@ void TestPCoordsSpecial(const PointWCoordsType& pointWCoords, CellShapeTag shape
using Vector3 = typename PointWCoordsType::ComponentType;
using T = typename Vector3::ComponentType;
// Stuff to fake running in the execution environment.
char messageBuffer[256];
messageBuffer[0] = '\0';
vtkm::exec::internal::ErrorMessageBuffer errorMessage(messageBuffer, 256);
vtkm::exec::FunctorBase workletProxy;
workletProxy.SetErrorMessageBuffer(errorMessage);
const vtkm::IdComponent numPoints = pointWCoords.GetNumberOfComponents();
std::cout << " Test parametric coordinates at cell nodes." << std::endl;
for (vtkm::IdComponent pointIndex = 0; pointIndex < numPoints; pointIndex++)
{
Vector3 pcoords;
vtkm::exec::ParametricCoordinatesPoint(numPoints, pointIndex, pcoords, shape, workletProxy);
VTKM_TEST_ASSERT(!errorMessage.IsErrorRaised(), messageBuffer);
CHECK_CALL(vtkm::exec::ParametricCoordinatesPoint(numPoints, pointIndex, shape, pcoords));
Vector3 wcoords = pointWCoords[pointIndex];
CompareCoordinates(pointWCoords, pcoords, wcoords, shape);
}
@ -113,7 +100,7 @@ void TestPCoordsSpecial(const PointWCoordsType& pointWCoords, CellShapeTag shape
wcoords = wcoords / Vector3(T(numPoints));
Vector3 pcoords;
vtkm::exec::ParametricCoordinatesCenter(numPoints, pcoords, shape, workletProxy);
CHECK_CALL(vtkm::exec::ParametricCoordinatesCenter(numPoints, shape, pcoords));
CompareCoordinates(pointWCoords, pcoords, wcoords, shape);
}
}
@ -123,13 +110,6 @@ void TestPCoordsSample(const PointWCoordsType& pointWCoords, CellShapeTag shape)
{
using Vector3 = typename PointWCoordsType::ComponentType;
// Stuff to fake running in the execution environment.
char messageBuffer[256];
messageBuffer[0] = '\0';
vtkm::exec::internal::ErrorMessageBuffer errorMessage(messageBuffer, 256);
vtkm::exec::FunctorBase workletProxy;
workletProxy.SetErrorMessageBuffer(errorMessage);
const vtkm::IdComponent numPoints = pointWCoords.GetNumberOfComponents();
std::uniform_real_distribution<vtkm::FloatDefault> randomDist;
@ -141,9 +121,9 @@ void TestPCoordsSample(const PointWCoordsType& pointWCoords, CellShapeTag shape)
vtkm::FloatDefault totalWeight = 0;
for (vtkm::IdComponent pointIndex = 0; pointIndex < numPoints; pointIndex++)
{
vtkm::Vec3f pointPcoords =
vtkm::exec::ParametricCoordinatesPoint(numPoints, pointIndex, shape, workletProxy);
VTKM_TEST_ASSERT(!errorMessage.IsErrorRaised(), messageBuffer);
vtkm::Vec3f pointPcoords;
CHECK_CALL(
vtkm::exec::ParametricCoordinatesPoint(numPoints, pointIndex, shape, pointPcoords));
vtkm::FloatDefault weight = randomDist(g_RandomGenerator);
pcoords = pcoords + weight * pointPcoords;
totalWeight += weight;
@ -154,13 +134,12 @@ void TestPCoordsSample(const PointWCoordsType& pointWCoords, CellShapeTag shape)
// If you convert to world coordinates and back, you should get the
// same value.
Vector3 wcoords = vtkm::exec::ParametricCoordinatesToWorldCoordinates(
pointWCoords, pcoords, shape, workletProxy);
VTKM_TEST_ASSERT(!errorMessage.IsErrorRaised(), messageBuffer);
bool success = false;
Vector3 computedPCoords = vtkm::exec::WorldCoordinatesToParametricCoordinates(
pointWCoords, wcoords, shape, success, workletProxy);
VTKM_TEST_ASSERT(!errorMessage.IsErrorRaised(), messageBuffer);
Vector3 wcoords;
CHECK_CALL(
vtkm::exec::ParametricCoordinatesToWorldCoordinates(pointWCoords, pcoords, shape, wcoords));
Vector3 computedPCoords;
CHECK_CALL(vtkm::exec::WorldCoordinatesToParametricCoordinates(
pointWCoords, wcoords, shape, computedPCoords));
VTKM_TEST_ASSERT(test_equal(pcoords, computedPCoords, 0.05),
"pcoord/wcoord transform not symmetrical");
@ -183,13 +162,6 @@ struct TestPCoordsFunctor
template <typename CellShapeTag>
PointWCoordType MakePointWCoords(CellShapeTag, vtkm::IdComponent numPoints) const
{
// Stuff to fake running in the execution environment.
char messageBuffer[256];
messageBuffer[0] = '\0';
vtkm::exec::internal::ErrorMessageBuffer errorMessage(messageBuffer, 256);
vtkm::exec::FunctorBase workletProxy;
workletProxy.SetErrorMessageBuffer(errorMessage);
std::uniform_real_distribution<T> randomDist(-1, 1);
Vector3 sheerVec(randomDist(g_RandomGenerator), randomDist(g_RandomGenerator), 0);
@ -198,9 +170,8 @@ struct TestPCoordsFunctor
for (vtkm::IdComponent pointIndex = 0; pointIndex < numPoints; pointIndex++)
{
Vector3 pcoords;
vtkm::exec::ParametricCoordinatesPoint(
numPoints, pointIndex, pcoords, CellShapeTag(), workletProxy);
VTKM_TEST_ASSERT(!errorMessage.IsErrorRaised(), messageBuffer);
CHECK_CALL(
vtkm::exec::ParametricCoordinatesPoint(numPoints, pointIndex, CellShapeTag(), pcoords));
Vector3 wCoords = Vector3(pcoords[0], pcoords[1], pcoords[2] + vtkm::Dot(pcoords, sheerVec));
pointWCoords.Append(wCoords);

15
vtkm/rendering/MapperWireframer.cxx
View File

@ -115,7 +115,9 @@ struct EdgesCounter : public vtkm::worklet::WorkletVisitCellsWithPoints
}
else
{
return vtkm::exec::CellEdgeNumberOfEdges(numPoints, shape, *this);
vtkm::IdComponent numEdges;
vtkm::exec::CellEdgeNumberOfEdges(numPoints, shape, numEdges);
return numEdges;
}
}
}; // struct EdgesCounter
@ -149,10 +151,13 @@ struct EdgesExtracter : public vtkm::worklet::WorkletVisitCellsWithPoints
}
else
{
p1 = pointIndices[vtkm::exec::CellEdgeLocalIndex(
pointIndices.GetNumberOfComponents(), 0, visitIndex, shape, *this)];
p2 = pointIndices[vtkm::exec::CellEdgeLocalIndex(
pointIndices.GetNumberOfComponents(), 1, visitIndex, shape, *this)];
vtkm::IdComponent localEdgeIndex;
vtkm::exec::CellEdgeLocalIndex(
pointIndices.GetNumberOfComponents(), 0, visitIndex, shape, localEdgeIndex);
p1 = pointIndices[localEdgeIndex];
vtkm::exec::CellEdgeLocalIndex(
pointIndices.GetNumberOfComponents(), 1, visitIndex, shape, localEdgeIndex);
p2 = pointIndices[localEdgeIndex];
}
// These indices need to be arranged in a definite order, as they will later be sorted to
// detect duplicates

87
vtkm/rendering/raytracing/CellSampler.h
View File

@ -62,12 +62,11 @@ VTKM_EXEC_CONT inline vtkm::Int32 GetNumberOfPoints<vtkm::CellShapeTagPyramid>(
return 5;
}
template <typename P, typename S, typename WorkletType, typename CellShapeTagType>
template <typename P, typename S, typename CellShapeTagType>
VTKM_EXEC_CONT inline bool Sample(const vtkm::Vec<vtkm::Vec<P, 3>, 8>& points,
const vtkm::Vec<S, 8>& scalars,
const vtkm::Vec<P, 3>& sampleLocation,
S& lerpedScalar,
const WorkletType& callingWorklet,
const CellShapeTagType& shapeTag)
{
@ -79,9 +78,8 @@ VTKM_EXEC_CONT inline bool Sample(const vtkm::Vec<vtkm::Vec<P, 3>, 8>& points,
pointsVec.Append(points[i]);
scalarVec.Append(scalars[i]);
}
bool success = false; // ignored
vtkm::Vec<P, 3> pcoords = vtkm::exec::WorldCoordinatesToParametricCoordinates(
pointsVec, sampleLocation, shapeTag, success, callingWorklet);
vtkm::Vec<P, 3> pcoords;
vtkm::exec::WorldCoordinatesToParametricCoordinates(pointsVec, sampleLocation, shapeTag, pcoords);
P pmin, pmax;
pmin = vtkm::Min(vtkm::Min(pcoords[0], pcoords[1]), pcoords[2]);
pmax = vtkm::Max(vtkm::Max(pcoords[0], pcoords[1]), pcoords[2]);
@ -89,23 +87,22 @@ VTKM_EXEC_CONT inline bool Sample(const vtkm::Vec<vtkm::Vec<P, 3>, 8>& points,
{
validSample = false;
}
lerpedScalar = vtkm::exec::CellInterpolate(scalarVec, pcoords, shapeTag, callingWorklet);
vtkm::exec::CellInterpolate(scalarVec, pcoords, shapeTag, lerpedScalar);
return validSample;
}
template <typename S, typename P, typename WorkletType, typename CellShapeTagType>
template <typename S, typename P, typename CellShapeTagType>
VTKM_EXEC_CONT inline bool Sample(const vtkm::VecAxisAlignedPointCoordinates<3>& points,
const vtkm::Vec<S, 8>& scalars,
const vtkm::Vec<P, 3>& sampleLocation,
S& lerpedScalar,
const WorkletType& callingWorklet,
const CellShapeTagType& vtkmNotUsed(shapeTag))
{
bool validSample = true;
bool success;
vtkm::Vec<P, 3> pcoords = vtkm::exec::WorldCoordinatesToParametricCoordinates(
points, sampleLocation, vtkm::CellShapeTagHexahedron(), success, callingWorklet);
vtkm::Vec<P, 3> pcoords;
vtkm::exec::WorldCoordinatesToParametricCoordinates(
points, sampleLocation, vtkm::CellShapeTagHexahedron(), pcoords);
P pmin, pmax;
pmin = vtkm::Min(vtkm::Min(pcoords[0], pcoords[1]), pcoords[2]);
pmax = vtkm::Max(vtkm::Max(pcoords[0], pcoords[1]), pcoords[2]);
@ -113,8 +110,7 @@ VTKM_EXEC_CONT inline bool Sample(const vtkm::VecAxisAlignedPointCoordinates<3>&
{
validSample = false;
}
lerpedScalar =
vtkm::exec::CellInterpolate(scalars, pcoords, vtkm::CellShapeTagHexahedron(), callingWorklet);
vtkm::exec::CellInterpolate(scalars, pcoords, vtkm::CellShapeTagHexahedron(), lerpedScalar);
return validSample;
}
} // namespace detail
@ -126,12 +122,11 @@ template <int CellType>
class CellSampler
{
public:
template <typename P, typename S, typename WorkletType>
template <typename P, typename S>
VTKM_EXEC_CONT inline bool SampleCell(const vtkm::Vec<vtkm::Vec<P, 3>, 8>& vtkmNotUsed(points),
const vtkm::Vec<S, 8>& vtkmNotUsed(scalars),
const vtkm::Vec<P, 3>& vtkmNotUsed(sampleLocation),
S& vtkmNotUsed(lerpedScalar),
const WorkletType& vtkmNotUsed(callingWorklet),
const vtkm::Int32& vtkmNotUsed(cellShape = CellType)) const
{
static_assert(CellType != CELL_SHAPE_ZOO && CellType != CELL_SHAPE_STRUCTURED &&
@ -149,40 +144,35 @@ template <>
class CellSampler<255>
{
public:
template <typename P, typename S, typename WorkletType>
template <typename P, typename S>
VTKM_EXEC_CONT inline bool SampleCell(const vtkm::Vec<vtkm::Vec<P, 3>, 8>& points,
const vtkm::Vec<S, 8>& scalars,
const vtkm::Vec<P, 3>& sampleLocation,
S& lerpedScalar,
const WorkletType& callingWorklet,
const vtkm::Int32& cellShape) const
{
bool valid = false;
if (cellShape == CELL_SHAPE_HEXAHEDRON)
{
valid = detail::Sample(points,
scalars,
sampleLocation,
lerpedScalar,
callingWorklet,
vtkm::CellShapeTagHexahedron());
valid = detail::Sample(
points, scalars, sampleLocation, lerpedScalar, vtkm::CellShapeTagHexahedron());
}
if (cellShape == CELL_SHAPE_TETRA)
{
valid = detail::Sample(
points, scalars, sampleLocation, lerpedScalar, callingWorklet, vtkm::CellShapeTagTetra());
valid =
detail::Sample(points, scalars, sampleLocation, lerpedScalar, vtkm::CellShapeTagTetra());
}
if (cellShape == CELL_SHAPE_WEDGE)
{
valid = detail::Sample(
points, scalars, sampleLocation, lerpedScalar, callingWorklet, vtkm::CellShapeTagWedge());
valid =
detail::Sample(points, scalars, sampleLocation, lerpedScalar, vtkm::CellShapeTagWedge());
}
if (cellShape == CELL_SHAPE_PYRAMID)
{
valid = detail::Sample(
points, scalars, sampleLocation, lerpedScalar, callingWorklet, vtkm::CellShapeTagPyramid());
valid =
detail::Sample(points, scalars, sampleLocation, lerpedScalar, vtkm::CellShapeTagPyramid());
}
return valid;
}
@ -195,21 +185,16 @@ template <>
class CellSampler<CELL_SHAPE_HEXAHEDRON>
{
public:
template <typename P, typename S, typename WorkletType>
template <typename P, typename S>
VTKM_EXEC_CONT inline bool SampleCell(
const vtkm::Vec<vtkm::Vec<P, 3>, 8>& points,
const vtkm::Vec<S, 8>& scalars,
const vtkm::Vec<P, 3>& sampleLocation,
S& lerpedScalar,
const WorkletType& callingWorklet,
const vtkm::Int32& vtkmNotUsed(cellShape = CELL_SHAPE_HEXAHEDRON)) const
{
return detail::Sample(points,
scalars,
sampleLocation,
lerpedScalar,
callingWorklet,
vtkm::CellShapeTagHexahedron());
return detail::Sample(
points, scalars, sampleLocation, lerpedScalar, vtkm::CellShapeTagHexahedron());
}
};
@ -221,22 +206,17 @@ template <>
class CellSampler<CELL_SHAPE_STRUCTURED>
{
public:
template <typename P, typename S, typename WorkletType>
template <typename P, typename S>
VTKM_EXEC_CONT inline bool SampleCell(
const vtkm::Vec<vtkm::Vec<P, 3>, 8>& points,
const vtkm::Vec<S, 8>& scalars,
const vtkm::Vec<P, 3>& sampleLocation,
S& lerpedScalar,
const WorkletType& callingWorklet,
const vtkm::Int32& vtkmNotUsed(cellShape = CELL_SHAPE_HEXAHEDRON)) const
{
vtkm::VecAxisAlignedPointCoordinates<3> rPoints(points[0], points[6] - points[0]);
return detail::Sample(rPoints,
scalars,
sampleLocation,
lerpedScalar,
callingWorklet,
vtkm::CellShapeTagHexahedron());
return detail::Sample(
rPoints, scalars, sampleLocation, lerpedScalar, vtkm::CellShapeTagHexahedron());
}
};
@ -247,17 +227,16 @@ template <>
class CellSampler<CELL_SHAPE_PYRAMID>
{
public:
template <typename P, typename S, typename WorkletType>
template <typename P, typename S>
VTKM_EXEC_CONT inline bool SampleCell(
const vtkm::Vec<vtkm::Vec<P, 3>, 8>& points,
const vtkm::Vec<S, 8>& scalars,
const vtkm::Vec<P, 3>& sampleLocation,
S& lerpedScalar,
const WorkletType& callingWorklet,
const vtkm::Int32& vtkmNotUsed(cellShape = CELL_SHAPE_PYRAMID)) const
{
return detail::Sample(
points, scalars, sampleLocation, lerpedScalar, callingWorklet, vtkm::CellShapeTagPyramid());
points, scalars, sampleLocation, lerpedScalar, vtkm::CellShapeTagPyramid());
}
};
@ -269,17 +248,15 @@ template <>
class CellSampler<CELL_SHAPE_TETRA>
{
public:
template <typename P, typename S, typename WorkletType>
template <typename P, typename S>
VTKM_EXEC_CONT inline bool SampleCell(
const vtkm::Vec<vtkm::Vec<P, 3>, 8>& points,
const vtkm::Vec<S, 8>& scalars,
const vtkm::Vec<P, 3>& sampleLocation,
S& lerpedScalar,
const WorkletType& callingWorklet,
const vtkm::Int32& vtkmNotUsed(cellShape = CELL_SHAPE_TETRA)) const
{
return detail::Sample(
points, scalars, sampleLocation, lerpedScalar, callingWorklet, vtkm::CellShapeTagTetra());
return detail::Sample(points, scalars, sampleLocation, lerpedScalar, vtkm::CellShapeTagTetra());
}
};
@ -290,17 +267,15 @@ template <>
class CellSampler<CELL_SHAPE_WEDGE>
{
public:
template <typename P, typename S, typename WorkletType>
template <typename P, typename S>
VTKM_EXEC_CONT inline bool SampleCell(
const vtkm::Vec<vtkm::Vec<P, 3>, 8>& points,
const vtkm::Vec<S, 8>& scalars,
const vtkm::Vec<P, 3>& sampleLocation,
S& lerpedScalar,
const WorkletType& callingWorklet,
const vtkm::Int32& vtkmNotUsed(cellShape = CELL_SHAPE_WEDGE)) const
{
return detail::Sample(
points, scalars, sampleLocation, lerpedScalar, callingWorklet, vtkm::CellShapeTagWedge());
return detail::Sample(points, scalars, sampleLocation, lerpedScalar, vtkm::CellShapeTagWedge());
}
};
}

9
vtkm/rendering/raytracing/ConnectivityTracer.cxx
View File

@ -520,8 +520,6 @@ public:
vtkm::Id cellId = currentCell;
vtkm::exec::FunctorBase fake_functor;
while (!valid_cell)
{
// push forward and look for a new cell
@ -530,8 +528,7 @@ public:
query_distance += bumpDistance;
vtkm::Vec<FloatType, 3> location = origin + rdir * (query_distance);
vtkm::Vec<vtkm::FloatDefault, 3> pcoords;
locator->FindCell(location, cellId, pcoords, fake_functor);
locator->FindCell(location, cellId, pcoords);
}
currentCell = cellId;
@ -1090,13 +1087,11 @@ public:
const vtkm::Id colorMapSize = colorMap.GetNumberOfValues();
const vtkm::Int32 cellShape = meshConn.GetCellShape(currentCell);
vtkm::exec::FunctorBase fake_functor;
while (enterDistance <= currentDistance && currentDistance <= exitDistance)
{
vtkm::Vec<FloatType, 3> sampleLoc = origin + currentDistance * dir;
vtkm::Float32 lerpedScalar;
bool validSample =
Sampler.SampleCell(points, scalars, sampleLoc, lerpedScalar, fake_functor, cellShape);
bool validSample = Sampler.SampleCell(points, scalars, sampleLoc, lerpedScalar, cellShape);
if (!validSample)
{
//

113
vtkm/worklet/ExternalFaces.h
View File

@ -288,8 +288,8 @@ struct ExternalFaces
vtkm::IdComponent faceIndex = FindFaceIndexForVisit(visitIndex, pointCoordinates);
const vtkm::IdComponent numFacePoints =
vtkm::exec::CellFaceNumberOfPoints(faceIndex, shape, *this);
vtkm::IdComponent numFacePoints;
vtkm::exec::CellFaceNumberOfPoints(faceIndex, shape, numFacePoints);
VTKM_ASSERT(numFacePoints == faceConnectivity.GetNumberOfComponents());
typename CellSetType::IndicesType inCellIndices = cellSet.GetIndices(inputIndex);
@ -299,8 +299,18 @@ struct ExternalFaces
for (vtkm::IdComponent facePointIndex = 0; facePointIndex < numFacePoints; facePointIndex++)
{
faceConnectivity[facePointIndex] =
inCellIndices[vtkm::exec::CellFaceLocalIndex(facePointIndex, faceIndex, shape, *this)];
vtkm::IdComponent localFaceIndex;
vtkm::ErrorCode status =
vtkm::exec::CellFaceLocalIndex(facePointIndex, faceIndex, shape, localFaceIndex);
if (status == vtkm::ErrorCode::Success)
{
faceConnectivity[facePointIndex] = inCellIndices[localFaceIndex];
}
else
{
// An error condition, but do we want to crash the operation?
faceConnectivity[facePointIndex] = 0;
}
}
}
@ -314,13 +324,13 @@ struct ExternalFaces
{
public:
using ControlSignature = void(CellSetIn inCellSet, FieldOut numFacesInCell);
using ExecutionSignature = _2(CellShape);
using ExecutionSignature = void(CellShape, _2);
using InputDomain = _1;
template <typename CellShapeTag>
VTKM_EXEC vtkm::IdComponent operator()(CellShapeTag shape) const
VTKM_EXEC void operator()(CellShapeTag shape, vtkm::IdComponent& numFaces) const
{
return vtkm::exec::CellFaceNumberOfFaces(shape, *this);
vtkm::exec::CellFaceNumberOfFaces(shape, numFaces);
}
};
@ -346,7 +356,9 @@ struct ExternalFaces
vtkm::Id inputIndex,
vtkm::IdComponent visitIndex) const
{
faceHash = vtkm::Hash(vtkm::exec::CellFaceCanonicalId(visitIndex, shape, cellNodeIds, *this));
vtkm::Id3 faceId;
vtkm::exec::CellFaceCanonicalId(visitIndex, shape, cellNodeIds, faceId);
faceHash = vtkm::Hash(faceId);
cellIndex = inputIndex;
faceIndex = visitIndex;
@ -384,18 +396,18 @@ struct ExternalFaces
myIndex < numCellsOnHash - 1; // Don't need to check last face
myIndex++)
{
vtkm::Id3 myFace =
vtkm::exec::CellFaceCanonicalId(originFaces[myIndex],
cellSet.GetCellShape(originCells[myIndex]),
cellSet.GetIndices(originCells[myIndex]),
*this);
vtkm::Id3 myFace;
vtkm::exec::CellFaceCanonicalId(originFaces[myIndex],
cellSet.GetCellShape(originCells[myIndex]),
cellSet.GetIndices(originCells[myIndex]),
myFace);
for (vtkm::IdComponent otherIndex = myIndex + 1; otherIndex < numCellsOnHash; otherIndex++)
{
vtkm::Id3 otherFace =
vtkm::exec::CellFaceCanonicalId(originFaces[otherIndex],
cellSet.GetCellShape(originCells[otherIndex]),
cellSet.GetIndices(originCells[otherIndex]),
*this);
vtkm::Id3 otherFace;
vtkm::exec::CellFaceCanonicalId(originFaces[otherIndex],
cellSet.GetCellShape(originCells[otherIndex]),
cellSet.GetIndices(originCells[otherIndex]),
otherFace);
if (myFace == otherFace)
{
// Faces are the same. Must be internal. Remove 2, one for each face. We don't have to
@ -421,8 +433,7 @@ private:
VTKM_EXEC static vtkm::IdComponent FindUniqueFace(const CellSetType& cellSet,
const OriginCellsType& originCells,
const OriginFacesType& originFaces,
vtkm::IdComponent visitIndex,
const vtkm::exec::FunctorBase* self)
vtkm::IdComponent visitIndex)
{
vtkm::IdComponent numCellsOnHash = originCells.GetNumberOfComponents();
VTKM_ASSERT(originFaces.GetNumberOfComponents() == numCellsOnHash);
@ -433,18 +444,19 @@ private:
while (true)
{
VTKM_ASSERT(myIndex < numCellsOnHash);
vtkm::Id3 myFace = vtkm::exec::CellFaceCanonicalId(originFaces[myIndex],
cellSet.GetCellShape(originCells[myIndex]),
cellSet.GetIndices(originCells[myIndex]),
*self);
vtkm::Id3 myFace;
vtkm::exec::CellFaceCanonicalId(originFaces[myIndex],
cellSet.GetCellShape(originCells[myIndex]),
cellSet.GetIndices(originCells[myIndex]),
myFace);
bool foundPair = false;
for (vtkm::IdComponent otherIndex = myIndex + 1; otherIndex < numCellsOnHash; otherIndex++)
{
vtkm::Id3 otherFace =
vtkm::exec::CellFaceCanonicalId(originFaces[otherIndex],
cellSet.GetCellShape(originCells[otherIndex]),
cellSet.GetIndices(originCells[otherIndex]),
*self);
vtkm::Id3 otherFace;
vtkm::exec::CellFaceCanonicalId(originFaces[otherIndex],
cellSet.GetCellShape(originCells[otherIndex]),
cellSet.GetIndices(originCells[otherIndex]),
otherFace);
if (myFace == otherFace)
{
// Faces are the same. Must be internal.
@ -482,7 +494,7 @@ public:
ValuesIn originCells,
ValuesIn originFaces,
ReducedValuesOut numPointsInFace);
using ExecutionSignature = _5(_2, _3, _4, VisitIndex);
using ExecutionSignature = void(_2, _3, _4, VisitIndex, _5);
using InputDomain = _1;
using ScatterType = vtkm::worklet::ScatterCounting;
@ -495,16 +507,17 @@ public:
}
template <typename CellSetType, typename OriginCellsType, typename OriginFacesType>
VTKM_EXEC vtkm::IdComponent operator()(const CellSetType& cellSet,
const OriginCellsType& originCells,
const OriginFacesType& originFaces,
vtkm::IdComponent visitIndex) const
VTKM_EXEC void operator()(const CellSetType& cellSet,
const OriginCellsType& originCells,
const OriginFacesType& originFaces,
vtkm::IdComponent visitIndex,
vtkm::IdComponent& numFacePoints) const
{
vtkm::IdComponent myIndex =
ExternalFaces::FindUniqueFace(cellSet, originCells, originFaces, visitIndex, this);
ExternalFaces::FindUniqueFace(cellSet, originCells, originFaces, visitIndex);
return vtkm::exec::CellFaceNumberOfPoints(
originFaces[myIndex], cellSet.GetCellShape(originCells[myIndex]), *this);
vtkm::exec::CellFaceNumberOfPoints(
originFaces[myIndex], cellSet.GetCellShape(originCells[myIndex]), numFacePoints);
}
};
@ -537,16 +550,16 @@ public:
vtkm::Id& cellIdMapOut) const
{
const vtkm::IdComponent myIndex =
ExternalFaces::FindUniqueFace(cellSet, originCells, originFaces, visitIndex, this);
ExternalFaces::FindUniqueFace(cellSet, originCells, originFaces, visitIndex);
const vtkm::IdComponent myFace = originFaces[myIndex];
typename CellSetType::CellShapeTag shapeIn = cellSet.GetCellShape(originCells[myIndex]);
shapeOut = vtkm::exec::CellFaceShape(myFace, shapeIn, *this);
vtkm::exec::CellFaceShape(myFace, shapeIn, shapeOut);
cellIdMapOut = originCells[myIndex];
const vtkm::IdComponent numFacePoints =
vtkm::exec::CellFaceNumberOfPoints(myFace, shapeIn, *this);
vtkm::IdComponent numFacePoints;
vtkm::exec::CellFaceNumberOfPoints(myFace, shapeIn, numFacePoints);
VTKM_ASSERT(numFacePoints == connectivityOut.GetNumberOfComponents());
@ -554,8 +567,18 @@ public:
for (vtkm::IdComponent facePointIndex = 0; facePointIndex < numFacePoints; facePointIndex++)
{
connectivityOut[facePointIndex] =
inCellIndices[vtkm::exec::CellFaceLocalIndex(facePointIndex, myFace, shapeIn, *this)];
vtkm::IdComponent localFaceIndex;
vtkm::ErrorCode status =
vtkm::exec::CellFaceLocalIndex(facePointIndex, myFace, shapeIn, localFaceIndex);
if (status == vtkm::ErrorCode::Success)
{
connectivityOut[facePointIndex] = inCellIndices[localFaceIndex];
}
else
{
// An error condition, but do we want to crash the operation?
connectivityOut[facePointIndex] = 0;
}
}
}
};
@ -570,7 +593,9 @@ public:
template <typename CellShapeTag>
VTKM_EXEC vtkm::IdComponent operator()(CellShapeTag shape) const
{
return !vtkm::exec::CellFaceNumberOfFaces(shape, *this);
vtkm::IdComponent numFaces;
vtkm::exec::CellFaceNumberOfFaces(shape, numFaces);
return !numFaces;
}
};

12
vtkm/worklet/Probe.h
View File

@ -48,7 +48,7 @@ public:
vtkm::Id& cellId,
vtkm::Vec3f& pcoords) const
{
locator->FindCell(point, cellId, pcoords, *this);
locator->FindCell(point, cellId, pcoords);
}
};
@ -124,10 +124,10 @@ public:
for (vtkm::Id i = minp[0]; i <= maxp[0]; ++i)
{
auto pt = portal.Get(vtkm::Id3(i, j, k));
bool success = false;
auto pc = vtkm::exec::WorldCoordinatesToParametricCoordinates(
cellPoints, pt, cellShape, success, *this);
if (success && vtkm::exec::CellInside(pc, cellShape))
CoordsType pc;
vtkm::ErrorCode status =
vtkm::exec::WorldCoordinatesToParametricCoordinates(cellPoints, pt, cellShape, pc);
if ((status == vtkm::ErrorCode::Success) && vtkm::exec::CellInside(pc, cellShape))
{
auto pointId = i + portal.GetDimensions()[0] * (j + portal.GetDimensions()[1] * k);
cellIds.Set(pointId, cellId);
@ -199,7 +199,7 @@ public:
{
auto indices = cells.GetIndices(cellId);
auto pointVals = vtkm::make_VecFromPortalPermute(&indices, in);
out = vtkm::exec::CellInterpolate(pointVals, pc, cells.GetCellShape(cellId), *this);
vtkm::exec::CellInterpolate(pointVals, pc, cells.GetCellShape(cellId), out);
}
}
};

63
vtkm/worklet/SplitSharpEdges.h
View File

@ -34,18 +34,17 @@ namespace internal
// Given a cell and a point on the cell, find the two edges that are
// associated with this point in canonical index
template <typename PointFromCellSetType>
VTKM_EXEC void FindRelatedEdges(const vtkm::Id& pointIndex,
const vtkm::Id& cellIndexG,
const PointFromCellSetType& pFromCellSet,
vtkm::Id2& edge0G,
vtkm::Id2& edge1G,
const vtkm::exec::FunctorBase& worklet)
VTKM_EXEC vtkm::ErrorCode FindRelatedEdges(const vtkm::Id& pointIndex,
const vtkm::Id& cellIndexG,
const PointFromCellSetType& pFromCellSet,
vtkm::Id2& edge0G,
vtkm::Id2& edge1G)
{
typename PointFromCellSetType::CellShapeTag cellShape = pFromCellSet.GetCellShape(cellIndexG);
typename PointFromCellSetType::IndicesType cellConnections = pFromCellSet.GetIndices(cellIndexG);
vtkm::IdComponent numPointsInCell = pFromCellSet.GetNumberOfIndices(cellIndexG);
vtkm::IdComponent numEdges =
vtkm::exec::CellEdgeNumberOfEdges(numPointsInCell, cellShape, worklet);
vtkm::IdComponent numEdges;
VTKM_RETURN_ON_ERROR(vtkm::exec::CellEdgeNumberOfEdges(numPointsInCell, cellShape, numEdges));
vtkm::IdComponent edgeIndex = -1;
// Find the two edges with the pointIndex
while (true)
@ -53,13 +52,16 @@ VTKM_EXEC void FindRelatedEdges(const vtkm::Id& pointIndex,
++edgeIndex;
if (edgeIndex >= numEdges)
{
worklet.RaiseError("Bad cell. Could not find two incident edges.");
return;
// Bad cell. Could not find two incident edges.
return vtkm::ErrorCode::MalformedCellDetected;
}
vtkm::Id2 canonicalEdgeId(cellConnections[vtkm::exec::CellEdgeLocalIndex(
numPointsInCell, 0, edgeIndex, cellShape, worklet)],
cellConnections[vtkm::exec::CellEdgeLocalIndex(
numPointsInCell, 1, edgeIndex, cellShape, worklet)]);
vtkm::IdComponent2 localEdgeIndices;
VTKM_RETURN_ON_ERROR(vtkm::exec::CellEdgeLocalIndex(
numPointsInCell, 0, edgeIndex, cellShape, localEdgeIndices[0]));
VTKM_RETURN_ON_ERROR(vtkm::exec::CellEdgeLocalIndex(
numPointsInCell, 1, edgeIndex, cellShape, localEdgeIndices[1]));
vtkm::Id2 canonicalEdgeId(cellConnections[localEdgeIndices[0]],
cellConnections[localEdgeIndices[1]]);
if (canonicalEdgeId[0] == pointIndex || canonicalEdgeId[1] == pointIndex)
{ // Assign value to edge0 first
if ((edge0G[0] == -1) && (edge0G[1] == -1))
@ -73,6 +75,7 @@ VTKM_EXEC void FindRelatedEdges(const vtkm::Id& pointIndex,
}
}
}
return vtkm::ErrorCode::Success;
}
// TODO: We should replace this expensive lookup with a WholeCellSetIn<Edge, Cell> map.
@ -82,8 +85,7 @@ template <typename PointFromCellSetType, typename IncidentCellVecType>
VTKM_EXEC int FindNeighborCellInLocalIndex(const vtkm::Id2& eOI,
const PointFromCellSetType& pFromCellSet,
const IncidentCellVecType& incidentCells,
const vtkm::Id currentCellLocalIndex,
const vtkm::exec::FunctorBase& worklet)
const vtkm::Id currentCellLocalIndex)
{
int neighboringCellIndex = -1;
vtkm::IdComponent numberOfIncidentCells = incidentCells.GetNumberOfComponents();
@ -100,8 +102,8 @@ VTKM_EXEC int FindNeighborCellInLocalIndex(const vtkm::Id2& eOI,
typename PointFromCellSetType::IndicesType cellConnections =
pFromCellSet.GetIndices(cellIndexG);
vtkm::IdComponent numPointsInCell = pFromCellSet.GetNumberOfIndices(cellIndexG);
vtkm::IdComponent numEdges =
vtkm::exec::CellEdgeNumberOfEdges(numPointsInCell, cellShape, worklet);
vtkm::IdComponent numEdges;
vtkm::exec::CellEdgeNumberOfEdges(numPointsInCell, cellShape, numEdges);
vtkm::IdComponent edgeIndex = -1;
// Check if this cell has edge of interest
while (true)
@ -111,10 +113,11 @@ VTKM_EXEC int FindNeighborCellInLocalIndex(const vtkm::Id2& eOI,
{
break;
}
vtkm::Id2 canonicalEdgeId(cellConnections[vtkm::exec::CellEdgeLocalIndex(
numPointsInCell, 0, edgeIndex, cellShape, worklet)],
cellConnections[vtkm::exec::CellEdgeLocalIndex(
numPointsInCell, 1, edgeIndex, cellShape, worklet)]);
vtkm::IdComponent2 localEdgeIndices;
vtkm::exec::CellEdgeLocalIndex(numPointsInCell, 0, edgeIndex, cellShape, localEdgeIndices[0]);
vtkm::exec::CellEdgeLocalIndex(numPointsInCell, 1, edgeIndex, cellShape, localEdgeIndices[1]);
vtkm::Id2 canonicalEdgeId(cellConnections[localEdgeIndices[0]],
cellConnections[localEdgeIndices[1]]);
if ((canonicalEdgeId[0] == eOI[0] && canonicalEdgeId[1] == eOI[1]) ||
(canonicalEdgeId[0] == eOI[1] && canonicalEdgeId[1] == eOI[0]))
{
@ -135,8 +138,7 @@ VTKM_EXEC bool FindConnectedCellOwnerships(vtkm::FloatDefault cosFeatureAngle,
const PointFromCellSetType& pFromCellSet,
const FaceNormalVecType& faceNormals,
vtkm::Id visitedCellsRegionIndex[64],
vtkm::Id& regionIndex,
const vtkm::exec::FunctorBase& worklet)
vtkm::Id& regionIndex)
{
const vtkm::IdComponent numberOfIncidentCells = incidentCells.GetNumberOfComponents();
VTKM_ASSERT(numberOfIncidentCells < 64);
@ -163,7 +165,7 @@ VTKM_EXEC bool FindConnectedCellOwnerships(vtkm::FloatDefault cosFeatureAngle,
// Find two edges containing the current point in canonial index
vtkm::Id2 edge0G(-1, -1), edge1G(-1, -1);
internal::FindRelatedEdges(pointIndex, cellIndexG, pFromCellSet, edge0G, edge1G, worklet);
internal::FindRelatedEdges(pointIndex, cellIndexG, pFromCellSet, edge0G, edge1G);
// Grow the area along each edge
for (size_t i = 0; i < 2; i++)
{ // Reset these two values for each grow operation
@ -173,7 +175,7 @@ VTKM_EXEC bool FindConnectedCellOwnerships(vtkm::FloatDefault cosFeatureAngle,
{
// Find the neighbor cell of the current cell edge in local index
int neighboringCellIndexQuery = internal::FindNeighborCellInLocalIndex(
currentEdgeG, pFromCellSet, incidentCells, currentTestingCellIndex, worklet);
currentEdgeG, pFromCellSet, incidentCells, currentTestingCellIndex);
// The edge should be manifold and the neighboring cell should
// have not been visited
if (neighboringCellIndexQuery != -1 && !visitedCells.test(neighboringCellIndexQuery))
@ -199,8 +201,7 @@ VTKM_EXEC bool FindConnectedCellOwnerships(vtkm::FloatDefault cosFeatureAngle,
incidentCells[currentTestingCellIndex],
pFromCellSet,
neighborCellEdge0G,
neighborCellEdge1G,
worklet);
neighborCellEdge1G);
// Update currentEdgeG
if ((currentEdgeG == neighborCellEdge0G) ||
currentEdgeG == vtkm::Id2(neighborCellEdge0G[1], neighborCellEdge0G[0]))
@ -284,8 +285,7 @@ public:
pFromCellSet,
faceNormals,
visitedCellsRegionIndex,
regionIndex,
*this);
regionIndex);
if (!foundConnections)
{
newPointNum = 0;
@ -357,8 +357,7 @@ public:
pFromCellSet,
faceNormals,
visitedCellsRegionIndex,
regionIndex,
*this);
regionIndex);
if (foundConnections)
{
// For each new region you need a new point

12
vtkm/worklet/connectivities/CellSetDualGraph.h
View File

@ -30,14 +30,16 @@ struct EdgeCount : public vtkm::worklet::WorkletVisitCellsWithPoints
{
using ControlSignature = void(CellSetIn, FieldOutCell numEdgesInCell);
using ExecutionSignature = _2(CellShape, PointCount);
using ExecutionSignature = void(CellShape, PointCount, _2);
using InputDomain = _1;
template <typename CellShapeTag>
VTKM_EXEC vtkm::IdComponent operator()(CellShapeTag cellShape, vtkm::IdComponent pointCount) const
VTKM_EXEC void operator()(CellShapeTag cellShape,
vtkm::IdComponent pointCount,
vtkm::IdComponent& numEdges) const
{
return vtkm::exec::CellEdgeNumberOfEdges(pointCount, cellShape, *this);
vtkm::exec::CellEdgeNumberOfEdges(pointCount, cellShape, numEdges);
}
};
@ -63,8 +65,8 @@ struct EdgeExtract : public vtkm::worklet::WorkletVisitCellsWithPoints
EdgeIndexVecType& edgeIndices) const
{
cellIndexOut = cellIndex;
edgeIndices = vtkm::exec::CellEdgeCanonicalId(
pointIndices.GetNumberOfComponents(), visitIndex, cellShape, pointIndices, *this);
vtkm::exec::CellEdgeCanonicalId(
pointIndices.GetNumberOfComponents(), visitIndex, cellShape, pointIndices, edgeIndices);
}
};

5
vtkm/worklet/gradient/CellGradient.h
View File

@ -48,9 +48,10 @@ struct CellGradient : vtkm::worklet::WorkletVisitCellsWithPoints
const FieldInVecType& field,
GradientOutType& outputGradient) const
{
vtkm::Vec3f center = vtkm::exec::ParametricCoordinatesCenter(pointCount, shape, *this);
vtkm::Vec3f center;
vtkm::exec::ParametricCoordinatesCenter(pointCount, shape, center);
outputGradient = vtkm::exec::CellDerivative(field, wCoords, center, shape, *this);
vtkm::exec::CellDerivative(field, wCoords, center, shape, outputGradient);
}
};
}

9
vtkm/worklet/gradient/PointGradient.h
View File

@ -100,10 +100,15 @@ private:
{
vtkm::Vec3f pCoords;
vtkm::exec::ParametricCoordinatesPoint(
wCoords.GetNumberOfComponents(), pointIndexForCell, pCoords, cellShape, *this);
wCoords.GetNumberOfComponents(), pointIndexForCell, cellShape, pCoords);
//we need to add this to a return value
gradient += vtkm::exec::CellDerivative(field, wCoords, pCoords, cellShape, *this);
vtkm::Vec<OutValueType, 3> pointGradient;
auto status = vtkm::exec::CellDerivative(field, wCoords, pCoords, cellShape, pointGradient);
if (status == vtkm::ErrorCode::Success)
{
gradient += pointGradient;
}
}
template <typename CellSetInType>

8
vtkm/worklet/particleadvection/GridEvaluators.h
View File

@ -62,9 +62,8 @@ public:
{
vtkm::Id cellId;
Point parametric;
vtkm::exec::FunctorBase tmp;
Locator->FindCell(point, cellId, parametric, tmp);
Locator->FindCell(point, cellId, parametric);
return cellId != -1;
}
@ -95,10 +94,9 @@ public:
{
vtkm::Id cellId;
Point parametric;
vtkm::exec::FunctorBase tmp;
GridEvaluatorStatus status;
Locator->FindCell(point, cellId, parametric, tmp);
Locator->FindCell(point, cellId, parametric);
if (cellId == -1)
{
status.SetFail();
@ -114,7 +112,7 @@ public:
for (vtkm::IdComponent i = 0; i < nVerts; i++)
fieldValues.Append(Field.Get(ptIndices[i]));
out = vtkm::exec::CellInterpolate(fieldValues, parametric, cellShape, tmp);
vtkm::exec::CellInterpolate(fieldValues, parametric, cellShape, out);
status.SetOk();
return status;

19
vtkm/worklet/testing/UnitTestBoundingIntervalHierarchy.cxx
View File

@ -23,17 +23,18 @@ namespace
{
struct CellCentroidCalculator : public vtkm::worklet::WorkletVisitCellsWithPoints
{
typedef void ControlSignature(CellSetIn, FieldInPoint, FieldOut);
typedef _3 ExecutionSignature(_1, PointCount, _2);
using ControlSignature = void(CellSetIn, FieldInPoint, FieldOut);
using ExecutionSignature = void(_1, PointCount, _2, _3);
template <typename CellShape, typename InputPointField>
VTKM_EXEC typename InputPointField::ComponentType operator()(
CellShape shape,
vtkm::IdComponent numPoints,
const InputPointField& inputPointField) const
VTKM_EXEC void operator()(CellShape shape,
vtkm::IdComponent numPoints,
const InputPointField& inputPointField,
typename InputPointField::ComponentType& outputField) const
{
vtkm::Vec3f parametricCenter = vtkm::exec::ParametricCoordinatesCenter(numPoints, shape, *this);
return vtkm::exec::CellInterpolate(inputPointField, parametricCenter, shape, *this);
vtkm::Vec3f parametricCenter;
vtkm::exec::ParametricCoordinatesCenter(numPoints, shape, parametricCenter);
vtkm::exec::CellInterpolate(inputPointField, parametricCenter, shape, outputField);
}
}; // struct CellCentroidCalculator
@ -49,7 +50,7 @@ struct BoundingIntervalHierarchyTester : public vtkm::worklet::WorkletMapField
{
vtkm::Vec3f parametric;
vtkm::Id cellId;
bih->FindCell(point, cellId, parametric, *this);
bih->FindCell(point, cellId, parametric);
return (1 - static_cast<vtkm::IdComponent>(expectedId == cellId));
}
}; // struct BoundingIntervalHierarchyTester

1
vtkm/worklet/testing/UnitTestProbe.cxx
View File

@ -108,6 +108,7 @@ const std::vector<vtkm::UInt8>& GetExpectedHiddenCells()
template <typename T>
void TestResultArray(const vtkm::cont::ArrayHandle<T>& result, const std::vector<T>& expected)
{
vtkm::cont::printSummary_ArrayHandle(result, std::cout);
VTKM_TEST_ASSERT(result.GetNumberOfValues() == static_cast<vtkm::Id>(expected.size()),
"Incorrect field size");