Commit 5a1685d8 authored by Matt Larsen's avatar Matt Larsen

updates to the connectivity tracer

parent 8237db20
......@@ -178,6 +178,7 @@ set(device_sources
raytracing/SphereExtractor.cxx
raytracing/SphereIntersector.cxx
raytracing/TriangleExtractor.cxx
raytracing/TriangleIntersector.cxx
raytracing/VolumeRendererStructured.cxx
)
......
......@@ -68,6 +68,9 @@ public:
~InternalsType() {}
VTKM_CONT
void SetUnitScalar(vtkm::Float32 unitScalar) { Tracer.SetUnitScalar(unitScalar); }
void SetSampleDistance(const vtkm::Float32& distance)
{
if (Mode != VOLUME_MODE)
......@@ -119,7 +122,12 @@ public:
vtkm::Bounds GetSpatialBounds() const { return SpatialBounds; }
VTKM_CONT
vtkm::Range GetScalarRange() const { return ScalarRange; }
vtkm::Range GetScalarFieldRange()
{
const vtkm::cont::ArrayHandle<vtkm::Range> range = this->ScalarField.GetRange();
ScalarRange = range.GetPortalConstControl().Get(0);
return ScalarRange;
}
VTKM_CONT
void SetScalarRange(const vtkm::Range& range) { ScalarRange = range; }
......@@ -141,7 +149,7 @@ public:
this->EmissionField);
}
Tracer.Trace(rays);
Tracer.FullTrace(rays);
}
VTKM_CONT
......@@ -160,7 +168,46 @@ public:
this->EmissionField);
}
Tracer.Trace(rays);
Tracer.FullTrace(rays);
}
VTKM_CONT
PartialVector64 PartialTrace(vtkm::rendering::raytracing::Ray<vtkm::Float64>& rays)
{
if (Mode == VOLUME_MODE)
{
Tracer.SetVolumeData(this->ScalarField, this->ScalarRange, this->Cells, this->Coords);
}
else
{
Tracer.SetEnergyData(this->ScalarField,
rays.Buffers.at(0).GetNumChannels(),
this->Cells,
this->Coords,
this->EmissionField);
}
return Tracer.PartialTrace(rays);
}
VTKM_CONT
PartialVector32 PartialTrace(vtkm::rendering::raytracing::Ray<vtkm::Float32>& rays)
{
if (Mode == VOLUME_MODE)
{
Tracer.SetVolumeData(this->ScalarField, this->ScalarRange, this->Cells, this->Coords);
}
else
{
Tracer.SetEnergyData(this->ScalarField,
rays.Buffers.at(0).GetNumChannels(),
this->Cells,
this->Coords,
this->EmissionField);
}
return Tracer.PartialTrace(rays);
}
VTKM_CONT
......@@ -188,7 +235,7 @@ public:
throw vtkm::cont::ErrorBadValue("ENERGY MODE Not implemented for this use case\n");
}
Tracer.Trace(rays);
Tracer.FullTrace(rays);
canvas->WriteToCanvas(rays, rays.Buffers.at(0).Buffer, camera);
if (CompositeBackground)
......@@ -266,9 +313,9 @@ vtkm::Bounds ConnectivityProxy::GetSpatialBounds()
}
VTKM_CONT
vtkm::Range ConnectivityProxy::GetScalarRange()
vtkm::Range ConnectivityProxy::GetScalarFieldRange()
{
return Internals->GetScalarRange();
return Internals->GetScalarFieldRange();
}
VTKM_CONT
......@@ -301,6 +348,27 @@ void ConnectivityProxy::Trace(vtkm::rendering::raytracing::Ray<vtkm::Float64>& r
logger->CloseLogEntry(-1.0);
}
VTKM_CONT
PartialVector32 ConnectivityProxy::PartialTrace(
vtkm::rendering::raytracing::Ray<vtkm::Float32>& rays)
{
raytracing::Logger* logger = raytracing::Logger::GetInstance();
logger->OpenLogEntry("connectivity_trace_32");
if (Internals->GetRenderMode() == VOLUME_MODE)
{
logger->AddLogData("volume_mode", "true");
}
else
{
logger->AddLogData("volume_mode", "false");
}
PartialVector32 res = Internals->PartialTrace(rays);
logger->CloseLogEntry(-1.0);
return res;
}
VTKM_CONT
void ConnectivityProxy::Trace(vtkm::rendering::raytracing::Ray<vtkm::Float32>& rays)
{
......@@ -320,6 +388,27 @@ void ConnectivityProxy::Trace(vtkm::rendering::raytracing::Ray<vtkm::Float32>& r
logger->CloseLogEntry(-1.0);
}
VTKM_CONT
PartialVector64 ConnectivityProxy::PartialTrace(
vtkm::rendering::raytracing::Ray<vtkm::Float64>& rays)
{
raytracing::Logger* logger = raytracing::Logger::GetInstance();
logger->OpenLogEntry("connectivity_trace_64");
if (Internals->GetRenderMode() == VOLUME_MODE)
{
logger->AddLogData("volume_mode", "true");
}
else
{
logger->AddLogData("volume_mode", "false");
}
PartialVector64 res = Internals->PartialTrace(rays);
logger->CloseLogEntry(-1.0);
return res;
}
VTKM_CONT
void ConnectivityProxy::Trace(const vtkm::rendering::Camera& camera,
vtkm::rendering::CanvasRayTracer* canvas)
......@@ -332,10 +421,17 @@ void ConnectivityProxy::Trace(const vtkm::rendering::Camera& camera,
logger->CloseLogEntry(-1.0);
}
VTKM_CONT
void ConnectivityProxy::SetDebugPrints(bool on)
{
Internals->SetDebugPrints(on);
}
VTKM_CONT
void ConnectivityProxy::SetUnitScalar(vtkm::Float32 unitScalar)
{
Internals->SetUnitScalar(unitScalar);
}
}
} // namespace vtkm::rendering
......@@ -26,6 +26,7 @@
#include <vtkm/rendering/Mapper.h>
#include <vtkm/rendering/View.h>
#include <vtkm/rendering/raytracing/Camera.h>
#include <vtkm/rendering/raytracing/PartialComposite.h>
#include <vtkm/rendering/raytracing/Ray.h>
namespace vtkm
......@@ -33,6 +34,9 @@ namespace vtkm
namespace rendering
{
using PartialVector64 = std::vector<vtkm::rendering::raytracing::PartialComposite<vtkm::Float64>>;
using PartialVector32 = std::vector<vtkm::rendering::raytracing::PartialComposite<vtkm::Float32>>;
class VTKM_RENDERING_EXPORT ConnectivityProxy
{
public:
......@@ -57,14 +61,18 @@ public:
void SetColorMap(vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>>& colormap);
void SetCompositeBackground(bool on);
void SetDebugPrints(bool on);
void SetUnitScalar(vtkm::Float32 unitScalar);
vtkm::Bounds GetSpatialBounds();
vtkm::Range GetScalarRange();
vtkm::Range GetScalarFieldRange();
void Trace(const vtkm::rendering::Camera& camera, vtkm::rendering::CanvasRayTracer* canvas);
void Trace(vtkm::rendering::raytracing::Ray<vtkm::Float64>& rays);
void Trace(vtkm::rendering::raytracing::Ray<vtkm::Float32>& rays);
PartialVector64 PartialTrace(vtkm::rendering::raytracing::Ray<vtkm::Float64>& rays);
PartialVector32 PartialTrace(vtkm::rendering::raytracing::Ray<vtkm::Float32>& rays);
protected:
struct InternalsType;
struct BoundsFunctor;
......
......@@ -29,12 +29,8 @@
#include <vtkm/rendering/raytracing/CylinderExtractor.h>
#include <vtkm/rendering/raytracing/CylinderIntersector.h>
#include <vtkm/rendering/raytracing/Logger.h>
#include <vtkm/rendering/raytracing/QuadExtractor.h>
#include <vtkm/rendering/raytracing/QuadIntersector.h>
#include <vtkm/rendering/raytracing/RayOperations.h>
#include <vtkm/rendering/raytracing/RayTracer.h>
#include <vtkm/rendering/raytracing/SphereExtractor.h>
#include <vtkm/rendering/raytracing/SphereIntersector.h>
#include <vtkm/rendering/raytracing/Worklets.h>
namespace vtkm
......
......@@ -21,7 +21,6 @@
#include <vtkm/rendering/MapperPoint.h>
#include <vtkm/cont/Timer.h>
#include <vtkm/cont/TryExecute.h>
#include <vtkm/rendering/CanvasRayTracer.h>
#include <vtkm/rendering/internal/RunTriangulator.h>
......@@ -31,7 +30,6 @@
#include <vtkm/rendering/raytracing/RayTracer.h>
#include <vtkm/rendering/raytracing/SphereExtractor.h>
#include <vtkm/rendering/raytracing/SphereIntersector.h>
#include <vtkm/rendering/raytracing/TriangleExtractor.h>
namespace vtkm
{
......
......@@ -26,15 +26,11 @@
#include <vtkm/rendering/CanvasRayTracer.h>
#include <vtkm/rendering/Cylinderizer.h>
#include <vtkm/rendering/raytracing/Camera.h>
#include <vtkm/rendering/raytracing/CylinderExtractor.h>
#include <vtkm/rendering/raytracing/CylinderIntersector.h>
#include <vtkm/rendering/raytracing/Logger.h>
#include <vtkm/rendering/raytracing/QuadExtractor.h>
#include <vtkm/rendering/raytracing/QuadIntersector.h>
#include <vtkm/rendering/raytracing/RayOperations.h>
#include <vtkm/rendering/raytracing/RayTracer.h>
#include <vtkm/rendering/raytracing/SphereExtractor.h>
#include <vtkm/rendering/raytracing/SphereIntersector.h>
namespace vtkm
{
......
......@@ -78,28 +78,13 @@ VTKM_EXEC inline bool IntersectAABB(const BVHPortalType& bvh,
return (min0 > min1);
}
template <template <typename> class LeafIntersectorType>
class BVHTraverser
{
public:
template <typename Device>
class Intersector : public vtkm::worklet::WorkletMapField
{
public:
typedef typename vtkm::cont::ArrayHandle<Vec<vtkm::Float32, 4>> Float4ArrayHandle;
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Int32, 2>> Int2Handle;
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4>> Id4Handle;
typedef typename vtkm::cont::ArrayHandle<vtkm::Id> IdHandle;
typedef typename Float4ArrayHandle::ExecutionTypes<Device>::PortalConst Float4ArrayPortal;
typedef typename Int2Handle::ExecutionTypes<Device>::PortalConst Int2ArrayPortal;
typedef typename IdHandle::ExecutionTypes<Device>::PortalConst IdArrayPortal;
typedef typename Id4Handle::ExecutionTypes<Device>::PortalConst Id4ArrayPortal;
private:
bool Occlusion;
Float4ArrayPortal FlatBVH;
IdArrayPortal Leafs;
LeafIntersectorType<Device> LeafIntersector;
VTKM_EXEC
inline vtkm::Float32 rcp(vtkm::Float32 f) const { return 1.0f / f; }
......@@ -118,11 +103,8 @@ public:
public:
VTKM_CONT
Intersector(bool occlusion, LinearBVH& bvh, LeafIntersectorType<Device>& leafIntersector)
Intersector(bool occlusion)
: Occlusion(occlusion)
, FlatBVH(bvh.FlatBVH.PrepareForInput(Device()))
, Leafs(bvh.Leafs.PrepareForInput(Device()))
, LeafIntersector(leafIntersector)
{
}
using ControlSignature = void(FieldIn<>,
......@@ -133,11 +115,18 @@ public:
FieldOut<>,
FieldOut<>,
FieldOut<>,
WholeArrayIn<Vec3RenderingTypes>);
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, _7, _8, _9);
WholeArrayIn<Vec3RenderingTypes>,
ExecObject leafIntersector,
WholeArrayIn<>,
WholeArrayIn<>);
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12);
template <typename PointPortalType, typename Precision>
template <typename PointPortalType,
typename Precision,
typename LeafType,
typename InnerNodePortalType,
typename LeafPortalType>
VTKM_EXEC void operator()(const vtkm::Vec<Precision, 3>& dir,
const vtkm::Vec<Precision, 3>& origin,
Precision& distance,
......@@ -146,7 +135,10 @@ public:
Precision& minU,
Precision& minV,
vtkm::Id& hitIndex,
const PointPortalType& points) const
const PointPortalType& points,
LeafType& leafIntersector,
const InnerNodePortalType& flatBVH,
const LeafPortalType& leafs) const
{
Precision closestDistance = maxDistance;
distance = maxDistance;
......@@ -174,7 +166,7 @@ public:
bool hitLeftChild, hitRightChild;
bool rightCloser = IntersectAABB(FlatBVH,
bool rightCloser = IntersectAABB(flatBVH,
currentNode,
originDir,
invDir,
......@@ -191,7 +183,7 @@ public:
else
{
vtkm::Vec<vtkm::Float32, 4> children =
FlatBVH.Get(currentNode + 3); //Children.Get(currentNode);
flatBVH.Get(currentNode + 3); //Children.Get(currentNode);
vtkm::Int32 leftChild;
memcpy(&leftChild, &children[0], 4);
vtkm::Int32 rightChild;
......@@ -217,7 +209,7 @@ public:
if (currentNode < 0 && currentNode != barrier) //check register usage
{
currentNode = -currentNode - 1; //swap the neg address
LeafIntersector.IntersectLeaf(currentNode,
leafIntersector.IntersectLeaf(currentNode,
origin,
dir,
points,
......@@ -225,7 +217,7 @@ public:
closestDistance,
minU,
minV,
Leafs,
leafs,
minDistance);
currentNode = todo[stackptr];
stackptr--;
......@@ -239,16 +231,13 @@ public:
};
template <typename Precision, typename Device>
template <typename Precision, typename LeafIntersectorType>
VTKM_CONT void IntersectRays(Ray<Precision>& rays,
LinearBVH& bvh,
LeafIntersectorType<Device> leafIntersector,
vtkm::cont::CoordinateSystem& coordsHandle,
Device vtkmNotUsed(Device))
LeafIntersectorType& leafIntersector,
vtkm::cont::CoordinateSystem& coordsHandle)
{
vtkm::worklet::DispatcherMapField<Intersector<Device>> intersectDispatch(
Intersector<Device>(false, bvh, leafIntersector));
intersectDispatch.SetDevice(Device());
vtkm::worklet::DispatcherMapField<Intersector> intersectDispatch(Intersector(false));
intersectDispatch.Invoke(rays.Dir,
rays.Origin,
rays.Distance,
......@@ -257,7 +246,10 @@ public:
rays.U,
rays.V,
rays.HitIdx,
coordsHandle);
coordsHandle,
leafIntersector,
bvh.FlatBVH,
bvh.Leafs);
}
}; // BVHTraverser
#undef END_FLAG
......
......@@ -35,6 +35,7 @@ set(headers
MeshConnectivityContainers.h
MeshConnectivityBase.h
MortonCodes.h
PartialComposite.h
QuadExtractor.h
QuadIntersector.h
Ray.h
......@@ -46,6 +47,7 @@ set(headers
SphereExtractor.h
SphereIntersector.h
TriangleExtractor.h
TriangleIntersections.h
TriangleIntersector.h
VolumeRendererStructured.h
Worklets.h
......
......@@ -20,8 +20,9 @@
#ifndef vtk_m_rendering_raytracing_Cell_Intersector_h
#define vtk_m_rendering_raytracing_Cell_Intersector_h
#include <vtkm/CellShape.h>
#include <vtkm/rendering/raytracing/CellTables.h>
#include <vtkm/rendering/raytracing/TriangleIntersector.h>
#include <vtkm/rendering/raytracing/TriangleIntersections.h>
namespace vtkm
{
......
......@@ -511,6 +511,15 @@ void ChannelBuffer<Precision>::SetNumChannels(const vtkm::Int32 numChannels)
ResizeChannelFunctor<Precision> functor(this, numChannels);
vtkm::cont::TryExecute(functor);
}
template <typename Precision>
ChannelBuffer<Precision> ChannelBuffer<Precision>::Copy()
{
ChannelBuffer res(NumChannels, Size);
vtkm::cont::Algorithm::Copy(this->Buffer, res.Buffer);
return res;
}
// Instantiate supported types
template class ChannelBuffer<vtkm::Float32>;
template class ChannelBuffer<vtkm::Float64>;
......
......@@ -83,6 +83,8 @@ public:
const vtkm::Id outputSize,
Precision initValue = 1.f);
ChannelBuffer<Precision> Copy();
void InitConst(const Precision value);
void InitChannels(const vtkm::cont::ArrayHandle<Precision>& signature);
void Normalize(bool invert);
......
......@@ -103,23 +103,21 @@ public:
class ChannelBufferOperations
{
public:
template <typename Device, typename Precision>
template <typename Precision>
static void Compact(ChannelBuffer<Precision>& buffer,
vtkm::cont::ArrayHandle<UInt8>& masks,
const vtkm::Id& newSize,
Device)
const vtkm::Id& newSize)
{
vtkm::cont::ArrayHandle<vtkm::Id> offsets;
offsets.PrepareForOutput(buffer.Size, Device());
offsets.Allocate(buffer.Size);
vtkm::cont::ArrayHandleCast<vtkm::Id, vtkm::cont::ArrayHandle<vtkm::UInt8>> castedMasks(masks);
vtkm::cont::DeviceAdapterAlgorithm<Device>::ScanExclusive(castedMasks, offsets);
vtkm::cont::Algorithm::ScanExclusive(castedMasks, offsets);
vtkm::cont::ArrayHandle<Precision> compactedBuffer;
compactedBuffer.PrepareForOutput(newSize * buffer.NumChannels, Device());
compactedBuffer.Allocate(newSize * buffer.NumChannels);
vtkm::worklet::DispatcherMapField<detail::CompactBuffer> dispatcher(
detail::CompactBuffer(buffer.NumChannels));
dispatcher.SetDevice(Device());
dispatcher.Invoke(masks, buffer.Buffer, offsets, compactedBuffer);
buffer.Buffer = compactedBuffer;
buffer.Size = newSize;
......
......@@ -22,18 +22,11 @@
#include <vtkm/rendering/vtkm_rendering_export.h>
#include <iomanip>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/rendering/raytracing/MeshConnectivityContainers.h>
#include <vtkm/rendering/raytracing/PartialComposite.h>
#ifndef CELL_SHAPE_ZOO
#define CELL_SHAPE_ZOO 255
#endif
#ifndef CELL_SHAPE_STRUCTURED
#define CELL_SHAPE_STRUCTURED 254
#endif
namespace vtkm
{
......@@ -68,26 +61,29 @@ public:
ExitDist = &Distance2;
}
template <typename Device>
void Compact(vtkm::cont::ArrayHandle<FloatType>& compactedDistances,
vtkm::cont::ArrayHandle<UInt8>& masks,
Device);
vtkm::cont::ArrayHandle<UInt8>& masks);
template <typename Device>
void Init(const vtkm::Id size, vtkm::cont::ArrayHandle<FloatType>& distances, Device);
void Init(const vtkm::Id size, vtkm::cont::ArrayHandle<FloatType>& distances);
void Swap();
};
} //namespace detail
class ConnectivityTracer
/**
* \brief ConnectivityTracer is volumetric ray tracer for unstructured
* grids. Capabilities include volume rendering and integrating
* absorption and emission of N energy groups for simulated
* radiograhy.
*/
class VTKM_RENDERING_EXPORT ConnectivityTracer
{
public:
ConnectivityTracer()
: MeshContainer(nullptr)
, CountRayStatus(false)
, UnitScalar(1.f)
{
}
......@@ -120,57 +116,75 @@ public:
void SetSampleDistance(const vtkm::Float32& distance);
void SetColorMap(const vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>>& colorMap);
void Trace(Ray<vtkm::Float32>& rays);
void Trace(Ray<vtkm::Float64>& rays);
MeshConnContainer* GetMeshContainer() { return MeshContainer; }
void Init();
void SetDebugOn(bool on) { CountRayStatus = on; }
void SetUnitScalar(const vtkm::Float32 unitScalar) { UnitScalar = unitScalar; }
vtkm::Id GetNumberOfMeshCells() const;
void ResetTimers();
void LogTimers();
///
/// Traces rays fully through the mesh. Rays can exit and re-enter
/// multiple times before leaving the domain. This is fast path for
/// structured meshs or meshes that are not interlocking.
/// Note: rays will be compacted
///
template <typename FloatType>
void FullTrace(Ray<FloatType>& rays);
///
/// Integrates rays through the mesh. If rays leave the mesh and
/// re-enter, then those become two separate partial composites.
/// This is need to support domain decompositions that are like
/// puzzle pieces. Note: rays will be compacted
///
template <typename FloatType>
std::vector<PartialComposite<FloatType>> PartialTrace(Ray<FloatType>& rays);
///
/// Integrates the active rays though the mesh until all rays
/// have exited.
/// Precondition: rays.HitIdx is set to a valid mesh cell
///
template <typename FloatType>
void IntegrateMeshSegment(Ray<FloatType>& rays);
///
/// Find the entry point in the mesh
///
template <typename FloatType>
void FindMeshEntry(Ray<FloatType>& rays);
private:
friend struct detail::RenderFunctor;
template <typename FloatType, typename Device>
void IntersectCell(Ray<FloatType>& rays,
detail::RayTracking<FloatType>& tracker,
const MeshConnectivityBase* meshConn,
Device);
template <typename FloatType>
void IntersectCell(Ray<FloatType>& rays, detail::RayTracking<FloatType>& tracker);
template <typename FloatType, typename Device>
void AccumulatePathLengths(Ray<FloatType>& rays, detail::RayTracking<FloatType>& tracker, Device);
template <typename FloatType>
void AccumulatePathLengths(Ray<FloatType>& rays, detail::RayTracking<FloatType>& tracker);
template <typename FloatType, typename Device>
void FindLostRays(Ray<FloatType>& rays,
detail::RayTracking<FloatType>& tracker,
const MeshConnectivityBase* meshConn,
Device);
template <typename FloatType>
void FindLostRays(Ray<FloatType>& rays, detail::RayTracking<FloatType>& tracker);
template <typename FloatType, typename Device>
void SampleCells(Ray<FloatType>& rays,
detail::RayTracking<FloatType>& tracker,
const MeshConnectivityBase* meshConn,
Device);
template <typename FloatType>
void SampleCells(Ray<FloatType>& rays, detail::RayTracking<FloatType>& tracker);
template <typename FloatType, typename Device>
void IntegrateCells(Ray<FloatType>& rays, detail::RayTracking<FloatType>& tracker, Device);
template <typename FloatType>
void IntegrateCells(Ray<FloatType>& rays, detail::RayTracking<FloatType>& tracker);
template <typename FloatType, typename Device>
void OffsetMinDistances(Ray<FloatType>& rays, Device);
template <typename FloatType>
void OffsetMinDistances(Ray<FloatType>& rays);
template <typename FloatType, typename Device>
void PrintRayStatus(Ray<FloatType>& rays, Device);
template <typename FloatType>
void PrintRayStatus(Ray<FloatType>& rays);
protected:
template <typename Device, typename FloatType>
void RenderOnDevice(Ray<FloatType>& rays, Device);
// Data set info
vtkm::cont::Field ScalarField;
vtkm::cont::Field EmissionField;
......@@ -180,7 +194,6 @@ protected:
vtkm::Float32 BoundingBox[6];
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>> ColorMap;
vtkm::cont::ArrayHandle<vtkm::Id> PreviousCellIds;
vtkm::Vec<vtkm::Float32, 4> BackgroundColor;
vtkm::Float32 SampleDistance;
......@@ -204,6 +217,7 @@ protected:
vtkm::Float64 SampleTime;
vtkm::Float64 LostRayTime;
vtkm::Float64 MeshEntryTime;
vtkm::Float32 UnitScalar;
}; // class ConnectivityTracer<CellType,ConnectivityType>
}
......
This diff is collapsed.
......@@ -34,8 +34,126 @@ namespace raytracing
namespace detail
{
class FindCylinderAABBs : public vtkm::worklet::WorkletMapField
{
public:
VTKM_CONT
FindCylinderAABBs() {}
typedef void ControlSignature(FieldIn<>,
FieldIn<>,
FieldOut<>,
FieldOut<>,
FieldOut<>,
FieldOut<>,
FieldOut<>,
FieldOut<>,
WholeArrayIn<Vec3RenderingTypes>);
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6, _7, _8, _9);
template <typename PointPortalType>
VTKM_EXEC void operator()(const vtkm::Id3 cylId,
const vtkm::Float32& radius,
vtkm::Float32& xmin,
vtkm::Float32& ymin,
vtkm::Float32& zmin,