Shuenhoy/vtk-m2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove antiquated templated render test functions

Browse Source
This commit is contained in:
Kenneth Moreland 2021-12-29 14:12:11 -07:00
parent 0fe9300eed
commit c0fbe5f30f
28 changed files with 273 additions and 464 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
data/baseline/rendering/connectivity/explicit3D.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:198a1d211d4d19c9087ad2617156dd7b21e5d2ef59a21de142bbc2c0f043b528
size 70161

3
data/baseline/rendering/connectivity/rectilinear3D.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:e597b9f30fabcb92f708bbc78e30065280e9557a1e877e92fcbcbd5961946d1f
size 100273

3
data/baseline/rendering/connectivity/regular3D.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:f6c745a1187d7cb58a3846a3af0de38f779197a40ef288c8797eee4eb0cddec0
size 100510

3
data/baseline/rendering/multimapper/raytracer-connectivity.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:4d801ff92b3e8468d4c8b15f78b06a2c7b00a9be37d9f21ddef07e9d83ebedde
size 26081

3
data/baseline/rendering/multimapper/raytracer-volume.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:31484cd2cb07df4085bee3adbfc850bb61d84879367898a159a3bc4d6c92cc79
size 33352

3
data/baseline/rendering/point/cells.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:630de46cb5c3e21cade2b0cf0b6fd68574161283ff8383b1b5b7da8a8f096afa
size 24646

3
data/baseline/rendering/point/regular3D.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:4c26e2b4d8b9e34f2d2585a3e3760dc4ebfb55fc67853589be9151778f0bfd65
size 15964

3
data/baseline/rendering/point/variable_regular3D.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:fb46c3a59ab67deaf72b69fb3d282c1ab217d5bc6fff9f7eb2834b5349bc47b9
size 54889

3
data/baseline/rendering/quad/explicit3D.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:17b032ff1f2cf019b8cc39e5db2f823a8f5c1ceac5bf05ee7c2dd82d2097d19c
size 19720

3
data/baseline/rendering/quad/mixed3D.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:e9762ed54f5c45820a0e0321466813c805234908b8bc5de42d3069b750ba61c8
size 19067

3
data/baseline/rendering/quad/rectilinear3D.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:1252a96282b1713a57769d2b7d8bdf3d16f38ad2e02dfeb454e770d42679dedf
size 19398

3
data/baseline/rendering/quad/regular3D.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:da36149e1a86d54d2f051a48f06b1091306f3a5e972727287e18511371b125a7
size 19659

3
data/baseline/rendering/quad/uniform2D.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:c27cead7392df7591bb03418e0a6e97e2966577f630a43aad08e38dd93006543
size 26903

3
data/baseline/rendering/raytracer/explicit3D.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:4fcc277583c3896f666744a69885cce261e8b52e9ca965d861be4d3e1bc88f9f
size 68310

3
data/baseline/rendering/raytracer/rectilinear3D.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:b152032430e4c3cc700e93115b53fdcaf4f1908ae18cda69a505a0b11ba930a4
size 81045

3
data/baseline/rendering/raytracer/regular3D.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:77d298fc26c15b0446a092915ad4ba701a51467c52031f38b29de3ee903357ae
size 81406

3
data/baseline/rendering/raytracer/uniform2D.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:7463f11f7b3e0cb360764b8cf1a122ead519d39c2c1917df595b5159c06be377
size 77158

3
data/baseline/rendering/raytracer/vertex-cells.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:20ea460fd2b6af4b465f7f715ea65eba586cbc2562ac2caefbf3df9bdb6d3bcf
size 15883

3
data/baseline/rendering/volume/rectilinear3D.png Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:3a24175a16a60f3e917170907546a52de15e703bd06017fecd9c6238db9d2726
size 103177

44
vtkm/rendering/testing/RenderTest.cxx
View File

@ -12,6 +12,8 @@
#include <vtkm/rendering/Actor.h>
#include <vtkm/rendering/CanvasRayTracer.h>
#include <vtkm/rendering/MapperConnectivity.h>
#include <vtkm/rendering/MapperCylinder.h>
#include <vtkm/rendering/MapperPoint.h>
#include <vtkm/rendering/MapperQuad.h>
#include <vtkm/rendering/MapperRayTracer.h>
@ -69,6 +71,37 @@ void SetupView(vtkm::rendering::View1D& view,
view.SetLogY(options.LogY);
}
template <typename MapperType>
void SetupMapper(MapperType&, const vtkm::rendering::testing::RenderTestOptions&)
{
}
void SetupMapper(vtkm::rendering::MapperCylinder& mapper,
const vtkm::rendering::testing::RenderTestOptions& options)
{
mapper.UseVariableRadius(options.UseVariableRadius);
if (options.Radius >= 0)
{
mapper.SetRadius(options.Radius);
}
mapper.SetRadiusDelta(0.5);
}
void SetupMapper(vtkm::rendering::MapperPoint& mapper,
const vtkm::rendering::testing::RenderTestOptions& options)
{
mapper.UseVariableRadius(options.UseVariableRadius);
if (options.Radius >= 0)
{
mapper.SetRadius(options.Radius);
}
mapper.SetRadiusDelta(0.5);
if (options.RenderCells)
{
mapper.UseCells();
}
}
template <typename CanvasType, typename ViewType, typename MapperType>
void RenderTest(const DataSetFieldVector& dataSetsFields,
const std::string& outputFile,
@ -105,6 +138,7 @@ void RenderTest(const DataSetFieldVector& dataSetsFields,
}
MapperType mapper;
SetupMapper(mapper, options);
ViewType view(scene, mapper, canvas, options.Background, options.Foreground);
SetupView(view, bounds, fieldRange, options);
@ -135,6 +169,14 @@ void RenderTest(const DataSetFieldVector& dataSetsFields,
RenderTest<CanvasType, ViewType, vtkm::rendering::MapperRayTracer>(
dataSetsFields, outputFile, options);
break;
case vtkm::rendering::testing::MapperType::Connectivity:
RenderTest<CanvasType, ViewType, vtkm::rendering::MapperConnectivity>(
dataSetsFields, outputFile, options);
break;
case vtkm::rendering::testing::MapperType::Cylinder:
RenderTest<CanvasType, ViewType, vtkm::rendering::MapperCylinder>(
dataSetsFields, outputFile, options);
break;
case vtkm::rendering::testing::MapperType::Point:
RenderTest<CanvasType, ViewType, vtkm::rendering::MapperPoint>(
dataSetsFields, outputFile, options);
@ -151,8 +193,6 @@ void RenderTest(const DataSetFieldVector& dataSetsFields,
RenderTest<CanvasType, ViewType, vtkm::rendering::MapperWireframer>(
dataSetsFields, outputFile, options);
break;
default:
VTKM_TEST_FAIL("Invalid mapper type for 3D view.");
}
}

347
vtkm/rendering/testing/RenderTest.h
View File

@ -44,6 +44,8 @@ enum struct CanvasType
enum struct MapperType
{
RayTracer,
Connectivity,
Cylinder,
Point,
Quad,
Volume,
@ -99,6 +101,12 @@ struct RenderTestOptions
// Regardless of what device you are using for testing, you probably want to
// use the best available device for rendering.
bool AllowAnyDevice = true;
// Special options for some glyph-like mappers
bool UseVariableRadius = false;
vtkm::Float32 Radius = -1.0f;
vtkm::Float32 RadiusDelta = 0.5f;
bool RenderCells = false;
};
VTKM_RENDERING_TESTING_EXPORT
@ -112,345 +120,6 @@ void RenderTest(const std::vector<std::pair<vtkm::cont::DataSet, std::string>>&
const std::string& outputFile,
const RenderTestOptions& options = RenderTestOptions{});
template <typename ViewType>
inline void SetCamera(vtkm::rendering::Camera& camera,
const vtkm::Bounds& coordBounds,
const vtkm::cont::Field& field,
const vtkm::Float64& dataViewPadding = 0);
template <>
inline void SetCamera<vtkm::rendering::View3D>(vtkm::rendering::Camera& camera,
const vtkm::Bounds& coordBounds,
const vtkm::cont::Field&,
const vtkm::Float64& dataViewPadding)
{
vtkm::Bounds b = coordBounds;
camera = vtkm::rendering::Camera();
camera.ResetToBounds(b, dataViewPadding);
camera.Azimuth(static_cast<vtkm::Float32>(45.0));
camera.Elevation(static_cast<vtkm::Float32>(45.0));
}
template <>
inline void SetCamera<vtkm::rendering::View2D>(vtkm::rendering::Camera& camera,
const vtkm::Bounds& coordBounds,
const vtkm::cont::Field&,
const vtkm::Float64& dataViewPadding)
{
camera = vtkm::rendering::Camera(vtkm::rendering::Camera::MODE_2D);
camera.ResetToBounds(coordBounds, dataViewPadding);
camera.SetClippingRange(1.f, 100.f);
camera.SetViewport(-0.7f, +0.7f, -0.7f, +0.7f);
}
template <>
inline void SetCamera<vtkm::rendering::View1D>(vtkm::rendering::Camera& camera,
const vtkm::Bounds& coordBounds,
const vtkm::cont::Field& field,
const vtkm::Float64& dataViewPadding)
{
vtkm::Bounds bounds;
bounds.X = coordBounds.X;
field.GetRange(&bounds.Y);
camera = vtkm::rendering::Camera(vtkm::rendering::Camera::MODE_2D);
camera.ResetToBounds(bounds, dataViewPadding);
camera.SetClippingRange(1.f, 100.f);
camera.SetViewport(-0.7f, +0.7f, -0.7f, +0.7f);
}
template <typename MapperType, typename CanvasType, typename ViewType>
void Render(ViewType& view, const std::string& outputFile)
{
view.Paint();
view.SaveAs(outputFile);
}
// Different methods in which to create a View when provided with different
// field names, colors, and other utilities for testing 1D, 2D, and 3D views
// Testing Methods for working with what are normally 3D datasets
// --------------------------------------------------------------
template <typename MapperType, typename CanvasType, typename ViewType>
std::shared_ptr<ViewType> GetViewPtr(const vtkm::cont::DataSet& ds,
const std::string& fieldNm,
const CanvasType& canvas,
const MapperType& mapper,
vtkm::rendering::Scene& scene,
const vtkm::cont::ColorTable& colorTable,
const vtkm::Float64& dataViewPadding = 0)
{
scene.AddActor(vtkm::rendering::Actor(
ds.GetCellSet(), ds.GetCoordinateSystem(), ds.GetField(fieldNm), colorTable));
vtkm::rendering::Camera camera;
SetCamera<ViewType>(
camera, ds.GetCoordinateSystem().GetBounds(), ds.GetField(fieldNm), dataViewPadding);
vtkm::rendering::Color background(1.0f, 1.0f, 1.0f, 1.0f);
vtkm::rendering::Color foreground(0.0f, 0.0f, 0.0f, 1.0f);
auto view = std::make_shared<ViewType>(scene, mapper, canvas, camera, background, foreground);
// Print the title
std::unique_ptr<vtkm::rendering::TextAnnotationScreen> titleAnnotation(
new vtkm::rendering::TextAnnotationScreen(
"Test Plot", vtkm::rendering::Color(1, 1, 1, 1), .075f, vtkm::Vec2f_32(-.11f, .92f), 0.f));
view->AddTextAnnotation(std::move(titleAnnotation));
return view;
}
template <typename MapperType, typename CanvasType, typename ViewType>
void Render(const vtkm::cont::DataSet& ds,
const std::string& fieldNm,
const vtkm::cont::ColorTable& colorTable,
const std::string& outputFile,
const vtkm::Float64& dataViewPadding = 0)
{
MapperType mapper;
CanvasType canvas(512, 512);
vtkm::rendering::Scene scene;
auto view = GetViewPtr<MapperType, CanvasType, ViewType>(
ds, fieldNm, canvas, mapper, scene, colorTable, dataViewPadding);
Render<MapperType, CanvasType, ViewType>(*view, outputFile);
}
template <typename MapperType, typename CanvasType, typename ViewType>
void RenderAndRegressionTest(const vtkm::cont::DataSet& ds,
const std::string& fieldNm,
const vtkm::cont::ColorTable& colorTable,
const std::string& outputFile,
const bool& enableAnnotations = true,
const vtkm::Float64& dataViewPadding = 0,
const RenderTestOptions& options = RenderTestOptions{})
{
MapperType mapper;
CanvasType canvas(512, 512);
vtkm::rendering::Scene scene;
auto view = GetViewPtr<MapperType, CanvasType, ViewType>(
ds, fieldNm, canvas, mapper, scene, colorTable, dataViewPadding);
view->SetRenderAnnotationsEnabled(enableAnnotations);
VTKM_TEST_ASSERT(test_equal_images(*view,
outputFile,
options.AverageRadius,
options.PixelShiftRadius,
options.AllowedPixelErrorRatio,
options.Threshold));
}
// --------------------------------------------------------------
// Testing Methods for working with what are normally 2D datasets
// --------------------------------------------------------------
template <typename MapperType, typename CanvasType, typename ViewType>
std::shared_ptr<ViewType> GetViewPtr(const vtkm::cont::DataSet& ds,
const std::vector<std::string>& fields,
const std::vector<vtkm::rendering::Color>& colors,
const CanvasType& canvas,
const MapperType& mapper,
vtkm::rendering::Scene& scene,
const vtkm::Float64& dataViewPadding = 0)
{
size_t numFields = fields.size();
for (size_t i = 0; i < numFields; ++i)
{
scene.AddActor(vtkm::rendering::Actor(
ds.GetCellSet(), ds.GetCoordinateSystem(), ds.GetField(fields[i]), colors[i]));
}
vtkm::rendering::Camera camera;
SetCamera<ViewType>(
camera, ds.GetCoordinateSystem().GetBounds(), ds.GetField(fields[0]), dataViewPadding);
vtkm::rendering::Color background(1.0f, 1.0f, 1.0f, 1.0f);
vtkm::rendering::Color foreground(0.0f, 0.0f, 0.0f, 1.0f);
auto view = std::make_shared<ViewType>(scene, mapper, canvas, camera, background, foreground);
// Print the title
std::unique_ptr<vtkm::rendering::TextAnnotationScreen> titleAnnotation(
new vtkm::rendering::TextAnnotationScreen(
"Test Plot", vtkm::rendering::Color(1, 1, 1, 1), .075f, vtkm::Vec2f_32(-.11f, .92f), 0.f));
view->AddTextAnnotation(std::move(titleAnnotation));
return view;
}
template <typename MapperType, typename CanvasType, typename ViewType>
void Render(const vtkm::cont::DataSet& ds,
const std::vector<std::string>& fields,
const std::vector<vtkm::rendering::Color>& colors,
const std::string& outputFile,
const vtkm::Float64& dataViewPadding = 0)
{
MapperType mapper;
CanvasType canvas(512, 512);
canvas.SetBackgroundColor(vtkm::rendering::Color::white);
vtkm::rendering::Scene scene;
auto view = GetViewPtr<MapperType, CanvasType, ViewType>(
ds, fields, colors, canvas, mapper, scene, dataViewPadding);
Render<MapperType, CanvasType, ViewType>(*view, outputFile);
}
template <typename MapperType, typename CanvasType, typename ViewType>
void RenderAndRegressionTest(const vtkm::cont::DataSet& ds,
const std::vector<std::string>& fields,
const std::vector<vtkm::rendering::Color>& colors,
const std::string& outputFile,
const bool& enableAnnotations = true,
const vtkm::Float64& dataViewPadding = 0,
const RenderTestOptions& options = RenderTestOptions{})
{
MapperType mapper;
CanvasType canvas(512, 512);
canvas.SetBackgroundColor(vtkm::rendering::Color::white);
vtkm::rendering::Scene scene;
auto view = GetViewPtr<MapperType, CanvasType, ViewType>(
ds, fields, colors, canvas, mapper, scene, dataViewPadding);
view->SetRenderAnnotationsEnabled(enableAnnotations);
VTKM_TEST_ASSERT(test_equal_images(*view,
outputFile,
options.AverageRadius,
options.PixelShiftRadius,
options.AllowedPixelErrorRatio,
options.Threshold));
}
// --------------------------------------------------------------
// Testing Methods for working with what are normally 1D datasets
// --------------------------------------------------------------
template <typename MapperType, typename CanvasType, typename ViewType>
std::shared_ptr<ViewType> GetViewPtr(const vtkm::cont::DataSet& ds,
const std::string& fieldNm,
const CanvasType& canvas,
const MapperType& mapper,
vtkm::rendering::Scene& scene,
const vtkm::rendering::Color& color,
const bool logY = false,
const vtkm::Float64& dataViewPadding = 0)
{
//DRP Actor? no field? no colortable (or a constant colortable) ??
scene.AddActor(
vtkm::rendering::Actor(ds.GetCellSet(), ds.GetCoordinateSystem(), ds.GetField(fieldNm), color));
vtkm::rendering::Camera camera;
SetCamera<ViewType>(
camera, ds.GetCoordinateSystem().GetBounds(), ds.GetField(fieldNm), dataViewPadding);
vtkm::rendering::Color background(1.0f, 1.0f, 1.0f, 1.0f);
vtkm::rendering::Color foreground(0.0f, 0.0f, 0.0f, 1.0f);
auto view = std::make_shared<ViewType>(scene, mapper, canvas, camera, background, foreground);
// Print the title
std::unique_ptr<vtkm::rendering::TextAnnotationScreen> titleAnnotation(
new vtkm::rendering::TextAnnotationScreen(
"1D Test Plot", foreground, .1f, vtkm::Vec2f_32(-.27f, .87f), 0.f));
view->AddTextAnnotation(std::move(titleAnnotation));
view->SetLogY(logY);
return view;
}
template <typename MapperType, typename CanvasType, typename ViewType>
void Render(const vtkm::cont::DataSet& ds,
const std::string& fieldNm,
const vtkm::rendering::Color& color,
const std::string& outputFile,
const bool logY = false,
const vtkm::Float64& dataViewPadding = 0)
{
MapperType mapper;
CanvasType canvas(512, 512);
vtkm::rendering::Scene scene;
auto view = GetViewPtr<MapperType, CanvasType, ViewType>(
ds, fieldNm, canvas, mapper, scene, color, logY, dataViewPadding);
Render<MapperType, CanvasType, ViewType>(view, outputFile);
}
template <typename MapperType, typename CanvasType, typename ViewType>
void RenderAndRegressionTest(const vtkm::cont::DataSet& ds,
const std::string& fieldNm,
const vtkm::rendering::Color& color,
const std::string& outputFile,
const bool logY = false,
const bool& enableAnnotations = true,
const vtkm::Float64& dataViewPadding = 0,
const RenderTestOptions& options = RenderTestOptions{})
{
MapperType mapper;
CanvasType canvas(512, 512);
vtkm::rendering::Scene scene;
auto view = GetViewPtr<MapperType, CanvasType, ViewType>(
ds, fieldNm, canvas, mapper, scene, color, logY, dataViewPadding);
view->SetRenderAnnotationsEnabled(enableAnnotations);
VTKM_TEST_ASSERT(test_equal_images(*view,
outputFile,
options.AverageRadius,
options.PixelShiftRadius,
options.AllowedPixelErrorRatio,
options.Threshold));
}
// --------------------------------------------------------------
// A render test that allows for testing different mapper params
template <typename MapperType, typename CanvasType, typename ViewType>
void Render(MapperType& mapper,
const vtkm::cont::DataSet& ds,
const std::string& fieldNm,
const vtkm::cont::ColorTable& colorTable,
const std::string& outputFile,
const vtkm::Float64& dataViewPadding = 0)
{
CanvasType canvas(512, 512);
vtkm::rendering::Scene scene;
auto view = GetViewPtr<MapperType, CanvasType, ViewType>(
ds, fieldNm, canvas, mapper, scene, colorTable, dataViewPadding);
Render<MapperType, CanvasType, ViewType>(*view, outputFile);
}
template <typename MapperType1, typename MapperType2, typename CanvasType, typename ViewType>
void MultiMapperRender(const vtkm::cont::DataSet& ds1,
const vtkm::cont::DataSet& ds2,
const std::string& fieldNm,
const vtkm::cont::ColorTable& colorTable1,
const vtkm::cont::ColorTable& colorTable2,
const std::string& outputFile,
const vtkm::Float64& dataViewPadding = 0)
{
MapperType1 mapper1;
MapperType2 mapper2;
CanvasType canvas(512, 512);
canvas.SetBackgroundColor(vtkm::rendering::Color(0.8f, 0.8f, 0.8f, 1.0f));
canvas.Clear();
vtkm::Bounds totalBounds =
ds1.GetCoordinateSystem().GetBounds() + ds2.GetCoordinateSystem().GetBounds();
vtkm::rendering::Camera camera;
SetCamera<ViewType>(camera, totalBounds, ds1.GetField(fieldNm), dataViewPadding);
mapper1.SetCanvas(&canvas);
mapper1.SetActiveColorTable(colorTable1);
mapper1.SetCompositeBackground(false);
mapper2.SetCanvas(&canvas);
mapper2.SetActiveColorTable(colorTable2);
const vtkm::cont::Field field1 = ds1.GetField(fieldNm);
vtkm::Range range1;
field1.GetRange(&range1);
const vtkm::cont::Field field2 = ds2.GetField(fieldNm);
vtkm::Range range2;
field2.GetRange(&range2);
mapper1.RenderCells(
ds1.GetCellSet(), ds1.GetCoordinateSystem(), field1, colorTable1, camera, range1);
mapper2.RenderCells(
ds2.GetCellSet(), ds2.GetCoordinateSystem(), field2, colorTable2, camera, range2);
canvas.SaveAs(outputFile);
}
} // namespace vtkm::rendering::testing
} // namespace vtkm::rendering
} // namespace vtkm

35
vtkm/rendering/testing/UnitTestMapperConnectivity.cxx
View File

@ -25,26 +25,23 @@ namespace
void RenderTests()
{
try
{
vtkm::cont::testing::MakeTestDataSet maker;
vtkm::cont::ColorTable colorTable("inferno");
using M = vtkm::rendering::MapperConnectivity;
using C = vtkm::rendering::CanvasRayTracer;
using V3 = vtkm::rendering::View3D;
vtkm::cont::testing::MakeTestDataSet maker;
vtkm::rendering::testing::Render<M, C, V3>(
maker.Make3DRegularDataSet0(), "pointvar", colorTable, "reg3D.pnm");
vtkm::rendering::testing::Render<M, C, V3>(
maker.Make3DRectilinearDataSet0(), "pointvar", colorTable, "rect3D.pnm");
vtkm::rendering::testing::Render<M, C, V3>(
maker.Make3DExplicitDataSetZoo(), "pointvar", colorTable, "explicit3D.pnm");
}
catch (const std::exception& e)
{
std::cout << vtkm::rendering::raytracing::Logger::GetInstance()->GetStream().str() << "\n";
std::cout << e.what() << "\n";
}
vtkm::rendering::testing::RenderTestOptions testOptions;
testOptions.Mapper = vtkm::rendering::testing::MapperType::Connectivity;
testOptions.AllowAnyDevice = false;
testOptions.ColorTable = vtkm::cont::ColorTable::Preset::Inferno;
vtkm::rendering::testing::RenderTest(
maker.Make3DRegularDataSet0(), "pointvar", "rendering/connectivity/regular3D.png", testOptions);
vtkm::rendering::testing::RenderTest(maker.Make3DRectilinearDataSet0(),
"pointvar",
"rendering/connectivity/rectilinear3D.png",
testOptions);
vtkm::rendering::testing::RenderTest(maker.Make3DExplicitDataSetZoo(),
"pointvar",
"rendering/connectivity/explicit3D.png",
testOptions);
}
} //namespace

59
vtkm/rendering/testing/UnitTestMapperCylinders.cxx
View File

@ -23,46 +23,41 @@ namespace
void RenderTests()
{
typedef vtkm::rendering::MapperCylinder M;
typedef vtkm::rendering::CanvasRayTracer C;
typedef vtkm::rendering::View3D V3;
typedef vtkm::rendering::View2D V2;
vtkm::cont::testing::MakeTestDataSet maker;
vtkm::cont::ColorTable colorTable("inferno");
vtkm::rendering::testing::Render<M, C, V3>(
maker.Make3DRegularDataSet0(), "pointvar", colorTable, "rt_reg3D.pnm");
vtkm::rendering::testing::Render<M, C, V3>(
maker.Make3DRectilinearDataSet0(), "pointvar", colorTable, "rt_rect3D.pnm");
vtkm::rendering::testing::Render<M, C, V3>(
maker.Make3DExplicitDataSet4(), "pointvar", colorTable, "rt_expl3D.pnm");
vtkm::rendering::testing::RenderTestOptions options;
options.Mapper = vtkm::rendering::testing::MapperType::Cylinder;
options.AllowAnyDevice = false;
options.ColorTable = vtkm::cont::ColorTable::Preset::Inferno;
vtkm::rendering::testing::Render<M, C, V2>(
maker.Make2DUniformDataSet1(), "pointvar", colorTable, "uni2D.pnm");
vtkm::rendering::testing::RenderTest(
maker.Make3DRegularDataSet0(), "pointvar", "rendering/cylinder/regular3D.png", options);
vtkm::rendering::testing::RenderTest(
maker.Make3DRectilinearDataSet0(), "pointvar", "rendering/cylinder/rectilinear3D.png", options);
vtkm::rendering::testing::RenderTest(
maker.Make3DExplicitDataSet4(), "pointvar", "rendering/cylinder/explicit-hex.png", options);
vtkm::rendering::testing::Render<M, C, V3>(
maker.Make3DExplicitDataSet8(), "cellvar", colorTable, "cylinder.pnm");
options.ViewDimension = 2;
vtkm::rendering::testing::RenderTest(
maker.Make2DUniformDataSet1(), "pointvar", "rendering/cylinder/uniform2D.png", options);
options.ViewDimension = 3;
options.CameraAzimuth = 0;
vtkm::rendering::testing::RenderTest(
maker.Make3DExplicitDataSet8(), "cellvar", "rendering/cylinder/explicit-lines.png", options);
//hexahedron, wedge, pyramid, tetrahedron
vtkm::rendering::testing::Render<M, C, V3>(
maker.Make3DExplicitDataSet5(), "cellvar", colorTable, "rt_hex3d.pnm");
vtkm::rendering::testing::RenderTest(
maker.Make3DExplicitDataSet5(), "cellvar", "rendering/cylinder/explicit-zoo.png", options);
M mapper;
options.CylinderRadius = 0.1f;
vtkm::rendering::testing::RenderTest(
maker.Make3DExplicitDataSet8(), "cellvar", "rendering/cylinder/static-radius.png", options);
mapper.SetRadius(0.1f);
vtkm::rendering::testing::Render<M, C, V3>(
mapper, maker.Make3DExplicitDataSet8(), "cellvar", colorTable, "cyl_static_radius.pnm");
mapper.UseVariableRadius(true);
mapper.SetRadiusDelta(2.0f);
vtkm::rendering::testing::Render<M, C, V3>(
mapper, maker.Make3DExplicitDataSet8(), "cellvar", colorTable, "cyl_var_radius.pnm");
//test to make sure can reset
mapper.UseVariableRadius(false);
vtkm::rendering::testing::Render<M, C, V3>(
maker.Make3DExplicitDataSet8(), "cellvar", colorTable, "cylinder2.pnm");
options.CylinderUseVariableRadius = true;
options.CylinderRadius = 2.0f;
vtkm::rendering::testing::RenderTest(
maker.Make3DExplicitDataSet8(), "cellvar", "rendering/cylinder/variable-radius.png", options);
}
} //namespace

39
vtkm/rendering/testing/UnitTestMapperPoints.cxx
View File

@ -23,31 +23,30 @@ namespace
void RenderTests()
{
using M = vtkm::rendering::MapperPoint;
using C = vtkm::rendering::CanvasRayTracer;
using V3 = vtkm::rendering::View3D;
vtkm::cont::testing::MakeTestDataSet maker;
vtkm::cont::ColorTable colorTable("inferno");
M mapper;
std::cout << "Testing uniform delta raduis\n";
mapper.SetRadiusDelta(4.0f);
vtkm::rendering::testing::Render<M, C, V3>(
mapper, maker.Make3DUniformDataSet1(), "pointvar", colorTable, "points_vr_reg3D.pnm");
vtkm::rendering::testing::RenderTestOptions options;
options.Mapper = vtkm::rendering::testing::MapperType::Point;
options.AllowAnyDevice = false;
options.ColorTable = vtkm::cont::ColorTable::Preset::Inferno;
vtkm::rendering::testing::RenderTest(
maker.Make3DUniformDataSet1(), "pointvar", "rendering/point/regular3D.png", options);
options.UseVariableRadius = true;
options.RadiusDelta = 4.0f;
options.Radius = 0.25f;
vtkm::rendering::testing::RenderTest(
maker.Make3DUniformDataSet1(), "pointvar", "rendering/point/variable_regular3D.png", options);
// restore defaults
mapper.SetRadiusDelta(0.5f);
mapper.UseVariableRadius(false);
options.RadiusDelta = 0.5f;
options.UseVariableRadius = false;
mapper.SetRadius(0.2f);
vtkm::rendering::testing::Render<M, C, V3>(
mapper, maker.Make3DUniformDataSet1(), "pointvar", colorTable, "points_reg3D.pnm");
mapper.UseCells();
mapper.SetRadius(1.f);
vtkm::rendering::testing::Render<M, C, V3>(
mapper, maker.Make3DExplicitDataSet7(), "cellvar", colorTable, "spheres.pnm");
options.RenderCells = true;
options.Radius = 1.f;
vtkm::rendering::testing::RenderTest(
maker.Make3DExplicitDataSet7(), "cellvar", "rendering/point/cells.png", options);
}
} //namespace

32
vtkm/rendering/testing/UnitTestMapperQuads.cxx
View File

@ -23,27 +23,27 @@ namespace
void RenderTests()
{
typedef vtkm::rendering::MapperQuad M;
typedef vtkm::rendering::CanvasRayTracer C;
typedef vtkm::rendering::View3D V3;
typedef vtkm::rendering::View2D V2;
vtkm::cont::testing::MakeTestDataSet maker;
vtkm::cont::ColorTable colorTable("inferno");
vtkm::rendering::testing::Render<M, C, V3>(
maker.Make3DRegularDataSet0(), "pointvar", colorTable, "rt_reg3D.pnm");
vtkm::rendering::testing::Render<M, C, V3>(
maker.Make3DRectilinearDataSet0(), "pointvar", colorTable, "rt_rect3D.pnm");
vtkm::rendering::testing::Render<M, C, V3>(
maker.Make3DExplicitDataSet4(), "pointvar", colorTable, "rt_expl3D.pnm");
vtkm::rendering::testing::RenderTestOptions options;
options.Mapper = vtkm::rendering::testing::MapperType::Quad;
options.AllowAnyDevice = false;
options.ColorTable = vtkm::cont::ColorTable::Preset::Inferno;
vtkm::rendering::testing::Render<M, C, V2>(
maker.Make2DUniformDataSet1(), "pointvar", colorTable, "uni2D.pnm");
vtkm::rendering::testing::RenderTest(
maker.Make3DRegularDataSet0(), "pointvar", "rendering/quad/regular3D.png", options);
vtkm::rendering::testing::RenderTest(
maker.Make3DRectilinearDataSet0(), "pointvar", "rendering/quad/rectilinear3D.png", options);
vtkm::rendering::testing::RenderTest(
maker.Make3DExplicitDataSet4(), "pointvar", "rendering/quad/explicit3D.png", options);
//hexahedron, wedge, pyramid, tetrahedron
vtkm::rendering::testing::Render<M, C, V3>(
maker.Make3DExplicitDataSet5(), "cellvar", colorTable, "rt_hex3d.pnm");
vtkm::rendering::testing::RenderTest(
maker.Make3DExplicitDataSet5(), "cellvar", "rendering/quad/mixed3D.png", options);
options.ViewDimension = 2;
vtkm::rendering::testing::RenderTest(
maker.Make2DUniformDataSet1(), "pointvar", "rendering/quad/uniform2D.png", options);
}
} //namespace

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

@ -23,26 +23,30 @@ namespace
void RenderTests()
{
using M = vtkm::rendering::MapperRayTracer;
using C = vtkm::rendering::CanvasRayTracer;
using V3 = vtkm::rendering::View3D;
using V2 = vtkm::rendering::View2D;
vtkm::cont::testing::MakeTestDataSet maker;
vtkm::cont::ColorTable colorTable("inferno");
vtkm::rendering::testing::Render<M, C, V3>(
maker.Make3DRegularDataSet0(), "pointvar", colorTable, "rt_reg3D.pnm");
vtkm::rendering::testing::Render<M, C, V3>(
maker.Make3DRectilinearDataSet0(), "pointvar", colorTable, "rt_rect3D.pnm");
vtkm::rendering::testing::Render<M, C, V3>(
maker.Make3DExplicitDataSet4(), "pointvar", colorTable, "rt_expl3D.pnm");
vtkm::rendering::testing::RenderTestOptions options;
options.Mapper = vtkm::rendering::testing::MapperType::RayTracer;
options.AllowAnyDevice = false;
options.ColorTable = vtkm::cont::ColorTable::Preset::Inferno;
vtkm::rendering::testing::Render<M, C, V2>(
maker.Make2DUniformDataSet1(), "pointvar", colorTable, "uni2D.pnm");
vtkm::rendering::testing::RenderTest(
maker.Make3DRegularDataSet0(), "pointvar", "rendering/raytracer/regular3D.png", options);
vtkm::rendering::testing::RenderTest(maker.Make3DRectilinearDataSet0(),
"pointvar",
"rendering/raytracer/rectilinear3D.png",
options);
vtkm::rendering::testing::RenderTest(
maker.Make3DExplicitDataSet4(), "pointvar", "rendering/raytracer/explicit3D.png", options);
vtkm::rendering::testing::Render<M, C, V3>(
maker.Make3DExplicitDataSet7(), "cellvar", colorTable, "spheres.pnm");
// The result is blank. I don't think MapperRayTracer is actually supposed to render anything
// for 0D (vertex) cells, but it shouldn't crash if it receives them
vtkm::rendering::testing::RenderTest(
maker.Make3DExplicitDataSet7(), "cellvar", "rendering/raytracer/vertex-cells.png", options);
options.ViewDimension = 2;
vtkm::rendering::testing::RenderTest(
maker.Make2DUniformDataSet1(), "pointvar", "rendering/raytracer/uniform2D.png", options);
}
} //namespace

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

@ -27,14 +27,15 @@ namespace
void RenderTests()
{
using M = vtkm::rendering::MapperVolume;
using C = vtkm::rendering::CanvasRayTracer;
using V3 = vtkm::rendering::View3D;
vtkm::cont::ColorTable colorTable("inferno");
vtkm::cont::ColorTable colorTable = vtkm::cont::ColorTable::Preset::Inferno;
colorTable.AddPointAlpha(0.0, .01f);
colorTable.AddPointAlpha(1.0, .01f);
vtkm::rendering::testing::RenderTestOptions options;
options.Mapper = vtkm::rendering::testing::MapperType::Volume;
options.AllowAnyDevice = false;
options.ColorTable = colorTable;
vtkm::cont::DataSet rectDS, unsDS;
std::string rectfname = vtkm::cont::testing::Testing::DataPath("rectilinear/noise.vtk");
vtkm::io::VTKDataSetReader rectReader(rectfname);
@ -53,7 +54,8 @@ void RenderTests()
VTKM_TEST_FAIL(message.c_str());
}
vtkm::rendering::testing::Render<M, C, V3>(rectDS, "hardyglobal", colorTable, "rect3D.pnm");
vtkm::rendering::testing::RenderTest(
rectDS, "hardyglobal", "rendering/volume/rectilinear3D.png", options);
}
} //namespace

74
vtkm/rendering/testing/UnitTestMultiMapper.cxx
View File

@ -27,13 +27,59 @@
namespace
{
// Multi-mapper rendering is something of a hack right now. A view only supports one mapper
// at a time, so to use different mapper types you have to render the mappers yourself.
template <typename MapperType1, typename MapperType2>
void MultiMapperRender(const vtkm::cont::DataSet& ds1,
const vtkm::cont::DataSet& ds2,
const std::string& fieldNm,
const vtkm::cont::ColorTable& colorTable1,
const vtkm::cont::ColorTable& colorTable2,
const std::string& outputFile)
{
MapperType1 mapper1;
MapperType2 mapper2;
vtkm::rendering::CanvasRayTracer canvas(300, 300);
canvas.SetBackgroundColor(vtkm::rendering::Color(0.8f, 0.8f, 0.8f, 1.0f));
canvas.Clear();
vtkm::Bounds totalBounds =
ds1.GetCoordinateSystem().GetBounds() + ds2.GetCoordinateSystem().GetBounds();
vtkm::rendering::Camera camera;
camera.ResetToBounds(totalBounds);
camera.Azimuth(45.0f);
camera.Elevation(45.0f);
mapper1.SetCanvas(&canvas);
mapper1.SetActiveColorTable(colorTable1);
mapper1.SetCompositeBackground(false);
mapper2.SetCanvas(&canvas);
mapper2.SetActiveColorTable(colorTable2);
const vtkm::cont::Field field1 = ds1.GetField(fieldNm);
vtkm::Range range1;
field1.GetRange(&range1);
const vtkm::cont::Field field2 = ds2.GetField(fieldNm);
vtkm::Range range2;
field2.GetRange(&range2);
mapper1.RenderCells(
ds1.GetCellSet(), ds1.GetCoordinateSystem(), field1, colorTable1, camera, range1);
mapper2.RenderCells(
ds2.GetCellSet(), ds2.GetCoordinateSystem(), field2, colorTable2, camera, range2);
VTKM_TEST_ASSERT(test_equal_images(canvas, outputFile));
}
void RenderTests()
{
using M1 = vtkm::rendering::MapperVolume;
using M2 = vtkm::rendering::MapperConnectivity;
using R = vtkm::rendering::MapperRayTracer;
using C = vtkm::rendering::CanvasRayTracer;
using V3 = vtkm::rendering::View3D;
vtkm::cont::testing::MakeTestDataSet maker;
vtkm::cont::ColorTable colorTable("inferno");
@ -43,19 +89,19 @@ void RenderTests()
colorTable2.AddPointAlpha(0.0, .02f);
colorTable2.AddPointAlpha(1.0, .02f);
vtkm::rendering::testing::MultiMapperRender<R, M2, C, V3>(maker.Make3DExplicitDataSetPolygonal(),
maker.Make3DRectilinearDataSet0(),
"pointvar",
colorTable,
colorTable2,
"multi1.pnm");
MultiMapperRender<R, M2>(maker.Make3DExplicitDataSetPolygonal(),
maker.Make3DRectilinearDataSet0(),
"pointvar",
colorTable,
colorTable2,
"rendering/multimapper/raytracer-connectivity.png");
vtkm::rendering::testing::MultiMapperRender<R, M1, C, V3>(maker.Make3DExplicitDataSet4(),
maker.Make3DRectilinearDataSet0(),
"pointvar",
colorTable,
colorTable2,
"multi2.pnm");
MultiMapperRender<R, M1>(maker.Make3DExplicitDataSet4(),
maker.Make3DRectilinearDataSet0(),
"pointvar",
colorTable,
colorTable2,
"rendering/multimapper/raytracer-volume.png");
}
} //namespace