Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-10-06 10:29:00 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Merge topic 'scalar_renderer'

Browse Source 
33a154337 add deprecation
a7363c283 alter interface of scalar renderer result
5fc77cb58 warnings and store depth separately
aa468f5c0 more warning fixes
0943784c2 fix warning
094758e55 make result public?
70584ac8f fix benchmarks
458be65e9 fix logic error
...

Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: Kenneth Moreland <kmorel@sandia.gov>
Merge-request: !1962
This commit is contained in:
Matt Larsen 2020-03-21 14:27:59 +00:00 committed by Kitware Robot
commit d9cfb8687f
19 changed files with 653 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
benchmarking/BenchmarkRayTracing.cxx
View File

@ -64,7 +64,7 @@ void BenchRayTracing(::benchmark::State& state)
vtkm::rendering::CanvasRayTracer canvas(1920, 1080);
vtkm::rendering::raytracing::Camera rayCamera;
rayCamera.SetParameters(camera, canvas);
rayCamera.SetParameters(camera, vtkm::Int32(canvas.GetWidth()), vtkm::Int32(canvas.GetHeight()));
vtkm::rendering::raytracing::Ray<vtkm::Float32> rays;
rayCamera.CreateRays(rays, coords.GetBounds());

3
vtkm/rendering/CMakeLists.txt
View File

@ -63,6 +63,7 @@ set(headers
MapperConnectivity.h
MapperWireframer.h
Quadralizer.h
ScalarRenderer.h
TextAnnotation.h
TextAnnotationBillboard.h
TextAnnotationScreen.h
@ -109,6 +110,7 @@ set(device_sources
MapperRayTracer.cxx
MapperVolume.cxx
MapperWireframer.cxx
ScalarRenderer.cxx
Scene.cxx
TextAnnotation.cxx
TextAnnotationBillboard.cxx
@ -133,6 +135,7 @@ set(device_sources
raytracing/QuadIntersector.cxx
raytracing/RayTracer.cxx
raytracing/RayOperations.cxx
raytracing/ScalarRenderer.cxx
raytracing/ShapeIntersector.cxx
raytracing/SphereExtractor.cxx
raytracing/SphereIntersector.cxx

3
vtkm/rendering/ConnectivityProxy.cxx
View File

@ -215,7 +215,8 @@ public:
throw vtkm::cont::ErrorBadValue("Conn Proxy: null canvas");
}
vtkm::rendering::raytracing::Camera rayCamera;
rayCamera.SetParameters(camera, *canvas);
rayCamera.SetParameters(
camera, (vtkm::Int32)canvas->GetWidth(), (vtkm::Int32)canvas->GetHeight());
vtkm::rendering::raytracing::Ray<vtkm::Float32> rays;
rayCamera.CreateRays(rays, this->Coords.GetBounds());
rays.Buffers.at(0).InitConst(0.f);

7
vtkm/rendering/MapperCylinder.cxx
View File

@ -182,9 +182,10 @@ void MapperCylinder::RenderCells(const vtkm::cont::DynamicCellSet& cellset,
//
// Create rays
//
vtkm::rendering::raytracing::Camera& cam = this->Internals->Tracer.GetCamera();
cam.SetParameters(camera, *this->Internals->Canvas);
this->Internals->RayCamera.SetParameters(camera, *this->Internals->Canvas);
vtkm::Int32 width = (vtkm::Int32) this->Internals->Canvas->GetWidth();
vtkm::Int32 height = (vtkm::Int32) this->Internals->Canvas->GetHeight();
this->Internals->RayCamera.SetParameters(camera, width, height);
this->Internals->RayCamera.CreateRays(this->Internals->Rays, shapeBounds);
this->Internals->Rays.Buffers.at(0).InitConst(0.f);

7
vtkm/rendering/MapperPoint.cxx
View File

@ -181,9 +181,10 @@ void MapperPoint::RenderCells(const vtkm::cont::DynamicCellSet& cellset,
//
// Create rays
//
vtkm::rendering::raytracing::Camera& cam = this->Internals->Tracer.GetCamera();
cam.SetParameters(camera, *this->Internals->Canvas);
this->Internals->RayCamera.SetParameters(camera, *this->Internals->Canvas);
vtkm::Int32 width = (vtkm::Int32) this->Internals->Canvas->GetWidth();
vtkm::Int32 height = (vtkm::Int32) this->Internals->Canvas->GetHeight();
this->Internals->RayCamera.SetParameters(camera, width, height);
this->Internals->RayCamera.CreateRays(this->Internals->Rays, shapeBounds);
this->Internals->Rays.Buffers.at(0).InitConst(0.f);

7
vtkm/rendering/MapperQuad.cxx
View File

@ -103,9 +103,10 @@ void MapperQuad::RenderCells(const vtkm::cont::DynamicCellSet& cellset,
//
// Create rays
//
vtkm::rendering::raytracing::Camera& cam = this->Internals->Tracer.GetCamera();
cam.SetParameters(camera, *this->Internals->Canvas);
this->Internals->RayCamera.SetParameters(camera, *this->Internals->Canvas);
vtkm::Int32 width = (vtkm::Int32) this->Internals->Canvas->GetWidth();
vtkm::Int32 height = (vtkm::Int32) this->Internals->Canvas->GetHeight();
this->Internals->RayCamera.SetParameters(camera, width, height);
this->Internals->RayCamera.CreateRays(this->Internals->Rays, shapeBounds);
this->Internals->Rays.Buffers.at(0).InitConst(0.f);

7
vtkm/rendering/MapperRayTracer.cxx
View File

@ -107,9 +107,10 @@ void MapperRayTracer::RenderCells(const vtkm::cont::DynamicCellSet& cellset,
//
// Create rays
//
vtkm::rendering::raytracing::Camera& cam = this->Internals->Tracer.GetCamera();
cam.SetParameters(camera, *this->Internals->Canvas);
this->Internals->RayCamera.SetParameters(camera, *this->Internals->Canvas);
vtkm::Int32 width = (vtkm::Int32) this->Internals->Canvas->GetWidth();
vtkm::Int32 height = (vtkm::Int32) this->Internals->Canvas->GetHeight();
this->Internals->RayCamera.SetParameters(camera, width, height);
this->Internals->RayCamera.CreateRays(this->Internals->Rays, shapeBounds);
this->Internals->Rays.Buffers.at(0).InitConst(0.f);

2
vtkm/rendering/MapperRayTracer.h
View File

@ -47,8 +47,6 @@ public:
private:
struct InternalsType;
std::shared_ptr<InternalsType> Internals;
struct RenderFunctor;
};
}
} //namespace vtkm::rendering

6
vtkm/rendering/MapperVolume.cxx
View File

@ -14,7 +14,6 @@
#include <vtkm/cont/TryExecute.h>
#include <vtkm/rendering/CanvasRayTracer.h>
#include <vtkm/rendering/raytracing/Camera.h>
#include <vtkm/rendering/raytracing/Logger.h>
#include <vtkm/rendering/raytracing/RayOperations.h>
@ -103,7 +102,10 @@ void MapperVolume::RenderCells(const vtkm::cont::DynamicCellSet& cellset,
vtkm::rendering::raytracing::Camera rayCamera;
vtkm::rendering::raytracing::Ray<vtkm::Float32> rays;
rayCamera.SetParameters(camera, *this->Internals->Canvas);
vtkm::Int32 width = (vtkm::Int32) this->Internals->Canvas->GetWidth();
vtkm::Int32 height = (vtkm::Int32) this->Internals->Canvas->GetHeight();
rayCamera.SetParameters(camera, width, height);
rayCamera.CreateRays(rays, coords.GetBounds());
rays.Buffers.at(0).InitConst(0.f);

217
vtkm/rendering/ScalarRenderer.cxx Normal file
View File

@ -0,0 +1,217 @@
//============================================================================
// 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.
//============================================================================
#include <vtkm/rendering/ScalarRenderer.h>
#include <vtkm/cont/Timer.h>
#include <vtkm/cont/TryExecute.h>
#include <vtkm/rendering/CanvasRayTracer.h>
#include <vtkm/rendering/raytracing/Camera.h>
#include <vtkm/rendering/raytracing/Logger.h>
#include <vtkm/rendering/raytracing/RayOperations.h>
#include <vtkm/rendering/raytracing/ScalarRenderer.h>
#include <vtkm/rendering/raytracing/SphereExtractor.h>
#include <vtkm/rendering/raytracing/SphereIntersector.h>
#include <vtkm/rendering/raytracing/TriangleExtractor.h>
namespace vtkm
{
namespace rendering
{
struct ScalarRenderer::InternalsType
{
bool ValidDataSet;
vtkm::Int32 Width;
vtkm::Int32 Height;
vtkm::Float32 DefaultValue;
vtkm::cont::DataSet DataSet;
vtkm::rendering::raytracing::ScalarRenderer Tracer;
vtkm::Bounds ShapeBounds;
VTKM_CONT
InternalsType()
: ValidDataSet(false)
, Width(1024)
, Height(1024)
, DefaultValue(vtkm::Nan32())
{
}
};
ScalarRenderer::ScalarRenderer()
: Internals(new InternalsType)
{
}
ScalarRenderer::~ScalarRenderer()
{
}
void ScalarRenderer::SetWidth(const vtkm::Int32 width)
{
if (width < 1)
{
throw vtkm::cont::ErrorBadValue("ScalarRenderer: width must be greater than 0");
}
Internals->Width = width;
}
void ScalarRenderer::SetDefaultValue(const vtkm::Float32 value)
{
Internals->DefaultValue = value;
}
void ScalarRenderer::SetHeight(const vtkm::Int32 height)
{
if (height < 1)
{
throw vtkm::cont::ErrorBadValue("ScalarRenderer: height must be greater than 0");
}
Internals->Height = height;
}
void ScalarRenderer::SetInput(vtkm::cont::DataSet& dataSet)
{
this->Internals->DataSet = dataSet;
this->Internals->ValidDataSet = true;
raytracing::TriangleExtractor triExtractor;
vtkm::cont::DynamicCellSet cellSet = this->Internals->DataSet.GetCellSet();
vtkm::cont::CoordinateSystem coords = this->Internals->DataSet.GetCoordinateSystem();
triExtractor.ExtractCells(cellSet);
if (triExtractor.GetNumberOfTriangles() > 0)
{
auto triIntersector = std::make_shared<raytracing::TriangleIntersector>();
triIntersector->SetData(coords, triExtractor.GetTriangles());
this->Internals->Tracer.SetShapeIntersector(triIntersector);
this->Internals->ShapeBounds = triIntersector->GetShapeBounds();
}
}
ScalarRenderer::Result ScalarRenderer::Render(const vtkm::rendering::Camera& camera)
{
if (!Internals->ValidDataSet)
{
throw vtkm::cont::ErrorBadValue("ScalarRenderer: input never set");
}
raytracing::Logger* logger = raytracing::Logger::GetInstance();
logger->OpenLogEntry("scalar_render");
vtkm::cont::Timer tot_timer;
tot_timer.Start();
vtkm::cont::Timer timer;
timer.Start();
//
// Create rays
//
vtkm::rendering::raytracing::Camera cam;
cam.SetParameters(camera, this->Internals->Width, this->Internals->Height);
vtkm::rendering::raytracing::Ray<vtkm::Float32> rays;
cam.CreateRays(rays, this->Internals->ShapeBounds);
rays.Buffers.at(0).InitConst(0.f);
// add fields
const vtkm::Id numFields = this->Internals->DataSet.GetNumberOfFields();
std::map<std::string, vtkm::Range> rangeMap;
for (vtkm::Id i = 0; i < numFields; ++i)
{
vtkm::cont::Field field = this->Internals->DataSet.GetField(i);
vtkm::cont::ArrayHandle<vtkm::Range> ranges;
ranges = field.GetRange();
vtkm::Id comps = ranges.GetNumberOfValues();
if (comps == 1)
{
rangeMap[field.GetName()] = ranges.GetPortalControl().Get(0);
this->Internals->Tracer.AddField(field);
}
}
this->Internals->Tracer.Render(rays, Internals->DefaultValue);
using ArrayF32 = vtkm::cont::ArrayHandle<vtkm::Float32>;
std::vector<ArrayF32> res;
std::vector<std::string> names;
const size_t numBuffers = rays.Buffers.size();
vtkm::Id expandSize = Internals->Width * Internals->Height;
for (size_t i = 0; i < numBuffers; ++i)
{
const std::string name = rays.Buffers[i].GetName();
if (name == "default")
continue;
raytracing::ChannelBuffer<vtkm::Float32> buffer = rays.Buffers[i];
raytracing::ChannelBuffer<vtkm::Float32> expanded =
buffer.ExpandBuffer(rays.PixelIdx, expandSize, Internals->DefaultValue);
res.push_back(expanded.Buffer);
names.push_back(name);
}
raytracing::ChannelBuffer<vtkm::Float32> depthChannel(1, rays.NumRays);
depthChannel.Buffer = rays.Distance;
raytracing::ChannelBuffer<vtkm::Float32> depthExpanded =
depthChannel.ExpandBuffer(rays.PixelIdx, expandSize, Internals->DefaultValue);
Result result;
result.Width = Internals->Width;
result.Height = Internals->Height;
result.Scalars = res;
result.ScalarNames = names;
result.Ranges = rangeMap;
result.Depths = depthExpanded.Buffer;
vtkm::Float64 time = timer.GetElapsedTime();
logger->AddLogData("write_to_canvas", time);
time = tot_timer.GetElapsedTime();
logger->CloseLogEntry(time);
return result;
}
vtkm::cont::DataSet ScalarRenderer::Result::ToDataSet()
{
if (Scalars.size() == 0)
{
throw vtkm::cont::ErrorBadValue("ScalarRenderer: result empty");
}
VTKM_ASSERT(Width > 0);
VTKM_ASSERT(Height > 0);
vtkm::cont::DataSet result;
vtkm::Vec<vtkm::Float32, 3> origin(0.f, 0.f, 0.f);
vtkm::Vec<vtkm::Float32, 3> spacing(1.f, 1.f, 1.f);
vtkm::Id3 dims(Width + 1, Height + 1, 1);
result.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coords", dims, origin, spacing));
vtkm::Id2 dims2(dims[0], dims[1]);
vtkm::cont::CellSetStructured<2> resCellSet;
resCellSet.SetPointDimensions(dims2);
result.SetCellSet(resCellSet);
const size_t fieldSize = Scalars.size();
for (size_t i = 0; i < fieldSize; ++i)
{
result.AddField(
vtkm::cont::Field(ScalarNames[i], vtkm::cont::Field::Association::CELL_SET, Scalars[i]));
}
result.AddField(vtkm::cont::Field("depth", vtkm::cont::Field::Association::CELL_SET, Depths));
return result;
}
}
} // vtkm::rendering

58
vtkm/rendering/ScalarRenderer.h Normal file
View File

@ -0,0 +1,58 @@
//============================================================================
// 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_rendering_ScalarRenderer_h
#define vtk_m_rendering_ScalarRenderer_h
#include <vtkm/cont/DataSet.h>
#include <vtkm/rendering/Camera.h>
#include <memory>
namespace vtkm
{
namespace rendering
{
class VTKM_RENDERING_EXPORT ScalarRenderer
{
public:
ScalarRenderer();
~ScalarRenderer();
void SetInput(vtkm::cont::DataSet& dataSet);
void SetWidth(const vtkm::Int32 width);
void SetHeight(const vtkm::Int32 height);
void SetDefaultValue(vtkm::Float32 value);
struct VTKM_RENDERING_EXPORT Result
{
vtkm::Int32 Width;
vtkm::Int32 Height;
vtkm::cont::ArrayHandle<vtkm::Float32> Depths;
std::vector<vtkm::cont::ArrayHandle<vtkm::Float32>> Scalars;
std::vector<std::string> ScalarNames;
std::map<std::string, vtkm::Range> Ranges;
vtkm::cont::DataSet ToDataSet();
};
ScalarRenderer::Result Render(const vtkm::rendering::Camera& camera);
private:
struct InternalsType;
std::shared_ptr<InternalsType> Internals;
};
}
} //namespace vtkm::rendering
#endif //vtk_m_rendering_ScalarRenderer_h

1
vtkm/rendering/raytracing/CMakeLists.txt
View File

@ -33,6 +33,7 @@ set(headers
RayTracer.h
RayTracingTypeDefs.h
Sampler.h
ScalarRenderer.h
ShapeIntersector.h
SphereExtractor.h
SphereIntersector.h

22
vtkm/rendering/raytracing/Camera.cxx
View File

@ -494,17 +494,31 @@ Camera::~Camera()
VTKM_CONT
void Camera::SetParameters(const vtkm::rendering::Camera& camera,
vtkm::rendering::CanvasRayTracer& canvas)
const vtkm::Int32 width,
const vtkm::Int32 height)
{
this->SetUp(camera.GetViewUp());
this->SetLookAt(camera.GetLookAt());
this->SetPosition(camera.GetPosition());
this->SetZoom(camera.GetZoom());
this->SetFieldOfView(camera.GetFieldOfView());
this->SetHeight(static_cast<vtkm::Int32>(canvas.GetHeight()));
this->SetWidth(static_cast<vtkm::Int32>(canvas.GetWidth()));
this->SetHeight(height);
this->SetWidth(width);
this->CameraView = camera;
}
VTKM_DEPRECATED(1.6, "Use the canvas width and height rather than the canvas itself.")
VTKM_CONT void Camera::SetParameters(const vtkm::rendering::Camera& camera,
vtkm::rendering::CanvasRayTracer& canvas)
{
this->SetUp(camera.GetViewUp());
this->SetLookAt(camera.GetLookAt());
this->SetPosition(camera.GetPosition());
this->SetZoom(camera.GetZoom());
this->SetFieldOfView(camera.GetFieldOfView());
this->SetHeight(vtkm::Int32(canvas.GetHeight()));
this->SetWidth(vtkm::Int32(canvas.GetWidth()));
this->CameraView = camera;
Canvas = canvas;
}

7
vtkm/rendering/raytracing/Camera.h
View File

@ -27,7 +27,6 @@ class VTKM_RENDERING_EXPORT Camera
private:
struct PixelDataFunctor;
vtkm::rendering::CanvasRayTracer Canvas;
vtkm::Int32 Height;
vtkm::Int32 Width;
vtkm::Int32 SubsetWidth;
@ -61,8 +60,12 @@ public:
VTKM_CONT
void SetParameters(const vtkm::rendering::Camera& camera,
vtkm::rendering::CanvasRayTracer& canvas);
const vtkm::Int32 width,
const vtkm::Int32 height);
VTKM_CONT
void SetParameters(const vtkm::rendering::Camera& camera,
vtkm::rendering::CanvasRayTracer& canvas);
VTKM_CONT
void SetHeight(const vtkm::Int32& height);

1
vtkm/rendering/raytracing/RayTracer.h
View File

@ -30,7 +30,6 @@ protected:
std::vector<std::shared_ptr<ShapeIntersector>> Intersectors;
Camera camera;
vtkm::cont::Field ScalarField;
vtkm::cont::ArrayHandle<vtkm::Float32> Scalars;
vtkm::Id NumberOfShapes;
vtkm::cont::ArrayHandle<vtkm::Vec4f_32> ColorMap;
vtkm::Range ScalarRange;

218
vtkm/rendering/raytracing/ScalarRenderer.cxx Normal file
View File

@ -0,0 +1,218 @@
//============================================================================
// 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.
//============================================================================
#include <vtkm/rendering/raytracing/ScalarRenderer.h>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
#include <vtkm/cont/ColorTable.h>
#include <vtkm/cont/Timer.h>
#include <vtkm/rendering/raytracing/Logger.h>
#include <vtkm/rendering/raytracing/RayTracingTypeDefs.h>
#include <vtkm/worklet/DispatcherMapField.h>
#include <vtkm/worklet/WorkletMapField.h>
namespace vtkm
{
namespace rendering
{
namespace raytracing
{
namespace detail
{
template <typename Precision>
class FilterDepth : public vtkm::worklet::WorkletMapField
{
private:
Precision MissScalar;
public:
VTKM_CONT
FilterDepth(const Precision missScalar)
: MissScalar(missScalar)
{
}
typedef void ControlSignature(FieldIn, FieldInOut);
typedef void ExecutionSignature(_1, _2);
VTKM_EXEC void operator()(const vtkm::Id& hitIndex, Precision& scalar) const
{
Precision value = scalar;
if (hitIndex < 0)
{
value = MissScalar;
}
scalar = value;
}
}; //class WriteBuffer
template <typename Precision>
class WriteBuffer : public vtkm::worklet::WorkletMapField
{
private:
Precision MissScalar;
public:
VTKM_CONT
WriteBuffer(const Precision missScalar)
: MissScalar(missScalar)
{
}
typedef void ControlSignature(FieldIn, FieldIn, FieldOut);
typedef void ExecutionSignature(_1, _2, _3);
VTKM_EXEC void operator()(const vtkm::Id& hitIndex,
const Precision& scalar,
Precision& output) const
{
Precision value = scalar;
if (hitIndex < 0)
{
value = MissScalar;
}
output = value;
}
}; //class WriteBuffer
template <typename Precision>
class WriteDepthBuffer : public vtkm::worklet::WorkletMapField
{
public:
VTKM_CONT
WriteDepthBuffer() {}
typedef void ControlSignature(FieldIn, FieldOut);
typedef void ExecutionSignature(_1, _2);
VTKM_EXEC void operator()(const Precision& depth, Precision& output) const { output = depth; }
}; //class WriteDepthBuffer
} // namespace detail
ScalarRenderer::ScalarRenderer()
: IntersectorValid(false)
{
}
ScalarRenderer::~ScalarRenderer()
{
}
void ScalarRenderer::SetShapeIntersector(std::shared_ptr<ShapeIntersector> intersector)
{
Intersector = intersector;
IntersectorValid = true;
}
void ScalarRenderer::AddField(const vtkm::cont::Field& scalarField)
{
vtkm::cont::ArrayHandle<vtkm::Range> ranges = scalarField.GetRange();
if (ranges.GetNumberOfValues() != 1)
{
throw vtkm::cont::ErrorBadValue("ScalarRenderer(AddField): field must be a scalar");
}
Ranges.push_back(ranges.GetPortalControl().Get(0));
Fields.push_back(scalarField);
}
void ScalarRenderer::Render(Ray<vtkm::Float32>& rays, vtkm::Float32 missScalar)
{
RenderOnDevice(rays, missScalar);
}
void ScalarRenderer::Render(Ray<vtkm::Float64>& rays, vtkm::Float64 missScalar)
{
RenderOnDevice(rays, missScalar);
}
template <typename Precision>
void ScalarRenderer::RenderOnDevice(Ray<Precision>& rays, Precision missScalar)
{
using Timer = vtkm::cont::Timer;
Logger* logger = Logger::GetInstance();
Timer renderTimer;
renderTimer.Start();
vtkm::Float64 time = 0.;
logger->OpenLogEntry("scalar_renderer");
logger->AddLogData("device", GetDeviceString());
logger->AddLogData("num_rays", rays.NumRays);
const size_t numFields = Fields.size();
if (numFields == 0)
{
throw vtkm::cont::ErrorBadValue("ScalarRenderer: no fields added");
}
if (!IntersectorValid)
{
throw vtkm::cont::ErrorBadValue("ScalarRenderer: intersector never set");
}
Timer timer;
timer.Start();
Intersector->IntersectRays(rays);
time = timer.GetElapsedTime();
logger->AddLogData("intersect", time);
for (size_t f = 0; f < numFields; ++f)
{
timer.Start();
Intersector->IntersectionData(rays, Fields[f], Ranges[f]);
time = timer.GetElapsedTime();
logger->AddLogData("intersection_data", time);
AddBuffer(rays, missScalar, Fields[f].GetName());
}
vtkm::worklet::DispatcherMapField<detail::FilterDepth<Precision>>(
detail::FilterDepth<Precision>(missScalar))
.Invoke(rays.HitIdx, rays.Distance);
time = renderTimer.GetElapsedTime();
logger->CloseLogEntry(time);
} // RenderOnDevice
template <typename Precision>
void ScalarRenderer::AddBuffer(Ray<Precision>& rays, Precision missScalar, const std::string name)
{
const vtkm::Int32 numChannels = 1;
ChannelBuffer<Precision> buffer(numChannels, rays.NumRays);
vtkm::worklet::DispatcherMapField<detail::WriteBuffer<Precision>>(
detail::WriteBuffer<Precision>(missScalar))
.Invoke(rays.HitIdx, rays.Scalar, buffer.Buffer);
buffer.SetName(name);
rays.Buffers.push_back(buffer);
}
template <typename Precision>
void ScalarRenderer::AddDepthBuffer(Ray<Precision>& rays)
{
const vtkm::Int32 numChannels = 1;
ChannelBuffer<Precision> buffer(numChannels, rays.NumRays);
vtkm::worklet::DispatcherMapField<detail::WriteDepthBuffer<Precision>>(
detail::WriteDepthBuffer<Precision>())
.Invoke(rays.Depth, buffer.Buffer);
buffer.SetName("depth");
rays.Buffers.push_back(buffer);
}
}
}
} // namespace vtkm::rendering::raytracing

66
vtkm/rendering/raytracing/ScalarRenderer.h Normal file
View File

@ -0,0 +1,66 @@
//============================================================================
// 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_rendering_raytracing_ScalarRenderer_h
#define vtk_m_rendering_raytracing_ScalarRenderer_h
#include <memory>
#include <vector>
#include <vtkm/cont/DataSet.h>
#include <vtkm/rendering/raytracing/Camera.h>
#include <vtkm/rendering/raytracing/TriangleIntersector.h>
namespace vtkm
{
namespace rendering
{
namespace raytracing
{
class VTKM_RENDERING_EXPORT ScalarRenderer
{
protected:
std::shared_ptr<ShapeIntersector> Intersector;
std::vector<vtkm::cont::Field> Fields;
std::vector<vtkm::Range> Ranges;
bool IntersectorValid;
template <typename Precision>
void RenderOnDevice(Ray<Precision>& rays, Precision missScalar);
template <typename Precision>
void AddBuffer(Ray<Precision>& rays, Precision missScalar, const std::string name);
template <typename Precision>
void AddDepthBuffer(Ray<Precision>& rays);
public:
VTKM_CONT
ScalarRenderer();
VTKM_CONT
~ScalarRenderer();
VTKM_CONT
void SetShapeIntersector(std::shared_ptr<ShapeIntersector> intersector);
VTKM_CONT
void AddField(const vtkm::cont::Field& scalarField);
VTKM_CONT
void Render(vtkm::rendering::raytracing::Ray<vtkm::Float32>& rays, vtkm::Float32 missScalar);
VTKM_CONT
void Render(vtkm::rendering::raytracing::Ray<vtkm::Float64>& rays, vtkm::Float64 missScalar);
}; //class RayTracer
}
}
} // namespace vtkm::rendering::raytracing
#endif //vtk_m_rendering_raytracing_RayTracer_h

1
vtkm/rendering/testing/CMakeLists.txt
View File

@ -24,6 +24,7 @@ set(unit_tests
UnitTestMapperRayTracer.cxx
UnitTestMapperWireframer.cxx
UnitTestMapperVolume.cxx
UnitTestScalarRenderer.cxx
)
vtkm_unit_tests(SOURCES ${unit_tests} ALL_BACKENDS LIBRARIES vtkm_rendering)

43
vtkm/rendering/testing/UnitTestScalarRenderer.cxx Normal file
View File

@ -0,0 +1,43 @@
//============================================================================
// 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.
//============================================================================
#include <vtkm/io/writer/VTKDataSetWriter.h>
#include <vtkm/rendering/ScalarRenderer.h>
#include <vtkm/rendering/testing/RenderTest.h>
namespace
{
void RenderTests()
{
vtkm::cont::testing::MakeTestDataSet maker;
vtkm::cont::DataSet dataset = maker.Make3DRegularDataSet0();
vtkm::Bounds bounds = dataset.GetCoordinateSystem().GetBounds();
vtkm::rendering::Camera camera;
camera.ResetToBounds(bounds);
camera.Azimuth(-40.f);
camera.Elevation(15.f);
vtkm::rendering::ScalarRenderer renderer;
renderer.SetInput(dataset);
vtkm::rendering::ScalarRenderer::Result res = renderer.Render(camera);
vtkm::cont::DataSet result = res.ToDataSet();
vtkm::io::writer::VTKDataSetWriter writer("scalar.vtk");
writer.WriteDataSet(result);
}
} //namespace
int UnitTestScalarRenderer(int argc, char* argv[])
{
return vtkm::cont::testing::Testing::Run(RenderTests, argc, argv);
}