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

Move Mappers to rendering library

Browse Source 
Also changed the mappers to not be templated on the device adapter.
Instead, use TryExecute to determine the device adapter at runtime.
This commit is contained in:
Kenneth Moreland 2016-08-29 15:50:47 -06:00
parent 111850ef08
commit 668f93a66b
18 changed files with 802 additions and 263 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/rendering/Rendering.cxx
View File

@ -138,7 +138,7 @@ main(int argc, char* argv[])
vtkm::rendering::Color bg(0.2f, 0.2f, 0.2f, 1.0f);
vtkm::rendering::CanvasGL canvas;
vtkm::rendering::MapperGL<VTKM_DEFAULT_DEVICE_ADAPTER_TAG> mapper;
vtkm::rendering::MapperGL mapper;
vtkm::rendering::Scene scene;
scene.AddActor(vtkm::rendering::Actor(ds.GetCellSet(),

6
vtkm/rendering/CMakeLists.txt
View File

@ -56,6 +56,11 @@ set(sources
ColorBarAnnotation.cxx
ColorTable.cxx
DecodePNG.cxx
Mapper.cxx
MapperRayTracer.cxx
MapperVolume.cxx
internal/RunTriangulator.cxx
)
set(opengl_headers
@ -67,6 +72,7 @@ set(opengl_headers
set(opengl_sources
CanvasGL.cxx
MapperGL.cxx
)
set(egl_headers

6
vtkm/rendering/CanvasRayTracer.cxx
View File

@ -60,6 +60,7 @@ struct ClearBuffersInvokeFunctor
ColorBufferType ColorBuffer;
DepthBufferType DepthBuffer;
VTKM_CONT_EXPORT
ClearBuffersInvokeFunctor(const vtkm::rendering::Color &backgroundColor,
const ColorBufferType &colorBuffer,
const DepthBufferType &depthBuffer)
@ -69,8 +70,11 @@ struct ClearBuffersInvokeFunctor
{ }
template<typename Device>
VTKM_CONT_EXPORT
bool operator()(Device) const
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::worklet::DispatcherMapField<ClearBuffers, Device>
dispatcher(this->Worklet);
dispatcher.Invoke( this->ColorBuffer, this->DepthBuffer);
@ -101,7 +105,7 @@ void CanvasRayTracer::Finish()
void CanvasRayTracer::Clear()
{
// TODO: Should the rendering library support policies or some other wayt to
// TODO: Should the rendering library support policies or some other way to
// configure with custom devices?
vtkm::cont::TryExecute(
internal::ClearBuffersInvokeFunctor(this->GetBackgroundColor(),

34
vtkm/rendering/Mapper.cxx Normal file
View File

@ -0,0 +1,34 @@
//============================================================================
// 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.
//
// Copyright 2016 Sandia Corporation.
// Copyright 2016 UT-Battelle, LLC.
// Copyright 2016 Los Alamos National Security.
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#include <vtkm/rendering/Mapper.h>
namespace vtkm {
namespace rendering {
Mapper::~Mapper() { }
void Mapper::SetActiveColorTable(const vtkm::rendering::ColorTable &colorTable)
{
colorTable.Sample(1024, this->ColorMap);
}
}
}

37
vtkm/rendering/Mapper.h
View File

@ -20,7 +20,6 @@
#ifndef vtk_m_rendering_Mapper_h
#define vtk_m_rendering_Mapper_h
#include <vtkm/cont/DataSet.h>
#include <vtkm/rendering/Camera.h>
#include <vtkm/rendering/Canvas.h>
#include <vtkm/rendering/ColorTable.h>
@ -35,9 +34,10 @@ public:
{
}
VTKM_CONT_EXPORT
virtual ~Mapper()
{}
VTKM_RENDERING_EXPORT
virtual ~Mapper();
VTKM_RENDERING_EXPORT
virtual void RenderCells(const vtkm::cont::DynamicCellSet &cellset,
const vtkm::cont::CoordinateSystem &coords,
@ -46,27 +46,16 @@ public:
const vtkm::rendering::Camera &camera,
const vtkm::Range &scalarRange) = 0;
VTKM_CONT_EXPORT
virtual void SetActiveColorTable(const ColorTable &ct)
{
ct.Sample(1024, ColorMap);
}
VTKM_RENDERING_EXPORT
virtual void SetActiveColorTable(const ColorTable &ct);
VTKM_RENDERING_EXPORT
virtual void StartScene() = 0;
VTKM_RENDERING_EXPORT
virtual void EndScene() = 0;
VTKM_RENDERING_EXPORT
virtual void SetCanvas(vtkm::rendering::Canvas *canvas) = 0;
VTKM_CONT_EXPORT
virtual void Render() {}
VTKM_CONT_EXPORT
virtual void Finish() {}
VTKM_CONT_EXPORT
virtual void StartScene()
{
}
VTKM_CONT_EXPORT
virtual void EndScene()
{
}
virtual void SetCanvas(Canvas *vtkmNotUsed(canvas))
{
}
protected:
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32,4> > ColorMap;
};

144
vtkm/rendering/MapperGL.cxx Normal file
View File

@ -0,0 +1,144 @@
//============================================================================
// 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.
//
// Copyright 2016 Sandia Corporation.
// Copyright 2016 UT-Battelle, LLC.
// Copyright 2016 Los Alamos National Security.
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#include <vtkm/rendering/MapperGL.h>
#include <vtkm/cont/TryExecute.h>
#include <vtkm/rendering/internal/OpenGLHeaders.h>
#include <vtkm/rendering/internal/RunTriangulator.h>
namespace vtkm {
namespace rendering {
namespace {
template <typename PtType>
VTKM_CONT_EXPORT
void RenderTriangles(vtkm::Id numTri, const PtType &verts,
const vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Id, 4> > &indices,
const vtkm::cont::ArrayHandle<vtkm::Float32> &scalar,
const vtkm::rendering::ColorTable &ct,
const vtkm::Range &scalarRange)
{
vtkm::Float32 sMin = vtkm::Float32(scalarRange.Min);
vtkm::Float32 sMax = vtkm::Float32(scalarRange.Max);
vtkm::Float32 sDiff = sMax-sMin;
glBegin(GL_TRIANGLES);
for (int i = 0; i < numTri; i++)
{
vtkm::Vec<vtkm::Id, 4> idx = indices.GetPortalConstControl().Get(i);
vtkm::Id i1 = idx[1];
vtkm::Id i2 = idx[2];
vtkm::Id i3 = idx[3];
vtkm::Vec<vtkm::Float32, 3> p1 = verts.GetPortalConstControl().Get(idx[1]);
vtkm::Vec<vtkm::Float32, 3> p2 = verts.GetPortalConstControl().Get(idx[2]);
vtkm::Vec<vtkm::Float32, 3> p3 = verts.GetPortalConstControl().Get(idx[3]);
vtkm::Float32 s = scalar.GetPortalConstControl().Get(i1);
s = (s-sMin)/sDiff;
Color color = ct.MapRGB(s);
glColor3f(color.Components[0], color.Components[1], color.Components[2]);
glVertex3f(p1[0],p1[1],p1[2]);
s = scalar.GetPortalConstControl().Get(i2);
s = (s-sMin)/sDiff;
color = ct.MapRGB(s);
glColor3f(color.Components[0], color.Components[1], color.Components[2]);
glVertex3f(p2[0],p2[1],p2[2]);
s = scalar.GetPortalConstControl().Get(i3);
s = (s-sMin)/sDiff;
color = ct.MapRGB(s);
glColor3f(color.Components[0], color.Components[1], color.Components[2]);
glVertex3f(p3[0],p3[1],p3[2]);
}
glEnd();
}
} // anonymous namespace
void MapperGL::RenderCells(const vtkm::cont::DynamicCellSet &cellset,
const vtkm::cont::CoordinateSystem &coords,
const vtkm::cont::Field &scalarField,
const vtkm::rendering::ColorTable &colorTable,
const vtkm::rendering::Camera &,
const vtkm::Range &scalarRange)
{
vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Id, 4> > indices;
vtkm::Id numTri;
vtkm::rendering::internal::RunTriangulator(cellset, indices, numTri);
vtkm::cont::ArrayHandle<vtkm::Float32> sf;
sf = scalarField.GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32> >();
vtkm::cont::DynamicArrayHandleCoordinateSystem dcoords = coords.GetData();
vtkm::cont::ArrayHandleUniformPointCoordinates uVerts;
vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32,3> > eVerts;
if(dcoords.IsSameType(vtkm::cont::ArrayHandleUniformPointCoordinates()))
{
uVerts = dcoords.Cast<vtkm::cont::ArrayHandleUniformPointCoordinates>();
RenderTriangles(numTri, uVerts, indices, sf, colorTable, scalarRange);
}
else if(dcoords.IsSameType(vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32,3> >()))
{
eVerts = dcoords.Cast<vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32,3> > > ();
RenderTriangles(numTri, eVerts, indices, sf, colorTable, scalarRange);
}
else if(dcoords.IsSameType(vtkm::cont::ArrayHandleCartesianProduct<
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<vtkm::FloatDefault> >()))
{
vtkm::cont::ArrayHandleCartesianProduct<
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<vtkm::FloatDefault> > rVerts;
rVerts = dcoords.Cast<vtkm::cont::ArrayHandleCartesianProduct<
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<vtkm::FloatDefault> > > ();
RenderTriangles(numTri, rVerts, indices, sf, colorTable, scalarRange);
}
glFinish();
glFlush();
}
void MapperGL::StartScene()
{
// Nothing needs to be done.
}
void MapperGL::EndScene()
{
// Nothing needs to be done.
}
void MapperGL::SetCanvas(vtkm::rendering::Canvas *)
{
// Nothing needs to be done.
}
}
} // namespace vtkm::rendering

116
vtkm/rendering/MapperGL.h
View File

@ -20,124 +20,36 @@
#ifndef vtk_m_rendering_MapperGL_h
#define vtk_m_rendering_MapperGL_h
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/CoordinateSystem.h>
#include <vtkm/cont/DynamicArrayHandle.h>
#include <vtkm/rendering/Camera.h>
#include <vtkm/rendering/ColorTable.h>
#include <vtkm/rendering/Mapper.h>
#include <vtkm/rendering/Triangulator.h>
#include <vtkm/rendering/internal/OpenGLHeaders.h>
#include <stdio.h>
#include <iostream>
#include <fstream>
namespace vtkm {
namespace rendering {
template<typename DeviceAdapter = VTKM_DEFAULT_DEVICE_ADAPTER_TAG>
class MapperGL : public Mapper
{
public:
VTKM_CONT_EXPORT
MapperGL() {}
VTKM_CONT_EXPORT
virtual void RenderCells(const vtkm::cont::DynamicCellSet &cellset,
const vtkm::cont::CoordinateSystem &coords,
const vtkm::cont::Field &scalarField,
const vtkm::rendering::ColorTable &colorTable,
const vtkm::rendering::Camera &,
const vtkm::Range &scalarRange)
{
vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Id, 4> > indices;
vtkm::Id numTri;
Triangulator<DeviceAdapter> triangulator;
triangulator.run(cellset, indices, numTri);
VTKM_RENDERING_EXPORT
void RenderCells(const vtkm::cont::DynamicCellSet &cellset,
const vtkm::cont::CoordinateSystem &coords,
const vtkm::cont::Field &scalarField,
const vtkm::rendering::ColorTable &colorTable,
const vtkm::rendering::Camera &,
const vtkm::Range &scalarRange) VTKM_OVERRIDE;
vtkm::cont::ArrayHandle<vtkm::Float32> sf;
sf = scalarField.GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32> >();
vtkm::cont::DynamicArrayHandleCoordinateSystem dcoords = coords.GetData();
vtkm::cont::ArrayHandleUniformPointCoordinates uVerts;
vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32,3> > eVerts;
if(dcoords.IsSameType(vtkm::cont::ArrayHandleUniformPointCoordinates()))
{
uVerts = dcoords.Cast<vtkm::cont::ArrayHandleUniformPointCoordinates>();
RenderTriangles(numTri, uVerts, indices, sf, colorTable, scalarRange);
}
else if(dcoords.IsSameType(vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32,3> >()))
{
eVerts = dcoords.Cast<vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32,3> > > ();
RenderTriangles(numTri, eVerts, indices, sf, colorTable, scalarRange);
}
else if(dcoords.IsSameType(vtkm::cont::ArrayHandleCartesianProduct<
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<vtkm::FloatDefault> >()))
{
vtkm::cont::ArrayHandleCartesianProduct<
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<vtkm::FloatDefault> > rVerts;
rVerts = dcoords.Cast<vtkm::cont::ArrayHandleCartesianProduct<
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<vtkm::FloatDefault> > > ();
RenderTriangles(numTri, rVerts, indices, sf, colorTable, scalarRange);
}
glFinish();
glFlush();
}
template <typename PtType>
VTKM_CONT_EXPORT
void RenderTriangles(vtkm::Id numTri, const PtType &verts,
const vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Id, 4> > &indices,
const vtkm::cont::ArrayHandle<vtkm::Float32> &scalar,
const vtkm::rendering::ColorTable &ct,
const vtkm::Range &scalarRange)
{
vtkm::Float32 sMin = vtkm::Float32(scalarRange.Min);
vtkm::Float32 sMax = vtkm::Float32(scalarRange.Max);
vtkm::Float32 sDiff = sMax-sMin;
glBegin(GL_TRIANGLES);
for (int i = 0; i < numTri; i++)
{
vtkm::Vec<vtkm::Id, 4> idx = indices.GetPortalConstControl().Get(i);
vtkm::Id i1 = idx[1];
vtkm::Id i2 = idx[2];
vtkm::Id i3 = idx[3];
vtkm::Vec<vtkm::Float32, 3> p1 = verts.GetPortalConstControl().Get(idx[1]);
vtkm::Vec<vtkm::Float32, 3> p2 = verts.GetPortalConstControl().Get(idx[2]);
vtkm::Vec<vtkm::Float32, 3> p3 = verts.GetPortalConstControl().Get(idx[3]);
vtkm::Float32 s = scalar.GetPortalConstControl().Get(i1);
s = (s-sMin)/sDiff;
Color color = ct.MapRGB(s);
glColor3f(color.Components[0], color.Components[1], color.Components[2]);
glVertex3f(p1[0],p1[1],p1[2]);
s = scalar.GetPortalConstControl().Get(i2);
s = (s-sMin)/sDiff;
color = ct.MapRGB(s);
glColor3f(color.Components[0], color.Components[1], color.Components[2]);
glVertex3f(p2[0],p2[1],p2[2]);
s = scalar.GetPortalConstControl().Get(i3);
s = (s-sMin)/sDiff;
color = ct.MapRGB(s);
glColor3f(color.Components[0], color.Components[1], color.Components[2]);
glVertex3f(p3[0],p3[1],p3[2]);
}
glEnd();
}
VTKM_RENDERING_EXPORT
void StartScene() VTKM_OVERRIDE;
VTKM_RENDERING_EXPORT
void EndScene() VTKM_OVERRIDE;
VTKM_RENDERING_EXPORT
void SetCanvas(vtkm::rendering::Canvas *canvas) VTKM_OVERRIDE;
};
}} //namespace vtkm::rendering

192
vtkm/rendering/MapperRayTracer.cxx Normal file
View File

@ -0,0 +1,192 @@
//============================================================================
// 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.
//
// Copyright 2016 Sandia Corporation.
// Copyright 2016 UT-Battelle, LLC.
// Copyright 2016 Los Alamos National Security.
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#include <vtkm/rendering/MapperRayTracer.h>
#include <vtkm/cont/TryExecute.h>
#include <vtkm/cont/internal/RuntimeDeviceTracker.h>
#include <vtkm/cont/internal/SimplePolymorphicContainer.h>
#include <vtkm/rendering/CanvasRayTracer.h>
#include <vtkm/rendering/internal/RunTriangulator.h>
#include <vtkm/rendering/raytracing/RayTracer.h>
#include <vtkm/rendering/raytracing/Camera.h>
namespace vtkm {
namespace rendering {
struct MapperRayTracer::InternalsType
{
vtkm::rendering::CanvasRayTracer *Canvas;
vtkm::cont::internal::RuntimeDeviceTracker DeviceTracker;
boost::shared_ptr<vtkm::cont::internal::SimplePolymorphicContainerBase>
RayTracerContainer;
VTKM_CONT_EXPORT
InternalsType()
: Canvas(nullptr)
{ }
template<typename Device>
VTKM_CONT_EXPORT
vtkm::rendering::raytracing::RayTracer<Device> *GetRayTracer(Device)
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
typedef vtkm::rendering::raytracing::RayTracer<Device> RayTracerType;
typedef vtkm::cont::internal::SimplePolymorphicContainer<RayTracerType>
ContainerType;
RayTracerType *tracer = NULL;
if (this->RayTracerContainer)
{
ContainerType *container =
dynamic_cast<ContainerType *>(this->RayTracerContainer.get());
if (container)
{
tracer = &container->Item;
}
}
if (tracer == NULL)
{
ContainerType *container
= new vtkm::cont::internal::SimplePolymorphicContainer<RayTracerType>;
tracer = &container->Item;
this->RayTracerContainer.reset(container);
}
return tracer;
}
};
MapperRayTracer::MapperRayTracer()
: Internals(new InternalsType)
{ }
void MapperRayTracer::SetCanvas(vtkm::rendering::Canvas *canvas)
{
if(canvas != nullptr)
{
this->Internals->Canvas = dynamic_cast<CanvasRayTracer*>(canvas);
if(this->Internals->Canvas == nullptr)
{
throw vtkm::cont::ErrorControlBadValue(
"Ray Tracer: bad canvas type. Must be CanvasRayTracer");
}
}
else
{
this->Internals->Canvas = nullptr;
}
}
struct MapperRayTracer::RenderFunctor
{
vtkm::rendering::MapperRayTracer *Self;
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4> > TriangleIndices;
vtkm::Id NumberOfTriangles;
vtkm::cont::CoordinateSystem Coordinates;
vtkm::cont::Field ScalarField;
vtkm::rendering::Camera Camera;
vtkm::Range ScalarRange;
VTKM_CONT_EXPORT
RenderFunctor(vtkm::rendering::MapperRayTracer *self,
const vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id,4> > &indices,
vtkm::Id numberOfTriangles,
const vtkm::cont::CoordinateSystem &coordinates,
const vtkm::cont::Field &scalarField,
const vtkm::rendering::Camera &camera,
const vtkm::Range &scalarRange)
: Self(self),
TriangleIndices(indices),
NumberOfTriangles(numberOfTriangles),
Coordinates(coordinates),
ScalarField(scalarField),
Camera(camera),
ScalarRange(scalarRange)
{ }
template<typename Device>
bool operator()(Device)
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::rendering::raytracing::RayTracer<Device> *tracer =
this->Self->Internals->GetRayTracer(Device());
tracer->GetCamera().SetParameters(this->Camera,
*this->Self->Internals->Canvas);
vtkm::Bounds dataBounds = this->Coordinates.GetBounds(Device());
tracer->SetData(this->Coordinates.GetData(),
this->TriangleIndices,
this->ScalarField,
this->NumberOfTriangles,
this->ScalarRange,
dataBounds);
tracer->SetColorMap(this->Self->ColorMap);
tracer->SetBackgroundColor(
this->Self->Internals->Canvas->GetBackgroundColor().Components);
tracer->Render(this->Self->Internals->Canvas);
return true;
}
};
void MapperRayTracer::RenderCells(
const vtkm::cont::DynamicCellSet &cellset,
const vtkm::cont::CoordinateSystem &coords,
const vtkm::cont::Field &scalarField,
const vtkm::rendering::ColorTable &vtkmNotUsed(colorTable),
const vtkm::rendering::Camera &camera,
const vtkm::Range &scalarRange)
{
vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Id, 4> > indices;
vtkm::Id numberOfTriangles;
vtkm::rendering::internal::RunTriangulator(
cellset, indices, numberOfTriangles, this->Internals->DeviceTracker);
RenderFunctor functor(this,
indices,
numberOfTriangles,
coords,
scalarField,
camera,
scalarRange);
vtkm::cont::TryExecute(functor,
this->Internals->DeviceTracker,
VTKM_DEFAULT_DEVICE_ADAPTER_LIST_TAG());
}
void MapperRayTracer::StartScene()
{
// Nothing needs to be done.
}
void MapperRayTracer::EndScene()
{
// Nothing needs to be done.
}
}
} // vtkm::rendering

84
vtkm/rendering/MapperRayTracer.h
View File

@ -19,82 +19,48 @@
//============================================================================
#ifndef vtk_m_rendering_MapperRayTracer_h
#define vtk_m_rendering_MapperRayTracer_h
#include <vtkm/cont/Timer.h>
#include <vtkm/cont/internal/DeviceAdapterTagSerial.h>
#include <vtkm/rendering/ColorTable.h>
#include <vtkm/rendering/Mapper.h>
#include <vtkm/rendering/Triangulator.h>
#include <vtkm/rendering/raytracing/RayTracer.h>
#include <vtkm/rendering/raytracing/Camera.h>
#include <vtkm/rendering/CanvasRayTracer.h>
#include <vtkm/rendering/Camera.h>
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/smart_ptr.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
namespace vtkm {
namespace rendering {
// static bool doOnce = true;
template<typename DeviceAdapter = VTKM_DEFAULT_DEVICE_ADAPTER_TAG>
class MapperRayTracer : public Mapper
{
protected:
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32,4> > ColorMap;
vtkm::rendering::raytracing::RayTracer<DeviceAdapter> Tracer;
CanvasRayTracer *Canvas;
public:
VTKM_CONT_EXPORT
MapperRayTracer()
{
this->Canvas = nullptr;
}
VTKM_CONT_EXPORT
void SetCanvas(vtkm::rendering::Canvas *canvas)
{
if(canvas != nullptr)
{
VTKM_RENDERING_EXPORT
MapperRayTracer();
this->Canvas = dynamic_cast<CanvasRayTracer*>(canvas);
if(this->Canvas == nullptr)
{
throw vtkm::cont::ErrorControlBadValue(
"Ray Tracer: bad canvas type. Must be CanvasRayTracer");
}
}
}
VTKM_CONT_EXPORT
void SetActiveColorTable(const ColorTable &colorTable)
{
colorTable.Sample(1024, ColorMap);
}
VTKM_RENDERING_EXPORT
void SetCanvas(vtkm::rendering::Canvas *canvas) VTKM_OVERRIDE;
VTKM_CONT_EXPORT
VTKM_RENDERING_EXPORT
void RenderCells(const vtkm::cont::DynamicCellSet &cellset,
const vtkm::cont::CoordinateSystem &coords,
const vtkm::cont::Field &scalarField,
const vtkm::rendering::ColorTable &vtkmNotUsed(colorTable),
const vtkm::rendering::ColorTable &colorTable,
const vtkm::rendering::Camera &camera,
const vtkm::Range &scalarRange)
{
const vtkm::Range &scalarRange) VTKM_OVERRIDE;
const vtkm::cont::DynamicArrayHandleCoordinateSystem dynamicCoordsHandle = coords.GetData();
vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Id, 4> > indices;
this->Tracer.GetCamera().SetParameters(camera, *this->Canvas);
vtkm::Id numberOfTriangles;
VTKM_RENDERING_EXPORT
virtual void StartScene() VTKM_OVERRIDE;
VTKM_RENDERING_EXPORT
virtual void EndScene() VTKM_OVERRIDE;
vtkm::Bounds dataBounds = coords.GetBounds(DeviceAdapter());
private:
struct InternalsType;
boost::shared_ptr<InternalsType> Internals;
Triangulator<DeviceAdapter> triangulator;
triangulator.run(cellset, indices, numberOfTriangles);//,dynamicCoordsHandle,dataBounds);
this->Tracer.SetData(dynamicCoordsHandle,
indices,
scalarField,
numberOfTriangles,
scalarRange,
dataBounds);
this->Tracer.SetColorMap(this->ColorMap);
this->Tracer.SetBackgroundColor(
this->Canvas->GetBackgroundColor().Components);
this->Tracer.Render(this->Canvas);
}
struct RenderFunctor;
};
}} //namespace vtkm::rendering
}
} //namespace vtkm::rendering
#endif //vtk_m_rendering_MapperRayTracer_h

196
vtkm/rendering/MapperVolume.cxx Normal file
View File

@ -0,0 +1,196 @@
//============================================================================
// 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.
//
// Copyright 2016 Sandia Corporation.
// Copyright 2016 UT-Battelle, LLC.
// Copyright 2016 Los Alamos National Security.
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#include <vtkm/rendering/MapperVolume.h>
#include <vtkm/cont/TryExecute.h>
#include <vtkm/cont/internal/RuntimeDeviceTracker.h>
#include <vtkm/cont/internal/SimplePolymorphicContainer.h>
#include <vtkm/rendering/CanvasRayTracer.h>
#include <vtkm/rendering/internal/RunTriangulator.h>
#include <vtkm/rendering/raytracing/Camera.h>
#include <vtkm/rendering/raytracing/VolumeRendererStructured.h>
#include <typeinfo>
namespace vtkm {
namespace rendering {
struct MapperVolume::InternalsType
{
vtkm::rendering::CanvasRayTracer *Canvas;
vtkm::cont::internal::RuntimeDeviceTracker DeviceTracker;
boost::shared_ptr<vtkm::cont::internal::SimplePolymorphicContainerBase>
RayTracerContainer;
VTKM_CONT_EXPORT
InternalsType()
: Canvas(nullptr)
{ }
template<typename Device>
VTKM_CONT_EXPORT
vtkm::rendering::raytracing::VolumeRendererStructured<Device> *
GetRayTracer(Device)
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
typedef vtkm::rendering::raytracing::VolumeRendererStructured<Device>
RayTracerType;
typedef vtkm::cont::internal::SimplePolymorphicContainer<RayTracerType>
ContainerType;
RayTracerType *tracer = NULL;
if (this->RayTracerContainer)
{
ContainerType *container =
dynamic_cast<ContainerType *>(this->RayTracerContainer.get());
if (container)
{
tracer = &container->Item;
}
}
if (tracer == NULL)
{
ContainerType *container
= new vtkm::cont::internal::SimplePolymorphicContainer<RayTracerType>;
tracer = &container->Item;
this->RayTracerContainer.reset(container);
}
return tracer;
}
};
MapperVolume::MapperVolume()
: Internals(new InternalsType)
{ }
void MapperVolume::SetCanvas(vtkm::rendering::Canvas *canvas)
{
if(canvas != nullptr)
{
this->Internals->Canvas = dynamic_cast<CanvasRayTracer*>(canvas);
if(this->Internals->Canvas == nullptr)
{
throw vtkm::cont::ErrorControlBadValue(
"Ray Tracer: bad canvas type. Must be CanvasRayTracer");
}
}
else
{
this->Internals->Canvas = nullptr;
}
}
struct MapperVolume::RenderFunctor
{
vtkm::rendering::MapperVolume *Self;
vtkm::cont::CellSetStructured<3> CellSet;
vtkm::cont::CoordinateSystem Coordinates;
vtkm::cont::Field ScalarField;
vtkm::rendering::Camera Camera;
vtkm::Range ScalarRange;
VTKM_CONT_EXPORT
RenderFunctor(vtkm::rendering::MapperVolume *self,
const vtkm::cont::CellSetStructured<3> cellSet,
const vtkm::cont::CoordinateSystem &coordinates,
const vtkm::cont::Field &scalarField,
const vtkm::rendering::Camera &camera,
const vtkm::Range &scalarRange)
: Self(self),
CellSet(cellSet),
Coordinates(coordinates),
ScalarField(scalarField),
Camera(camera),
ScalarRange(scalarRange)
{ }
template<typename Device>
bool operator()(Device)
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::rendering::raytracing::VolumeRendererStructured<Device> *tracer =
this->Self->Internals->GetRayTracer(Device());
tracer->GetCamera().SetParameters(this->Camera,
*this->Self->Internals->Canvas);
vtkm::Bounds dataBounds = this->Coordinates.GetBounds(Device());
tracer->SetData(this->Coordinates,
this->ScalarField,
dataBounds,
this->CellSet,
this->ScalarRange);
tracer->SetColorMap(this->Self->ColorMap);
tracer->SetBackgroundColor(
this->Self->Internals->Canvas->GetBackgroundColor().Components);
tracer->Render(this->Self->Internals->Canvas);
return true;
}
};
void MapperVolume::RenderCells(
const vtkm::cont::DynamicCellSet &cellset,
const vtkm::cont::CoordinateSystem &coords,
const vtkm::cont::Field &scalarField,
const vtkm::rendering::ColorTable &vtkmNotUsed(colorTable),
const vtkm::rendering::Camera &camera,
const vtkm::Range &scalarRange)
{
if(!cellset.IsSameType(vtkm::cont::CellSetStructured<3>()))
{
std::cerr<<"ERROR cell set type not currently supported\n";
std::string theType = typeid(cellset).name();
std::cerr<<"Type : "<<theType<<std::endl;
}
else
{
RenderFunctor functor(this,
cellset.Cast<vtkm::cont::CellSetStructured<3> >(),
coords,
scalarField,
camera,
scalarRange);
vtkm::cont::TryExecute(functor,
this->Internals->DeviceTracker,
VTKM_DEFAULT_DEVICE_ADAPTER_LIST_TAG());
}
}
void MapperVolume::StartScene()
{
// Nothing needs to be done.
}
void MapperVolume::EndScene()
{
// Nothing needs to be done.
}
}
} // namespace vtkm::rendering

88
vtkm/rendering/MapperVolume.h
View File

@ -20,87 +20,45 @@
#ifndef vtk_m_rendering_MapperVolume_h
#define vtk_m_rendering_MapperVolume_h
#include <vtkm/rendering/Camera.h>
#include <vtkm/rendering/CanvasRayTracer.h>
#include <vtkm/rendering/ColorTable.h>
#include <vtkm/rendering/Mapper.h>
#include <vtkm/rendering/Triangulator.h>
#include <vtkm/rendering/raytracing/VolumeRendererStructured.h>
#include <vtkm/rendering/raytracing/Camera.h>
#include <typeinfo>
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/smart_ptr.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
namespace vtkm {
namespace rendering {
template<typename DeviceAdapter = VTKM_DEFAULT_DEVICE_ADAPTER_TAG>
class MapperVolume : public Mapper
{
protected:
vtkm::rendering::raytracing::VolumeRendererStructured<DeviceAdapter> Tracer;
CanvasRayTracer *Canvas;
public:
VTKM_CONT_EXPORT
MapperVolume()
{
this->Canvas = nullptr;
}
VTKM_RENDERING_EXPORT
MapperVolume();
VTKM_CONT_EXPORT
void SetNumberOfSamples(const vtkm::Int32 &numSamples)
{
Tracer.SetNumberOfSamples(numSamples);
}
VTKM_RENDERING_EXPORT
void SetCanvas(vtkm::rendering::Canvas *canvas) VTKM_OVERRIDE;
VTKM_CONT_EXPORT
void SetCanvas(vtkm::rendering::Canvas *canvas)
{
if(canvas != nullptr)
{
this->Canvas = dynamic_cast<CanvasRayTracer*>(canvas);
if(this->Canvas == nullptr)
{
throw vtkm::cont::ErrorControlBadValue(
"Volume Render: bad canvas type. Must be CanvasRayTracer");
}
}
}
VTKM_CONT_EXPORT
VTKM_RENDERING_EXPORT
virtual void RenderCells(const vtkm::cont::DynamicCellSet &cellset,
const vtkm::cont::CoordinateSystem &coords,
const vtkm::cont::Field &scalarField,
const vtkm::rendering::ColorTable &, //colorTable
const vtkm::rendering::Camera &camera,
const vtkm::Range &scalarRange)
{
// vtkm::cont::DynamicArrayHandleCoordinateSystem dynamicCoordsHandle = coords.GetData();
vtkm::Bounds coordsBounds = coords.GetBounds(DeviceAdapter());
const vtkm::Range &scalarRange) VTKM_OVERRIDE;
if(!cellset.IsSameType(vtkm::cont::CellSetStructured<3>()))
{
std::cerr<<"ERROR cell set type not currently supported\n";
std::string theType = typeid(cellset).name();
std::cerr<<"Type : "<<theType<<std::endl;
}
else
{
vtkm::cont::CellSetStructured<3> cellSetStructured3D = cellset.Cast<vtkm::cont::CellSetStructured<3> >();
//vtkm::cont::ArrayHandleUniformPointCoordinates vertices;
//vertices = dynamicCoordsHandle.Cast<vtkm::cont::ArrayHandleUniformPointCoordinates>();
this->Tracer.GetCamera().SetParameters(camera, *this->Canvas);
this->Tracer.SetData(coords,
scalarField,
coordsBounds,
cellSetStructured3D,
scalarRange);
this->Tracer.SetColorMap(this->ColorMap);
this->Tracer.SetBackgroundColor(
this->Canvas->GetBackgroundColor().Components);
this->Tracer.Render(this->Canvas);
}
VTKM_RENDERING_EXPORT
virtual void StartScene() VTKM_OVERRIDE;
VTKM_RENDERING_EXPORT
virtual void EndScene() VTKM_OVERRIDE;
}
private:
struct InternalsType;
boost::shared_ptr<InternalsType> Internals;
struct RenderFunctor;
};
}} //namespace vtkm::rendering
}
} //namespace vtkm::rendering
#endif //vtk_m_rendering_MapperVolume_h

2
vtkm/rendering/Triangulator.h
View File

@ -457,7 +457,7 @@ public:
}
VTKM_CONT_EXPORT
void run(const vtkm::cont::DynamicCellSet &cellset,
void Run(const vtkm::cont::DynamicCellSet &cellset,
vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Id,4> > &outputIndices,
vtkm::Id &outputTriangles)
{

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

@ -20,6 +20,7 @@
set(headers
OpenGLHeaders.h
RunTriangulator.h
)
vtkm_declare_headers(${headers})

85
vtkm/rendering/internal/RunTriangulator.cxx Normal file
View File

@ -0,0 +1,85 @@
//============================================================================
// 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.
//
// Copyright 2016 Sandia Corporation.
// Copyright 2016 UT-Battelle, LLC.
// Copyright 2016 Los Alamos National Security.
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#include <vtkm/rendering/internal/RunTriangulator.h>
#include <vtkm/cont/TryExecute.h>
#include <vtkm/rendering/Triangulator.h>
namespace vtkm {
namespace rendering {
namespace internal {
namespace {
struct TriangulatorFunctor
{
vtkm::cont::DynamicCellSet CellSet;
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id,4> > Indices;
vtkm::Id NumberOfTriangles;
VTKM_CONT_EXPORT
TriangulatorFunctor(vtkm::cont::DynamicCellSet cellSet)
: CellSet(cellSet)
{ }
template<typename Device>
VTKM_CONT_EXPORT
bool operator()(Device)
{
vtkm::rendering::Triangulator<Device> triangulator;
triangulator.Run(this->CellSet, this->Indices, this->NumberOfTriangles);
return true;
}
};
} // anonymous namespace
void RunTriangulator(const vtkm::cont::DynamicCellSet &cellSet,
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id,4> > &indices,
vtkm::Id &numberOfTriangles,
vtkm::cont::internal::RuntimeDeviceTracker &tracker)
{
// TODO: Should the rendering library support policies or some other way to
// configure with custom devices?
TriangulatorFunctor triangulatorFunctor(cellSet);
if (!vtkm::cont::TryExecute(triangulatorFunctor,
tracker,
VTKM_DEFAULT_DEVICE_ADAPTER_LIST_TAG()))
{
throw vtkm::cont::ErrorExecution("Failed to execute triangulator.");
}
indices = triangulatorFunctor.Indices;
numberOfTriangles = triangulatorFunctor.NumberOfTriangles;
}
void RunTriangulator(const vtkm::cont::DynamicCellSet &cellSet,
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id,4> > &indices,
vtkm::Id &numberOfTriangles)
{
vtkm::cont::internal::RuntimeDeviceTracker tracker;
vtkm::rendering::internal::RunTriangulator(
cellSet, indices, numberOfTriangles, tracker);
}
}
}
} // namespace vtkm::rendering::internal

52
vtkm/rendering/internal/RunTriangulator.h Normal file
View File

@ -0,0 +1,52 @@
//============================================================================
// 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.
//
// Copyright 2016 Sandia Corporation.
// Copyright 2016 UT-Battelle, LLC.
// Copyright 2016 Los Alamos National Security.
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_rendering_internal_RunTriangulator_h
#define vtk_m_rendering_internal_RunTriangulator_h
#include <vtkm/rendering/vtkm_rendering_export.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/DynamicCellSet.h>
#include <vtkm/cont/internal/RuntimeDeviceTracker.h>
namespace vtkm {
namespace rendering {
namespace internal {
/// This is a wrapper around the Triangulator worklet so that the
/// implementation of the triangulator only gets compiled once. This function
/// really is a stop-gap. Eventually, the Triangulator should be moved to
/// filters, and filters should be compiled in a library (for the same reason).
///
VTKM_RENDERING_EXPORT
void RunTriangulator(const vtkm::cont::DynamicCellSet &cellSet,
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id,4> > &indices,
vtkm::Id &numberOfTriangles);
VTKM_RENDERING_EXPORT
void RunTriangulator(const vtkm::cont::DynamicCellSet &cellSet,
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id,4> > &indices,
vtkm::Id &numberOfTriangles,
vtkm::cont::internal::RuntimeDeviceTracker &tracker);
}
}
} // namespace vtkm::rendering::internal
#endif //vtk_m_rendering_internal_RunTriangulator_h

2
vtkm/rendering/testing/UnitTestMapperRayTracer.cxx
View File

@ -53,7 +53,7 @@ void Render(const vtkm::cont::DataSet &ds,
{
const vtkm::Int32 W = 512, H = 512;
const vtkm::cont::CoordinateSystem coords = ds.GetCoordinateSystem();
vtkm::rendering::MapperRayTracer<VTKM_DEFAULT_DEVICE_ADAPTER_TAG> mapper;
vtkm::rendering::MapperRayTracer mapper;
vtkm::rendering::Camera camera;
Set3DView(camera, coords);

2
vtkm/rendering/testing/UnitTestMapperVolume.cxx
View File

@ -54,7 +54,7 @@ void Render(const vtkm::cont::DataSet &ds,
{
const vtkm::Int32 W = 512, H = 512;
const vtkm::cont::CoordinateSystem coords = ds.GetCoordinateSystem();
vtkm::rendering::MapperVolume<VTKM_DEFAULT_DEVICE_ADAPTER_TAG> mapper;
vtkm::rendering::MapperVolume mapper;
vtkm::rendering::Camera camera;
Set3DView(camera, coords);

16
vtkm/rendering/testing/glfw/UnitTestMapperGLFW.cxx
View File

@ -49,10 +49,10 @@ void RenderTests()
{
std::cout<<"Press any key to cycle through datasets. ESC to quit."<<std::endl;
typedef vtkm::rendering::MapperGL<VTKM_DEFAULT_DEVICE_ADAPTER_TAG> M;
typedef vtkm::rendering::CanvasGL C;
typedef vtkm::rendering::View3D V3;
typedef vtkm::rendering::View2D V2;
typedef vtkm::rendering::MapperGL MapperType;
typedef vtkm::rendering::CanvasGL CanvasType;
typedef vtkm::rendering::View3D View3DType;
typedef vtkm::rendering::View2D View2DType;
vtkm::cont::testing::MakeTestDataSet maker;
vtkm::rendering::ColorTable colorTable("thermal");
@ -67,16 +67,16 @@ void RenderTests()
glfwPollEvents();
if (which == 0)
vtkm::rendering::testing::Render<M,C,V3>(maker.Make3DRegularDataSet0(),
vtkm::rendering::testing::Render<MapperType,CanvasType,View3DType>(maker.Make3DRegularDataSet0(),
"pointvar", colorTable, "reg3D.pnm");
else if (which == 1)
vtkm::rendering::testing::Render<M,C,V3>(maker.Make3DRectilinearDataSet0(),
vtkm::rendering::testing::Render<MapperType,CanvasType,View3DType>(maker.Make3DRectilinearDataSet0(),
"pointvar", colorTable, "rect3D.pnm");
else if (which == 2)
vtkm::rendering::testing::Render<M,C,V3>(maker.Make3DExplicitDataSet4(),
vtkm::rendering::testing::Render<MapperType,CanvasType,View3DType>(maker.Make3DExplicitDataSet4(),
"pointvar", colorTable, "expl3D.pnm");
else if (which == 3)
vtkm::rendering::testing::Render<M,C,V2>(maker.Make2DRectilinearDataSet0(),
vtkm::rendering::testing::Render<MapperType,CanvasType,View2DType>(maker.Make2DRectilinearDataSet0(),
"pointvar", colorTable, "rect2D.pnm");
glfwSwapBuffers(window);