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

Avoid raising errors when operating on cells

Browse Source 
Cell operations like interpolate and finding parametric coordinates can
fail under certain conditions. Typically these call RaiseError on the
worklet. But that can make a worklet unstable, so provide paths where no
error is raised.
This commit is contained in:
Kenneth Moreland 2020-03-11 17:56:05 -06:00
parent 2796dc33d2
commit 04edc3d202
13 changed files with 414 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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);
}

4
vtkm/cont/CellLocatorUniformBins.h
View File

@ -111,7 +111,7 @@ private:
VTKM_EXEC static bool PointInsideCell(FloatVec3 point,
CellShapeTag cellShape,
CoordsType cellPoints,
const vtkm::exec::FunctorBase& worklet,
const vtkm::exec::FunctorBase* worklet,
FloatVec3& parametricCoordinates)
{
auto bounds = vtkm::internal::cl_uniform_bins::ComputeCellBounds(cellPoints);
@ -160,7 +160,7 @@ public:
void FindCell(const FloatVec3& point,
vtkm::Id& cellId,
FloatVec3& parametric,
const vtkm::exec::FunctorBase& worklet) const override
const vtkm::exec::FunctorBase* worklet) const override
{
using namespace vtkm::internal::cl_uniform_bins;

47
vtkm/exec/CellDerivative.h
View File

@ -39,7 +39,7 @@ VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivative(
const WorldCoordType& worldCoordinateValues,
const vtkm::Vec<ParametricCoordType, 3>& parametricCoords,
vtkm::CellShapeTagGeneric shape,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
vtkm::Vec<typename FieldVecType::ComponentType, 3> result;
switch (shape.Id)
@ -48,7 +48,10 @@ VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivative(
result = CellDerivative(
pointFieldValues, worldCoordinateValues, parametricCoords, CellShapeTag(), worklet));
default:
worklet.RaiseError("Unknown cell shape sent to derivative.");
if (worklet)
{
worklet->RaiseError("Unknown cell shape sent to derivative.");
}
return vtkm::Vec<typename FieldVecType::ComponentType, 3>();
}
return result;
@ -67,7 +70,7 @@ VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivativeImpl(
const FieldVecType& field,
const WorldCoordType& wCoords,
const ParametricCoordType& pcoords,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet)
{
VTKM_ASSERT(field.GetNumberOfComponents() == tag.numberOfPoints());
VTKM_ASSERT(wCoords.GetNumberOfComponents() == tag.numberOfPoints());
@ -85,7 +88,10 @@ VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivativeImpl(
derivs[2]);
if (status != lcl::ErrorCode::SUCCESS)
{
worklet.RaiseError(lcl::errorString(status));
if (worklet)
{
worklet->RaiseError(lcl::errorString(status));
}
derivs = vtkm::TypeTraits<vtkm::Vec<FieldType, 3>>::ZeroInitialization();
}
@ -103,10 +109,10 @@ VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivative(
const WorldCoordType& wCoords,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
return internal::CellDerivativeImpl(
vtkm::internal::make_VtkcCellShapeTag(shape), field, wCoords, pcoords, worklet);
vtkm::internal::make_LclCellShapeTag(shape), field, wCoords, pcoords, worklet);
}
template <typename FieldVecType, typename WorldCoordType, typename ParametricCoordType>
@ -115,9 +121,12 @@ VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivative(
const WorldCoordType&,
const vtkm::Vec<ParametricCoordType, 3>&,
vtkm::CellShapeTagEmpty,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
worklet.RaiseError("Attempted to take derivative in empty cell.");
if (worklet)
{
worklet->RaiseError("Attempted to take derivative in empty cell.");
}
return vtkm::Vec<typename FieldVecType::ComponentType, 3>();
}
@ -127,7 +136,7 @@ VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivative(
const WorldCoordType& wCoords,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolyLine,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
vtkm::IdComponent numPoints = field.GetNumberOfComponents();
VTKM_ASSERT(numPoints >= 1);
@ -165,7 +174,7 @@ VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivative(
const WorldCoordType& wCoords,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolygon,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
VTKM_ASSERT(field.GetNumberOfComponents() == wCoords.GetNumberOfComponents());
@ -191,7 +200,7 @@ VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivative(
const vtkm::VecAxisAlignedPointCoordinates<2>& wCoords,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagQuad,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
return internal::CellDerivativeImpl(lcl::Pixel{}, field, wCoords, pcoords, worklet);
}
@ -202,10 +211,24 @@ VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivative(
const vtkm::VecAxisAlignedPointCoordinates<3>& wCoords,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagHexahedron,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
return internal::CellDerivativeImpl(lcl::Voxel{}, field, wCoords, pcoords, worklet);
}
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)
{
return CellDerivative(field, wCoords, pcoords, shape, &worklet);
}
}
} // namespace vtkm::exec

98
vtkm/exec/CellEdge.h
View File

@ -116,26 +116,29 @@ 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::IdComponent CellEdgeNumberOfEdges(
vtkm::IdComponent numPoints,
CellShapeTag,
const vtkm::exec::FunctorBase* = nullptr)
{
(void)numPoints; // Silence compiler warnings.
VTKM_ASSERT(numPoints == vtkm::CellTraits<CellShapeTag>::NUM_POINTS);
return detail::CellEdgeTables{}.NumEdges(CellShapeTag::Id);
}
static inline VTKM_EXEC vtkm::IdComponent CellEdgeNumberOfEdges(vtkm::IdComponent numPoints,
vtkm::CellShapeTagPolygon,
const vtkm::exec::FunctorBase&)
static inline VTKM_EXEC vtkm::IdComponent CellEdgeNumberOfEdges(
vtkm::IdComponent numPoints,
vtkm::CellShapeTagPolygon,
const vtkm::exec::FunctorBase* = nullptr)
{
VTKM_ASSUME(numPoints > 0);
return numPoints;
}
static inline VTKM_EXEC vtkm::IdComponent CellEdgeNumberOfEdges(vtkm::IdComponent numPoints,
vtkm::CellShapeTagPolyLine,
const vtkm::exec::FunctorBase&)
static inline VTKM_EXEC vtkm::IdComponent CellEdgeNumberOfEdges(
vtkm::IdComponent numPoints,
vtkm::CellShapeTagPolyLine,
const vtkm::exec::FunctorBase* = nullptr)
{
(void)numPoints; // Silence compiler warnings.
VTKM_ASSUME(numPoints > 0);
@ -145,7 +148,7 @@ static inline VTKM_EXEC vtkm::IdComponent CellEdgeNumberOfEdges(vtkm::IdComponen
static inline VTKM_EXEC vtkm::IdComponent CellEdgeNumberOfEdges(
vtkm::IdComponent numPoints,
vtkm::CellShapeTagGeneric shape,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
if (shape.Id == vtkm::CELL_SHAPE_POLYGON)
{
@ -162,11 +165,21 @@ static inline VTKM_EXEC vtkm::IdComponent CellEdgeNumberOfEdges(
}
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)
static inline VTKM_EXEC vtkm::IdComponent CellEdgeNumberOfEdges(
vtkm::IdComponent numPoints,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
return CellEdgeNumberOfEdges(numPoints, shape, &worklet);
}
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 = nullptr)
{
VTKM_ASSUME(pointIndex >= 0);
VTKM_ASSUME(pointIndex < 2);
@ -174,7 +187,10 @@ static inline VTKM_EXEC vtkm::IdComponent CellEdgeLocalIndex(vtkm::IdComponent n
VTKM_ASSUME(edgeIndex < detail::CellEdgeTables::MAX_NUM_EDGES);
if (edgeIndex >= vtkm::exec::CellEdgeNumberOfEdges(numPoints, shape, worklet))
{
worklet.RaiseError("Invalid edge number.");
if (worklet)
{
worklet->RaiseError("Invalid edge number.");
}
return 0;
}
@ -182,11 +198,12 @@ static inline VTKM_EXEC vtkm::IdComponent CellEdgeLocalIndex(vtkm::IdComponent n
return table.PointsInEdge(CellShapeTag::Id, edgeIndex, pointIndex);
}
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::IdComponent CellEdgeLocalIndex(
vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::IdComponent edgeIndex,
vtkm::CellShapeTagPolygon,
const vtkm::exec::FunctorBase* = nullptr)
{
VTKM_ASSUME(numPoints >= 3);
VTKM_ASSUME(pointIndex >= 0);
@ -204,11 +221,12 @@ static inline VTKM_EXEC vtkm::IdComponent CellEdgeLocalIndex(vtkm::IdComponent n
}
}
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::IdComponent CellEdgeLocalIndex(
vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::IdComponent edgeIndex,
vtkm::CellShapeTagGeneric shape,
const vtkm::exec::FunctorBase* worklet = nullptr)
{
VTKM_ASSUME(pointIndex >= 0);
VTKM_ASSUME(pointIndex < 2);
@ -225,7 +243,10 @@ static inline VTKM_EXEC vtkm::IdComponent CellEdgeLocalIndex(vtkm::IdComponent n
detail::CellEdgeTables table;
if (edgeIndex >= table.NumEdges(shape.Id))
{
worklet.RaiseError("Invalid edge number.");
if (worklet)
{
worklet->RaiseError("Invalid edge number.");
}
return 0;
}
@ -233,6 +254,16 @@ static inline VTKM_EXEC vtkm::IdComponent CellEdgeLocalIndex(vtkm::IdComponent n
}
}
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)
{
return CellEdgeLocalIndex(numPoints, pointIndex, edgeIndex, shape, &worklet);
}
/// \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
@ -245,7 +276,7 @@ static inline VTKM_EXEC vtkm::Id2 CellEdgeCanonicalId(
vtkm::IdComponent edgeIndex,
CellShapeTag shape,
const GlobalPointIndicesVecType& globalPointIndicesVec,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
vtkm::Id pointIndex0 =
globalPointIndicesVec[vtkm::exec::CellEdgeLocalIndex(numPoints, 0, edgeIndex, shape, worklet)];
@ -260,6 +291,17 @@ static inline VTKM_EXEC vtkm::Id2 CellEdgeCanonicalId(
return vtkm::Id2(pointIndex1, pointIndex0);
}
}
template <typename CellShapeTag, typename GlobalPointIndicesVecType>
static inline VTKM_EXEC vtkm::Id2 CellEdgeCanonicalId(
vtkm::IdComponent numPoints,
vtkm::IdComponent edgeIndex,
CellShapeTag shape,
const GlobalPointIndicesVecType& globalPointIndicesVec,
const vtkm::exec::FunctorBase& worklet)
{
return CellEdgeCanonicalId(numPoints, edgeIndex, shape, globalPointIndicesVec, &worklet);
}
}
} // namespace vtkm::exec

83
vtkm/exec/CellFace.h
View File

@ -140,35 +140,56 @@ public:
} // namespace detail
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::IdComponent CellFaceNumberOfFaces(CellShapeTag shape,
const vtkm::exec::FunctorBase&)
static inline VTKM_EXEC vtkm::IdComponent CellFaceNumberOfFaces(
CellShapeTag shape,
const vtkm::exec::FunctorBase* = nullptr)
{
(void)shape; //C4100 false positive workaround
detail::CellFaceTables table;
return table.NumFaces(shape.Id);
}
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::IdComponent CellFaceNumberOfFaces(
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
return CellFaceNumberOfFaces(shape, &worklet);
}
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::IdComponent CellFaceNumberOfPoints(
vtkm::IdComponent faceIndex,
CellShapeTag shape,
const vtkm::exec::FunctorBase* worklet = nullptr)
{
VTKM_ASSUME(faceIndex >= 0);
VTKM_ASSUME(faceIndex < detail::CellFaceTables::MAX_NUM_FACES);
if (faceIndex >= vtkm::exec::CellFaceNumberOfFaces(shape, worklet))
{
if (worklet)
{
worklet->RaiseError("Invalid face number.");
}
return 0;
}
detail::CellFaceTables table;
return table.NumPointsInFace(shape.Id, faceIndex);
}
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::IdComponent CellFaceNumberOfPoints(
vtkm::IdComponent faceIndex,
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))
{
worklet.RaiseError("Invalid face number.");
return 0;
}
detail::CellFaceTables table;
return table.NumPointsInFace(shape.Id, faceIndex);
return CellFaceNumberOfPoints(faceIndex, shape, &worklet);
}
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::UInt8 CellFaceShape(vtkm::IdComponent faceIndex,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
VTKM_ASSUME(faceIndex >= 0);
VTKM_ASSUME(faceIndex < detail::CellFaceTables::MAX_NUM_FACES);
@ -184,10 +205,19 @@ static inline VTKM_EXEC vtkm::UInt8 CellFaceShape(vtkm::IdComponent faceIndex,
}
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::IdComponent CellFaceLocalIndex(vtkm::IdComponent pointIndex,
vtkm::IdComponent faceIndex,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
static inline VTKM_EXEC vtkm::UInt8 CellFaceShape(vtkm::IdComponent faceIndex,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
return CellFaceShape(faceIndex, shape, &worklet);
}
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::IdComponent CellFaceLocalIndex(
vtkm::IdComponent pointIndex,
vtkm::IdComponent faceIndex,
CellShapeTag shape,
const vtkm::exec::FunctorBase* worklet = nullptr)
{
vtkm::IdComponent numPointsInFace = vtkm::exec::CellFaceNumberOfPoints(faceIndex, shape, worklet);
if (numPointsInFace < 1)
@ -201,6 +231,15 @@ static inline VTKM_EXEC vtkm::IdComponent CellFaceLocalIndex(vtkm::IdComponent p
return table.PointsInFace(shape.Id, faceIndex, pointIndex);
}
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::IdComponent CellFaceLocalIndex(vtkm::IdComponent pointIndex,
vtkm::IdComponent faceIndex,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
return CellFaceLocalIndex(pointIndex, faceIndex, shape, &worklet);
}
/// \brief Returns a canonical identifier for a cell face
///
/// Given information about a cell face and the global point indices for that cell, returns a
@ -216,7 +255,7 @@ static inline VTKM_EXEC vtkm::Id3 CellFaceCanonicalId(
vtkm::IdComponent faceIndex,
CellShapeTag shape,
const GlobalPointIndicesVecType& globalPointIndicesVec,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
const vtkm::IdComponent numPointsInFace =
vtkm::exec::CellFaceNumberOfPoints(faceIndex, shape, worklet);
@ -284,6 +323,16 @@ static inline VTKM_EXEC vtkm::Id3 CellFaceCanonicalId(
return sorted;
}
template <typename CellShapeTag, typename GlobalPointIndicesVecType>
static inline VTKM_EXEC vtkm::Id3 CellFaceCanonicalId(
vtkm::IdComponent faceIndex,
CellShapeTag shape,
const GlobalPointIndicesVecType& globalPointIndicesVec,
const vtkm::exec::FunctorBase& worklet)
{
return CellFaceCanonicalId(faceIndex, shape, globalPointIndicesVec, &worklet);
}
}
} // namespace vtkm::exec

44
vtkm/exec/CellInterpolate.h
View File

@ -35,7 +35,7 @@ VTKM_EXEC typename FieldVecType::ComponentType CellInterpolateImpl(
VtkcCellShapeTag tag,
const FieldVecType& field,
const ParametricCoordType& pcoords,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
VTKM_ASSERT(tag.numberOfPoints() == field.GetNumberOfComponents());
@ -44,9 +44,9 @@ VTKM_EXEC typename FieldVecType::ComponentType CellInterpolateImpl(
FieldValueType result(0);
auto status =
lcl::interpolate(tag, lcl::makeFieldAccessorNestedSOA(field, numComponents), pcoords, result);
if (status != lcl::ErrorCode::SUCCESS)
if ((status != lcl::ErrorCode::SUCCESS) && (worklet != nullptr))
{
worklet.RaiseError(lcl::errorString(status));
worklet->RaiseError(lcl::errorString(status));
}
return result;
}
@ -64,7 +64,7 @@ VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate(
const FieldVecType& pointFieldValues,
const vtkm::Vec<ParametricCoordType, 3>& parametricCoords,
vtkm::CellShapeTagGeneric shape,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
typename FieldVecType::ComponentType result;
switch (shape.Id)
@ -72,7 +72,10 @@ VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate(
vtkmGenericCellShapeMacro(
result = CellInterpolate(pointFieldValues, parametricCoords, CellShapeTag(), worklet));
default:
worklet.RaiseError("Unknown cell shape sent to interpolate.");
if (worklet)
{
worklet->RaiseError("Unknown cell shape sent to interpolate.");
}
return typename FieldVecType::ComponentType();
}
return result;
@ -84,10 +87,9 @@ VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate(
const FieldVecType& pointFieldValues,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
CellShapeTag tag,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
auto lclTag =
vtkm::internal::make_VtkcCellShapeTag(tag, pointFieldValues.GetNumberOfComponents());
auto lclTag = vtkm::internal::make_LclCellShapeTag(tag, pointFieldValues.GetNumberOfComponents());
return internal::CellInterpolateImpl(lclTag, pointFieldValues, pcoords, worklet);
}
@ -97,9 +99,12 @@ VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate(
const FieldVecType&,
const vtkm::Vec<ParametricCoordType, 3>&,
vtkm::CellShapeTagEmpty,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
worklet.RaiseError("Attempted to interpolate an empty cell.");
if (worklet)
{
worklet->RaiseError("Attempted to interpolate an empty cell.");
}
return typename FieldVecType::ComponentType();
}
@ -109,7 +114,7 @@ VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate(
const FieldVecType& field,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolyLine,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
const vtkm::IdComponent numPoints = field.GetNumberOfComponents();
VTKM_ASSERT(numPoints >= 1);
@ -139,7 +144,7 @@ VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate(
const FieldVecType& field,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolygon,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
const vtkm::IdComponent numPoints = field.GetNumberOfComponents();
VTKM_ASSERT(numPoints > 0);
@ -159,7 +164,7 @@ 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)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
return internal::CellInterpolateImpl(lcl::Pixel{}, field, pcoords, worklet);
}
@ -169,10 +174,21 @@ 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)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
return internal::CellInterpolateImpl(lcl::Voxel{}, field, pcoords, worklet);
}
//-----------------------------------------------------------------------------
template <typename FieldVecType, typename ParametricCoordType, typename CellShapeTag>
VTKM_EXEC typename FieldVecType::ComponentType CellInterpolate(
const FieldVecType& pointFieldValues,
const vtkm::Vec<ParametricCoordType, 3>& pcoords,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
return CellInterpolate(pointFieldValues, pcoords, shape, &worklet);
}
}
} // namespace vtkm::exec

17
vtkm/exec/CellLocator.h
View File

@ -32,7 +32,22 @@ public:
virtual void FindCell(const vtkm::Vec3f& point,
vtkm::Id& cellId,
vtkm::Vec3f& parametric,
const vtkm::exec::FunctorBase& worklet) const = 0;
const vtkm::exec::FunctorBase* worklet) const = 0;
VTKM_EXEC
void FindCell(const vtkm::Vec3f& point,
vtkm::Id& cellId,
vtkm::Vec3f& parametric,
const vtkm::exec::FunctorBase& worklet) const
{
this->FindCell(point, cellId, parametric, &worklet);
}
VTKM_EXEC
void FindCell(const vtkm::Vec3f& point, vtkm::Id& cellId, vtkm::Vec3f& parametric) const
{
this->FindCell(point, cellId, parametric, nullptr);
}
};
} // namespace exec

8
vtkm/exec/CellLocatorBoundingIntervalHierarchyExec.h
View File

@ -98,7 +98,7 @@ public:
void FindCell(const vtkm::Vec3f& point,
vtkm::Id& cellId,
vtkm::Vec3f& parametric,
const vtkm::exec::FunctorBase& worklet) const override
const vtkm::exec::FunctorBase* worklet) const override
{
cellId = -1;
vtkm::Id nodeIndex = 0;
@ -139,7 +139,7 @@ private:
vtkm::Id& cellId,
vtkm::Id nodeIndex,
vtkm::Vec3f& parametric,
const vtkm::exec::FunctorBase& worklet) const
const vtkm::exec::FunctorBase* worklet) const
{
VTKM_ASSERT(state == FindCellState::EnterNode);
@ -224,7 +224,7 @@ private:
VTKM_EXEC vtkm::Id FindInLeaf(const vtkm::Vec3f& point,
vtkm::Vec3f& parametric,
const vtkm::exec::CellLocatorBoundingIntervalHierarchyNode& node,
const vtkm::exec::FunctorBase& worklet) const
const vtkm::exec::FunctorBase* worklet) const
{
using IndicesType = typename CellSetPortal::IndicesType;
for (vtkm::Id i = node.Leaf.Start; i < node.Leaf.Start + node.Leaf.Size; ++i)
@ -246,7 +246,7 @@ private:
vtkm::Vec3f& parametric,
CellShapeTag cellShape,
const CoordsType& cellPoints,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet)
{
bool success = false;
parametric = vtkm::exec::WorldCoordinatesToParametricCoordinates(

3
vtkm/exec/CellLocatorRectilinearGrid.h
View File

@ -98,9 +98,8 @@ public:
void FindCell(const vtkm::Vec3f& point,
vtkm::Id& cellId,
vtkm::Vec3f& parametric,
const vtkm::exec::FunctorBase& worklet) const override
const vtkm::exec::FunctorBase* vtkmNotUsed(worklet)) const override
{
(void)worklet; //suppress unused warning
if (!this->IsInside(point))
{
cellId = -1;

3
vtkm/exec/CellLocatorUniformGrid.h
View File

@ -78,9 +78,8 @@ public:
void FindCell(const vtkm::Vec3f& point,
vtkm::Id& cellId,
vtkm::Vec3f& parametric,
const vtkm::exec::FunctorBase& worklet) const override
const vtkm::exec::FunctorBase* vtkmNotUsed(worklet)) const override
{
(void)worklet; //suppress unused warning
if (!this->IsInside(point))
{
cellId = -1;

224
vtkm/exec/ParametricCoordinates.h
View File

@ -30,7 +30,7 @@ template <typename ParametricCoordType, typename CellShapeTag>
static inline VTKM_EXEC void ParametricCoordinatesCenter(vtkm::IdComponent numPoints,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
CellShapeTag,
const vtkm::exec::FunctorBase&)
const vtkm::exec::FunctorBase* = nullptr)
{
auto lclTag = typename vtkm::internal::CellShapeTagVtkmToVtkc<CellShapeTag>::Type{};
@ -45,7 +45,7 @@ template <typename ParametricCoordType>
static inline VTKM_EXEC void ParametricCoordinatesCenter(vtkm::IdComponent numPoints,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagEmpty,
const vtkm::exec::FunctorBase&)
const vtkm::exec::FunctorBase* = nullptr)
{
(void)numPoints; // Silence compiler warnings.
VTKM_ASSERT(numPoints == 0);
@ -56,7 +56,7 @@ template <typename ParametricCoordType>
static inline VTKM_EXEC void ParametricCoordinatesCenter(vtkm::IdComponent numPoints,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagVertex,
const vtkm::exec::FunctorBase&)
const vtkm::exec::FunctorBase* = nullptr)
{
(void)numPoints; // Silence compiler warnings.
VTKM_ASSERT(numPoints == 1);
@ -64,10 +64,11 @@ static inline VTKM_EXEC void ParametricCoordinatesCenter(vtkm::IdComponent numPo
}
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 void ParametricCoordinatesCenter(
vtkm::IdComponent numPoints,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolyLine,
const vtkm::exec::FunctorBase* worklet = nullptr)
{
switch (numPoints)
{
@ -84,10 +85,11 @@ static inline VTKM_EXEC void ParametricCoordinatesCenter(vtkm::IdComponent numPo
}
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 void ParametricCoordinatesCenter(
vtkm::IdComponent numPoints,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolygon,
const vtkm::exec::FunctorBase* worklet = nullptr)
{
VTKM_ASSERT(numPoints > 0);
switch (numPoints)
@ -110,22 +112,35 @@ 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 void ParametricCoordinatesCenter(
vtkm::IdComponent numPoints,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagGeneric shape,
const vtkm::exec::FunctorBase* worklet = nullptr)
{
switch (shape.Id)
{
vtkmGenericCellShapeMacro(
ParametricCoordinatesCenter(numPoints, pcoords, CellShapeTag(), worklet));
default:
worklet.RaiseError("Bad shape given to ParametricCoordinatesCenter.");
if (worklet)
{
worklet->RaiseError("Bad shape given to ParametricCoordinatesCenter.");
}
pcoords[0] = pcoords[1] = pcoords[2] = 0;
break;
}
}
template <typename ParametricCoordType, typename CellShapeTag>
static inline VTKM_EXEC void ParametricCoordinatesCenter(vtkm::IdComponent numPoints,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
ParametricCoordinatesCenter(numPoints, pcoords, shape, &worklet);
}
/// Returns the parametric center of the given cell shape with the given number
/// of points.
///
@ -133,20 +148,29 @@ template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::Vec3f ParametricCoordinatesCenter(
vtkm::IdComponent numPoints,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
vtkm::Vec3f pcoords(0.0f);
ParametricCoordinatesCenter(numPoints, pcoords, shape, worklet);
return pcoords;
}
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::Vec3f ParametricCoordinatesCenter(
vtkm::IdComponent numPoints,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
return ParametricCoordinatesCenter(numPoints, shape, &worklet);
}
//-----------------------------------------------------------------------------
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&)
const vtkm::exec::FunctorBase* = nullptr)
{
auto lclTag = typename vtkm::internal::CellShapeTagVtkmToVtkc<CellShapeTag>::Type{};
@ -159,13 +183,17 @@ static inline VTKM_EXEC void ParametricCoordinatesPoint(vtkm::IdComponent numPoi
}
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 void ParametricCoordinatesPoint(
vtkm::IdComponent,
vtkm::IdComponent,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagEmpty,
const vtkm::exec::FunctorBase* worklet = nullptr)
{
worklet.RaiseError("Empty cell has no points.");
if (worklet)
{
worklet->RaiseError("Empty cell has no points.");
}
pcoords[0] = pcoords[1] = pcoords[2] = 0;
}
@ -174,7 +202,7 @@ static inline VTKM_EXEC void ParametricCoordinatesPoint(vtkm::IdComponent numPoi
vtkm::IdComponent pointIndex,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagVertex,
const vtkm::exec::FunctorBase&)
const vtkm::exec::FunctorBase* = nullptr)
{
(void)numPoints; // Silence compiler warnings.
(void)pointIndex; // Silence compiler warnings.
@ -184,11 +212,12 @@ static inline VTKM_EXEC void ParametricCoordinatesPoint(vtkm::IdComponent numPoi
}
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 void ParametricCoordinatesPoint(
vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolyLine,
const vtkm::exec::FunctorBase* functor = nullptr)
{
switch (numPoints)
{
@ -207,11 +236,12 @@ static inline VTKM_EXEC void ParametricCoordinatesPoint(vtkm::IdComponent numPoi
}
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 void ParametricCoordinatesPoint(
vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagPolygon,
const vtkm::exec::FunctorBase* worklet = nullptr)
{
VTKM_ASSUME((numPoints > 0));
VTKM_ASSUME((pointIndex >= 0) && (pointIndex < numPoints));
@ -237,23 +267,37 @@ 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 void ParametricCoordinatesPoint(
vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
vtkm::CellShapeTagGeneric shape,
const vtkm::exec::FunctorBase* worklet = nullptr)
{
switch (shape.Id)
{
vtkmGenericCellShapeMacro(
ParametricCoordinatesPoint(numPoints, pointIndex, pcoords, CellShapeTag(), worklet));
default:
worklet.RaiseError("Bad shape given to ParametricCoordinatesPoint.");
if (worklet)
{
worklet->RaiseError("Bad shape given to ParametricCoordinatesPoint.");
}
pcoords[0] = pcoords[1] = pcoords[2] = 0;
break;
}
}
template <typename ParametricCoordType, typename CellShapeTag>
static inline VTKM_EXEC void ParametricCoordinatesPoint(vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
vtkm::Vec<ParametricCoordType, 3>& pcoords,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
ParametricCoordinatesPoint(numPoints, pointIndex, pcoords, shape, &worklet);
}
/// Returns the parametric coordinate of a cell point of the given shape with
/// the given number of points.
///
@ -262,30 +306,40 @@ static inline VTKM_EXEC vtkm::Vec3f ParametricCoordinatesPoint(
vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
vtkm::Vec3f pcoords(0.0f);
ParametricCoordinatesPoint(numPoints, pointIndex, pcoords, shape, worklet);
return pcoords;
}
template <typename CellShapeTag>
static inline VTKM_EXEC vtkm::Vec3f ParametricCoordinatesPoint(
vtkm::IdComponent numPoints,
vtkm::IdComponent pointIndex,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
{
return ParametricCoordinatesPoint(numPoints, pointIndex, shape, &worklet);
}
//-----------------------------------------------------------------------------
namespace internal
{
template <typename VtkcCellShapeTag, typename WorldCoordVector, typename PCoordType>
template <typename LclCellShapeTag, typename WorldCoordVector, typename PCoordType>
static inline VTKM_EXEC typename WorldCoordVector::ComponentType
ParametricCoordinatesToWorldCoordinatesImpl(VtkcCellShapeTag tag,
ParametricCoordinatesToWorldCoordinatesImpl(LclCellShapeTag tag,
const WorldCoordVector& pointWCoords,
const PCoordType& pcoords,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
typename WorldCoordVector::ComponentType wcoords(0);
auto status =
lcl::parametricToWorld(tag, lcl::makeFieldAccessorNestedSOA(pointWCoords, 3), pcoords, wcoords);
if (status != lcl::ErrorCode::SUCCESS)
if ((status != lcl::ErrorCode::SUCCESS) && (worklet != nullptr))
{
worklet.RaiseError(lcl::errorString(status));
worklet->RaiseError(lcl::errorString(status));
}
return wcoords;
}
@ -297,11 +351,11 @@ static inline VTKM_EXEC typename WorldCoordVector::ComponentType
ParametricCoordinatesToWorldCoordinates(const WorldCoordVector& pointWCoords,
const vtkm::Vec<PCoordType, 3>& pcoords,
CellShapeTag shape,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
auto numPoints = pointWCoords.GetNumberOfComponents();
return internal::ParametricCoordinatesToWorldCoordinatesImpl(
vtkm::internal::make_VtkcCellShapeTag(shape, numPoints), pointWCoords, pcoords, worklet);
vtkm::internal::make_LclCellShapeTag(shape, numPoints), pointWCoords, pcoords, worklet);
}
template <typename WorldCoordVector, typename PCoordType>
@ -309,7 +363,7 @@ 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)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
return vtkm::exec::CellInterpolate(pointWCoords, pcoords, empty, worklet);
}
@ -319,7 +373,7 @@ 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)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
return vtkm::exec::CellInterpolate(pointWCoords, pcoords, polyLine, worklet);
}
@ -329,7 +383,7 @@ static inline VTKM_EXEC typename WorldCoordVector::ComponentType
ParametricCoordinatesToWorldCoordinates(const WorldCoordVector& pointWCoords,
const vtkm::Vec<PCoordType, 3>& pcoords,
vtkm::CellShapeTagPolygon,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
auto numPoints = pointWCoords.GetNumberOfComponents();
switch (numPoints)
@ -351,7 +405,7 @@ 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)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
return internal::ParametricCoordinatesToWorldCoordinatesImpl(
lcl::Pixel{}, pointWCoords, pcoords, worklet);
@ -362,7 +416,7 @@ 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)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
return internal::ParametricCoordinatesToWorldCoordinatesImpl(
lcl::Voxel{}, pointWCoords, pcoords, worklet);
@ -376,7 +430,7 @@ 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)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
typename WorldCoordVector::ComponentType wcoords(0);
switch (shape.Id)
@ -384,12 +438,25 @@ ParametricCoordinatesToWorldCoordinates(const WorldCoordVector& pointWCoords,
vtkmGenericCellShapeMacro(wcoords = ParametricCoordinatesToWorldCoordinates(
pointWCoords, pcoords, CellShapeTag(), worklet));
default:
worklet.RaiseError("Bad shape given to ParametricCoordinatesPoint.");
if (worklet)
{
worklet->RaiseError("Bad shape given to ParametricCoordinatesPoint.");
}
break;
}
return wcoords;
}
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)
{
return ParametricCoordinatesToWorldCoordinates(pointWCoords, pcoords, shape, &worklet);
}
//-----------------------------------------------------------------------------
namespace internal
{
@ -400,7 +467,7 @@ WorldCoordinatesToParametricCoordinatesImpl(VtkcCellShapeTag tag,
const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType& wcoords,
bool& success,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet)
{
VTKM_ASSERT(pointWCoords.GetNumberOfComponents() == tag.numberOfPoints());
@ -409,9 +476,9 @@ WorldCoordinatesToParametricCoordinatesImpl(VtkcCellShapeTag tag,
lcl::worldToParametric(tag, lcl::makeFieldAccessorNestedSOA(pointWCoords, 3), wcoords, pcoords);
success = true;
if (status != lcl::ErrorCode::SUCCESS)
if ((status != lcl::ErrorCode::SUCCESS) && (worklet != nullptr))
{
worklet.RaiseError(lcl::errorString(status));
worklet->RaiseError(lcl::errorString(status));
success = false;
}
return pcoords;
@ -425,11 +492,11 @@ WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType& wcoords,
CellShapeTag shape,
bool& success,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
auto numPoints = pointWCoords.GetNumberOfComponents();
return internal::WorldCoordinatesToParametricCoordinatesImpl(
vtkm::internal::make_VtkcCellShapeTag(shape, numPoints),
vtkm::internal::make_LclCellShapeTag(shape, numPoints),
pointWCoords,
wcoords,
success,
@ -442,9 +509,12 @@ WorldCoordinatesToParametricCoordinates(const WorldCoordVector&,
const typename WorldCoordVector::ComponentType&,
vtkm::CellShapeTagEmpty,
bool& success,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
worklet.RaiseError("Attempted to find point coordinates in empty cell.");
if (worklet)
{
worklet->RaiseError("Attempted to find point coordinates in empty cell.");
}
success = false;
return typename WorldCoordVector::ComponentType();
}
@ -455,7 +525,7 @@ WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType&,
vtkm::CellShapeTagVertex,
bool& success,
const vtkm::exec::FunctorBase& vtkmNotUsed(worklet))
const vtkm::exec::FunctorBase* = nullptr)
{
(void)pointWCoords; // Silence compiler warnings.
VTKM_ASSERT(pointWCoords.GetNumberOfComponents() == 1);
@ -469,7 +539,7 @@ WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType& wcoords,
vtkm::CellShapeTagPolyLine,
bool& success,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
vtkm::IdComponent numPoints = pointWCoords.GetNumberOfComponents();
VTKM_ASSERT(pointWCoords.GetNumberOfComponents() >= 1);
@ -524,7 +594,7 @@ WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType& wcoords,
vtkm::CellShapeTagPolygon,
bool& success,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
auto numPoints = pointWCoords.GetNumberOfComponents();
switch (numPoints)
@ -546,7 +616,7 @@ static inline VTKM_EXEC vtkm::Vec3f WorldCoordinatesToParametricCoordinates(
const vtkm::Vec3f& wcoords,
vtkm::CellShapeTagQuad,
bool& success,
const FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
return internal::WorldCoordinatesToParametricCoordinatesImpl(
lcl::Pixel{}, pointWCoords, wcoords, success, worklet);
@ -557,7 +627,7 @@ static inline VTKM_EXEC vtkm::Vec3f WorldCoordinatesToParametricCoordinates(
const vtkm::Vec3f& wcoords,
vtkm::CellShapeTagHexahedron,
bool& success,
const FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
return internal::WorldCoordinatesToParametricCoordinatesImpl(
lcl::Voxel{}, pointWCoords, wcoords, success, worklet);
@ -572,7 +642,7 @@ WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords,
const typename WorldCoordVector::ComponentType& wcoords,
vtkm::CellShapeTagGeneric shape,
bool& success,
const vtkm::exec::FunctorBase& worklet)
const vtkm::exec::FunctorBase* worklet = nullptr)
{
typename WorldCoordVector::ComponentType result;
switch (shape.Id)
@ -581,12 +651,26 @@ WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords,
pointWCoords, wcoords, CellShapeTag(), success, worklet));
default:
success = false;
worklet.RaiseError("Unknown cell shape sent to world 2 parametric.");
if (worklet)
{
worklet->RaiseError("Unknown cell shape sent to world 2 parametric.");
}
return typename WorldCoordVector::ComponentType();
}
return result;
}
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)
{
return WorldCoordinatesToParametricCoordinates(pointWCoords, wcoords, shape, success, &worklet);
}
}
} // namespace vtkm::exec

80
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)
{
@ -81,7 +80,7 @@ VTKM_EXEC_CONT inline bool Sample(const vtkm::Vec<vtkm::Vec<P, 3>, 8>& points,
}
bool success = false; // ignored
vtkm::Vec<P, 3> pcoords = vtkm::exec::WorldCoordinatesToParametricCoordinates(
pointsVec, sampleLocation, shapeTag, success, callingWorklet);
pointsVec, sampleLocation, shapeTag, success);
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 +88,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);
lerpedScalar = vtkm::exec::CellInterpolate(scalarVec, pcoords, shapeTag);
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);
points, sampleLocation, vtkm::CellShapeTagHexahedron(), success);
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 +111,7 @@ VTKM_EXEC_CONT inline bool Sample(const vtkm::VecAxisAlignedPointCoordinates<3>&
{
validSample = false;
}
lerpedScalar =
vtkm::exec::CellInterpolate(scalars, pcoords, vtkm::CellShapeTagHexahedron(), callingWorklet);
lerpedScalar = vtkm::exec::CellInterpolate(scalars, pcoords, vtkm::CellShapeTagHexahedron());
return validSample;
}
} // namespace detail
@ -126,12 +123,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 +145,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 +186,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 +207,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 +228,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 +249,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 +268,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());
}
};
}

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

@ -528,7 +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, *this);
locator->FindCell(location, cellId, pcoords);
}
currentCell = cellId;
@ -1091,8 +1091,7 @@ public:
{
vtkm::Vec<FloatType, 3> sampleLoc = origin + currentDistance * dir;
vtkm::Float32 lerpedScalar;
bool validSample =
Sampler.SampleCell(points, scalars, sampleLoc, lerpedScalar, *this, cellShape);
bool validSample = Sampler.SampleCell(points, scalars, sampleLoc, lerpedScalar, cellShape);
if (!validSample)
{
//