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

Merge topic 'partitionedRendering'

Browse Source 
e243e51c1 revert superfluous corners distance
53ab4d41e next round of changes
d9875a41d fix typos
60fdcbaf7 add this->
4fabc168e add this->
7c61aaca0 add this->
cec1091b0 remove compiler warning
ac152d25d ensure presen ghost array if extractor is called from other than vtkm actor
...

Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: Kenneth Moreland <morelandkd@ornl.gov>
Merge-request: !3149
This commit is contained in:
Roxana Bujack 2024-01-05 16:36:56 +00:00 committed by Kitware Robot
commit 982c5bbb93
40 changed files with 659 additions and 259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
vtkm/cont/CellLocatorPartitioned.cxx
View File

@ -45,18 +45,8 @@ void CellLocatorPartitioned::Build()
this->LocatorsCont.at(index) = cellLocator;
// fill vector of ghostFields
vtkm::cont::ArrayHandle<vtkm::UInt8> ghostArrayHandle;
if (dataset.HasCellField("vtkGhostType"))
{
dataset.GetField("vtkGhostType").GetData().AsArrayHandle(ghostArrayHandle);
}
else
{
vtkm::cont::ArrayCopy(
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(0, dataset.GetNumberOfCells()),
ghostArrayHandle);
}
this->GhostsCont.at(index) = ghostArrayHandle;
this->GhostsCont.at(index) =
dataset.GetGhostCellField().GetData().ExtractComponent<vtkm::UInt8>(0);
}
}

4
vtkm/cont/CellLocatorPartitioned.h
View File

@ -47,9 +47,9 @@ public:
private:
vtkm::cont::PartitionedDataSet Partitions;
std::vector<CellLocatorGeneral> LocatorsCont;
std::vector<vtkm::cont::ArrayHandle<vtkm::UInt8>> GhostsCont;
std::vector<vtkm::cont::ArrayHandleStride<vtkm::UInt8>> GhostsCont;
vtkm::cont::ArrayHandle<vtkm::cont::CellLocatorGeneral::ExecObjType> LocatorsExec;
vtkm::cont::ArrayHandle<vtkm::cont::ArrayHandle<vtkm::UInt8>::ReadPortalType> GhostsExec;
vtkm::cont::ArrayHandle<vtkm::cont::ArrayHandleStride<vtkm::UInt8>::ReadPortalType> GhostsExec;
bool Modified = true;
};
} // namespace cont

6
vtkm/cont/DataSet.cxx
View File

@ -153,7 +153,7 @@ bool DataSet::HasGhostCellField() const
return this->HasCellField(this->GetGhostCellFieldName());
}
const vtkm::cont::Field& DataSet::GetGhostCellField() const
vtkm::cont::Field DataSet::GetGhostCellField() const
{
if (this->HasGhostCellField())
{
@ -161,7 +161,9 @@ const vtkm::cont::Field& DataSet::GetGhostCellField() const
}
else
{
throw vtkm::cont::ErrorBadValue("No Ghost Cell Field");
return make_FieldCell(
this->GetGhostCellFieldName(),
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(0, this->GetNumberOfCells()));
}
}

4
vtkm/cont/DataSet.h
View File

@ -186,11 +186,11 @@ public:
/// \brief Returns the cell field that matches the ghost cell field name.
///
/// This method will throw an exception if no match is found. Use `HasGhostCellField()` to query
/// This method will return a constant array of zeros if no match is found. Use `HasGhostCellField()` to query
/// whether a particular field exists.
///@{
VTKM_CONT
const vtkm::cont::Field& GetGhostCellField() const;
vtkm::cont::Field GetGhostCellField() const;
///@}
/// \brief Returns the first point field that matches the provided name.

8
vtkm/exec/CellLocatorPartitioned.h
View File

@ -22,16 +22,16 @@ class VTKM_ALWAYS_EXPORT CellLocatorPartitioned
{
private:
vtkm::cont::ArrayHandle<vtkm::cont::CellLocatorGeneral::ExecObjType>::ReadPortalType Locators;
vtkm::cont::ArrayHandle<vtkm::cont::ArrayHandle<vtkm::UInt8>::ReadPortalType>::ReadPortalType
Ghosts;
vtkm::cont::ArrayHandle<
vtkm::cont::ArrayHandleStride<vtkm::UInt8>::ReadPortalType>::ReadPortalType Ghosts;
public:
VTKM_CONT CellLocatorPartitioned() = default;
VTKM_CONT CellLocatorPartitioned(
const vtkm::cont::ArrayHandle<vtkm::cont::CellLocatorGeneral::ExecObjType>::ReadPortalType&
locators,
vtkm::cont::ArrayHandle<vtkm::cont::ArrayHandle<vtkm::UInt8>::ReadPortalType>::ReadPortalType
ghosts)
vtkm::cont::ArrayHandle<
vtkm::cont::ArrayHandleStride<vtkm::UInt8>::ReadPortalType>::ReadPortalType ghosts)
: Locators(locators)
, Ghosts(ghosts)
{

34
vtkm/filter/multi_block/AmrArrays.cxx
View File

@ -223,21 +223,21 @@ void AmrArrays::ComputeGenerateGhostType()
this->AmrDataSet.GetPartition(this->PartitionIds.at(l).at(bParent));
vtkm::cont::CellSetStructured<Dim> cellset;
partition.GetCellSet().AsCellSet(cellset);
vtkm::cont::ArrayHandle<vtkm::UInt8> ghostField;
if (!partition.HasField("vtkGhostType", vtkm::cont::Field::Association::Cells))
vtkm::cont::ArrayHandle<vtkm::UInt8> ghostArrayHandle;
if (!partition.HasGhostCellField())
{
ghostField.AllocateAndFill(partition.GetNumberOfCells(), 0);
ghostArrayHandle.AllocateAndFill(partition.GetNumberOfCells(), 0);
}
else
{
vtkm::cont::Invoker invoke;
invoke(vtkm::worklet::ResetGhostTypeWorklet{},
partition.GetField("vtkGhostType", vtkm::cont::Field::Association::Cells)
partition.GetGhostCellField()
.GetData()
.AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::UInt8>>(),
ghostField);
ghostArrayHandle);
}
partition.AddCellField("vtkGhostType", ghostField);
partition.AddCellField(vtkm::cont::GetGlobalGhostCellFieldName(), ghostArrayHandle);
auto pointField = partition.GetCoordinateSystem().GetDataAsMultiplexer();
@ -257,7 +257,7 @@ void AmrArrays::ComputeGenerateGhostType()
invoke(vtkm::worklet::GenerateGhostTypeWorklet<Dim>{ boundsChild },
cellset,
pointField,
ghostField);
ghostArrayHandle);
}
this->AmrDataSet.ReplacePartition(this->PartitionIds.at(l).at(bParent), partition);
}
@ -274,15 +274,21 @@ void AmrArrays::GenerateIndexArrays()
{
vtkm::cont::DataSet partition = this->AmrDataSet.GetPartition(this->PartitionIds.at(l).at(b));
partition.AddCellField(
"vtkAmrLevel", vtkm::cont::ArrayHandleConstant<vtkm::Id>(l, partition.GetNumberOfCells()));
vtkm::cont::ArrayHandle<vtkm::Id> fieldAmrLevel;
vtkm::cont::ArrayCopy(
vtkm::cont::ArrayHandleConstant<vtkm::Id>(l, partition.GetNumberOfCells()), fieldAmrLevel);
partition.AddCellField("vtkAmrLevel", fieldAmrLevel);
partition.AddCellField(
"vtkAmrIndex", vtkm::cont::ArrayHandleConstant<vtkm::Id>(b, partition.GetNumberOfCells()));
vtkm::cont::ArrayHandle<vtkm::Id> fieldBlockId;
vtkm::cont::ArrayCopy(
vtkm::cont::ArrayHandleConstant<vtkm::Id>(b, partition.GetNumberOfCells()), fieldBlockId);
partition.AddCellField("vtkAmrIndex", fieldBlockId);
partition.AddCellField("vtkCompositeIndex",
vtkm::cont::ArrayHandleConstant<vtkm::Id>(
this->PartitionIds.at(l).at(b), partition.GetNumberOfCells()));
vtkm::cont::ArrayHandle<vtkm::Id> fieldPartitionIndex;
vtkm::cont::ArrayCopy(vtkm::cont::ArrayHandleConstant<vtkm::Id>(
this->PartitionIds.at(l).at(b), partition.GetNumberOfCells()),
fieldPartitionIndex);
partition.AddCellField("vtkCompositeIndex", fieldPartitionIndex);
this->AmrDataSet.ReplacePartition(this->PartitionIds.at(l).at(b), partition);
}

2
vtkm/filter/multi_block/AmrArrays.h
View File

@ -74,7 +74,7 @@ private:
template <vtkm::IdComponent Dim>
void ComputeGenerateParentChildInformation();
/// generate the vtkGhostType array based on the overlap analogously to vtk
/// generate the GhostType array based on the overlap analogously to vtk
/// blanked cells: 8 normal cells: 0
VTKM_CONT
void GenerateGhostType();

2
vtkm/filter/multi_block/testing/RenderTestAmrArrays.cxx
View File

@ -36,7 +36,7 @@ void TestAmrArraysExecute(int dim, int numberOfLevels, int cellsPerDimension)
vtkm::filter::entity_extraction::Threshold threshold;
threshold.SetLowerThreshold(0);
threshold.SetUpperThreshold(1);
threshold.SetActiveField("vtkGhostType");
threshold.SetActiveField(vtkm::cont::GetGlobalGhostCellFieldName());
vtkm::cont::PartitionedDataSet derivedDataSet = threshold.Execute(amrDataSet);
// std::cout << "derived " << std::endl;
// derivedDataSet.PrintSummary(std::cout);

149
vtkm/rendering/Actor.cxx
View File

@ -10,6 +10,9 @@
#include <vtkm/rendering/Actor.h>
#include <vtkm/Assert.h>
#include <vtkm/cont/BoundsCompute.h>
#include <vtkm/cont/FieldRangeCompute.h>
#include <vtkm/cont/TryExecute.h>
#include <vtkm/cont/UnknownCellSet.h>
@ -22,63 +25,137 @@ namespace rendering
struct Actor::InternalsType
{
vtkm::cont::UnknownCellSet Cells;
vtkm::cont::CoordinateSystem Coordinates;
vtkm::cont::Field ScalarField;
vtkm::cont::PartitionedDataSet Data;
std::string CoordinateName;
std::string FieldName;
vtkm::cont::Field::Association FieldAssociation;
vtkm::cont::ColorTable ColorTable;
vtkm::Range ScalarRange;
vtkm::Bounds SpatialBounds;
VTKM_CONT
InternalsType(vtkm::cont::UnknownCellSet cells,
vtkm::cont::CoordinateSystem coordinates,
vtkm::cont::Field scalarField,
InternalsType(const vtkm::cont::PartitionedDataSet partitionedDataSet,
const std::string coordinateName,
const std::string fieldName,
const vtkm::rendering::Color& color)
: Cells(std::move(cells))
, Coordinates(std::move(coordinates))
, ScalarField(std::move(scalarField))
: Data(partitionedDataSet)
, CoordinateName(coordinateName)
, FieldName(fieldName)
, ColorTable(vtkm::Range{ 0, 1 }, color.Components, color.Components)
{
}
VTKM_CONT
InternalsType(vtkm::cont::UnknownCellSet cells,
vtkm::cont::CoordinateSystem coordinates,
vtkm::cont::Field scalarField,
InternalsType(const vtkm::cont::PartitionedDataSet partitionedDataSet,
const std::string coordinateName,
const std::string fieldName,
const vtkm::cont::ColorTable& colorTable = vtkm::cont::ColorTable::Preset::Default)
: Cells(std::move(cells))
, Coordinates(std::move(coordinates))
, ScalarField(std::move(scalarField))
: Data(partitionedDataSet)
, CoordinateName(coordinateName)
, FieldName(fieldName)
, ColorTable(colorTable)
{
}
};
Actor::Actor(const vtkm::cont::DataSet dataSet,
const std::string coordinateName,
const std::string fieldName)
{
vtkm::cont::PartitionedDataSet partitionedDataSet(dataSet);
this->Internals = std::make_unique<InternalsType>(partitionedDataSet, coordinateName, fieldName);
this->Init();
}
Actor::Actor(const vtkm::cont::DataSet dataSet,
const std::string coordinateName,
const std::string fieldName,
const vtkm::rendering::Color& color)
{
vtkm::cont::PartitionedDataSet partitionedDataSet(dataSet);
this->Internals =
std::make_unique<InternalsType>(partitionedDataSet, coordinateName, fieldName, color);
this->Init();
}
Actor::Actor(const vtkm::cont::DataSet dataSet,
const std::string coordinateName,
const std::string fieldName,
const vtkm::cont::ColorTable& colorTable)
{
vtkm::cont::PartitionedDataSet partitionedDataSet(dataSet);
this->Internals =
std::make_unique<InternalsType>(partitionedDataSet, coordinateName, fieldName, colorTable);
this->Init();
}
Actor::Actor(const vtkm::cont::PartitionedDataSet dataSet,
const std::string coordinateName,
const std::string fieldName)
: Internals(new InternalsType(dataSet, coordinateName, fieldName))
{
this->Init();
}
Actor::Actor(const vtkm::cont::PartitionedDataSet dataSet,
const std::string coordinateName,
const std::string fieldName,
const vtkm::rendering::Color& color)
: Internals(new InternalsType(dataSet, coordinateName, fieldName, color))
{
this->Init();
}
Actor::Actor(const vtkm::cont::PartitionedDataSet dataSet,
const std::string coordinateName,
const std::string fieldName,
const vtkm::cont::ColorTable& colorTable)
: Internals(new InternalsType(dataSet, coordinateName, fieldName, colorTable))
{
this->Init();
}
Actor::Actor(const vtkm::cont::UnknownCellSet& cells,
const vtkm::cont::CoordinateSystem& coordinates,
const vtkm::cont::Field& scalarField)
: Internals(std::make_unique<InternalsType>(cells, coordinates, scalarField))
{
this->Init(coordinates, scalarField);
vtkm::cont::DataSet dataSet;
dataSet.SetCellSet(cells);
dataSet.AddCoordinateSystem(coordinates);
dataSet.AddField(scalarField);
this->Internals =
std::make_unique<InternalsType>(dataSet, coordinates.GetName(), scalarField.GetName());
this->Init();
}
Actor::Actor(const vtkm::cont::UnknownCellSet& cells,
const vtkm::cont::CoordinateSystem& coordinates,
const vtkm::cont::Field& scalarField,
const vtkm::rendering::Color& color)
: Internals(std::make_unique<InternalsType>(cells, coordinates, scalarField, color))
{
this->Init(coordinates, scalarField);
vtkm::cont::DataSet dataSet;
dataSet.SetCellSet(cells);
dataSet.AddCoordinateSystem(coordinates);
dataSet.AddField(scalarField);
this->Internals =
std::make_unique<InternalsType>(dataSet, coordinates.GetName(), scalarField.GetName(), color);
this->Init();
}
Actor::Actor(const vtkm::cont::UnknownCellSet& cells,
const vtkm::cont::CoordinateSystem& coordinates,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable)
: Internals(std::make_unique<InternalsType>(cells, coordinates, scalarField, colorTable))
{
this->Init(coordinates, scalarField);
vtkm::cont::DataSet dataSet;
dataSet.SetCellSet(cells);
dataSet.AddCoordinateSystem(coordinates);
dataSet.AddField(scalarField);
this->Internals = std::make_unique<InternalsType>(
dataSet, coordinates.GetName(), scalarField.GetName(), colorTable);
this->Init();
}
Actor::Actor(const Actor& rhs)
@ -112,11 +189,13 @@ Actor::Actor(vtkm::rendering::Actor&&) noexcept = default;
Actor& Actor::operator=(Actor&&) noexcept = default;
Actor::~Actor() = default;
void Actor::Init(const vtkm::cont::CoordinateSystem& coordinates,
const vtkm::cont::Field& scalarField)
void Actor::Init()
{
scalarField.GetRange(&this->Internals->ScalarRange);
this->Internals->SpatialBounds = coordinates.GetBounds();
this->Internals->SpatialBounds = vtkm::cont::BoundsCompute(this->Internals->Data);
this->Internals->ScalarRange =
vtkm::cont::FieldRangeCompute(this->Internals->Data, this->Internals->FieldName)
.ReadPortal()
.Get(0);
}
void Actor::Render(vtkm::rendering::Mapper& mapper,
@ -125,27 +204,27 @@ void Actor::Render(vtkm::rendering::Mapper& mapper,
{
mapper.SetCanvas(&canvas);
mapper.SetActiveColorTable(this->Internals->ColorTable);
mapper.RenderCells(this->Internals->Cells,
this->Internals->Coordinates,
this->Internals->ScalarField,
this->Internals->ColorTable,
camera,
this->Internals->ScalarRange);
mapper.RenderCellsPartitioned(this->Internals->Data,
this->Internals->FieldName,
this->Internals->ColorTable,
camera,
this->Internals->ScalarRange);
}
const vtkm::cont::UnknownCellSet& Actor::GetCells() const
{
return this->Internals->Cells;
return this->Internals->Data.GetPartition(0).GetCellSet();
}
const vtkm::cont::CoordinateSystem& Actor::GetCoordinates() const
vtkm::cont::CoordinateSystem Actor::GetCoordinates() const
{
return this->Internals->Coordinates;
return this->Internals->Data.GetPartition(0).GetCoordinateSystem(this->Internals->CoordinateName);
}
const vtkm::cont::Field& Actor::GetScalarField() const
{
return this->Internals->ScalarField;
return this->Internals->Data.GetPartition(0).GetField(this->Internals->FieldName);
}
const vtkm::cont::ColorTable& Actor::GetColorTable() const

32
vtkm/rendering/Actor.h
View File

@ -30,6 +30,34 @@ namespace rendering
class VTKM_RENDERING_EXPORT Actor
{
public:
Actor(const vtkm::cont::DataSet dataSet,
const std::string coordinateName,
const std::string fieldName);
Actor(const vtkm::cont::DataSet dataSet,
const std::string coordinateName,
const std::string fieldName,
const vtkm::cont::ColorTable& colorTable);
Actor(const vtkm::cont::DataSet dataSet,
const std::string coordinateName,
const std::string fieldName,
const vtkm::rendering::Color& color);
Actor(const vtkm::cont::PartitionedDataSet dataSet,
const std::string coordinateName,
const std::string fieldName);
Actor(const vtkm::cont::PartitionedDataSet dataSet,
const std::string coordinateName,
const std::string fieldName,
const vtkm::cont::ColorTable& colorTable);
Actor(const vtkm::cont::PartitionedDataSet dataSet,
const std::string coordinateName,
const std::string fieldName,
const vtkm::rendering::Color& color);
/// Create an `Actor` object that renders a set of cells positioned by a given coordiante
/// system. A field to apply psudocoloring is also provided. The default colormap is applied.
/// The cells, coordinates, and field are typically pulled from a `vtkm::cont::DataSet` object.
@ -68,7 +96,7 @@ public:
const vtkm::cont::UnknownCellSet& GetCells() const;
const vtkm::cont::CoordinateSystem& GetCoordinates() const;
vtkm::cont::CoordinateSystem GetCoordinates() const;
const vtkm::cont::Field& GetScalarField() const;
@ -90,6 +118,8 @@ private:
std::unique_ptr<InternalsType> Internals;
void Init(const vtkm::cont::CoordinateSystem& coordinates, const vtkm::cont::Field& scalarField);
void Init();
};
}
} //namespace vtkm::rendering

103
vtkm/rendering/ConnectivityProxy.cxx
View File

@ -29,10 +29,9 @@ protected:
using TracerType = vtkm::rendering::raytracing::ConnectivityTracer;
TracerType Tracer;
vtkm::cont::Field ScalarField;
vtkm::cont::Field EmissionField;
vtkm::cont::UnknownCellSet Cells;
vtkm::cont::CoordinateSystem Coords;
std::string CoordinateName;
std::string FieldName;
std::string EmissionFieldName;
RenderMode Mode;
vtkm::Bounds SpatialBounds;
ColorMapType ColorMap;
@ -41,11 +40,12 @@ protected:
bool CompositeBackground;
public:
InternalsType(const vtkm::cont::DataSet& dataSet, const std::string& fieldName)
InternalsType(const vtkm::cont::DataSet& dataSet,
const std::string& coordinateName,
const std::string& fieldName)
{
Dataset = dataSet;
Cells = dataSet.GetCellSet();
Coords = dataSet.GetCoordinateSystem();
CoordinateName = coordinateName;
Mode = RenderMode::Volume;
CompositeBackground = true;
if (!fieldName.empty())
@ -76,8 +76,9 @@ public:
VTKM_CONT
void SetScalarField(const std::string& fieldName)
{
ScalarField = Dataset.GetField(fieldName);
const vtkm::cont::ArrayHandle<vtkm::Range> range = this->ScalarField.GetRange();
this->FieldName = fieldName;
const vtkm::cont::ArrayHandle<vtkm::Range> range =
this->Dataset.GetField(this->FieldName).GetRange();
ScalarRange = range.ReadPortal().Get(0);
}
@ -104,7 +105,7 @@ public:
throw vtkm::cont::ErrorBadValue(
"Conn Proxy: energy mode must be set before setting emission field");
}
EmissionField = Dataset.GetField(fieldName);
this->EmissionFieldName = fieldName;
}
VTKM_CONT
@ -113,7 +114,8 @@ public:
VTKM_CONT
vtkm::Range GetScalarFieldRange()
{
const vtkm::cont::ArrayHandle<vtkm::Range> range = this->ScalarField.GetRange();
const vtkm::cont::ArrayHandle<vtkm::Range> range =
this->Dataset.GetField(this->FieldName).GetRange();
ScalarRange = range.ReadPortal().Get(0);
return ScalarRange;
}
@ -130,15 +132,19 @@ public:
if (this->Mode == RenderMode::Volume)
{
Tracer.SetVolumeData(this->ScalarField, this->ScalarRange, this->Cells, this->Coords);
Tracer.SetVolumeData(this->Dataset.GetField(this->FieldName),
this->ScalarRange,
this->Dataset.GetCellSet(),
this->Dataset.GetCoordinateSystem(this->CoordinateName),
this->Dataset.GetGhostCellField());
}
else
{
Tracer.SetEnergyData(this->ScalarField,
Tracer.SetEnergyData(this->Dataset.GetField(this->FieldName),
rays.Buffers.at(0).GetNumChannels(),
this->Cells,
this->Coords,
this->EmissionField);
this->Dataset.GetCellSet(),
this->Dataset.GetCoordinateSystem(this->CoordinateName),
this->Dataset.GetField(this->EmissionFieldName));
}
Tracer.FullTrace(rays);
@ -149,15 +155,19 @@ public:
{
if (this->Mode == RenderMode::Volume)
{
Tracer.SetVolumeData(this->ScalarField, this->ScalarRange, this->Cells, this->Coords);
Tracer.SetVolumeData(this->Dataset.GetField(this->FieldName),
this->ScalarRange,
this->Dataset.GetCellSet(),
this->Dataset.GetCoordinateSystem(this->CoordinateName),
this->Dataset.GetGhostCellField());
}
else
{
Tracer.SetEnergyData(this->ScalarField,
Tracer.SetEnergyData(this->Dataset.GetField(this->FieldName),
rays.Buffers.at(0).GetNumChannels(),
this->Cells,
this->Coords,
this->EmissionField);
this->Dataset.GetCellSet(),
this->Dataset.GetCoordinateSystem(this->CoordinateName),
this->Dataset.GetField(this->EmissionFieldName));
}
Tracer.FullTrace(rays);
@ -169,15 +179,19 @@ public:
if (this->Mode == RenderMode::Volume)
{
Tracer.SetVolumeData(this->ScalarField, this->ScalarRange, this->Cells, this->Coords);
Tracer.SetVolumeData(this->Dataset.GetField(this->FieldName),
this->ScalarRange,
this->Dataset.GetCellSet(),
this->Dataset.GetCoordinateSystem(this->CoordinateName),
this->Dataset.GetGhostCellField());
}
else
{
Tracer.SetEnergyData(this->ScalarField,
Tracer.SetEnergyData(this->Dataset.GetField(this->FieldName),
rays.Buffers.at(0).GetNumChannels(),
this->Cells,
this->Coords,
this->EmissionField);
this->Dataset.GetCellSet(),
this->Dataset.GetCoordinateSystem(this->CoordinateName),
this->Dataset.GetField(this->EmissionFieldName));
}
return Tracer.PartialTrace(rays);
@ -188,15 +202,19 @@ public:
{
if (this->Mode == RenderMode::Volume)
{
Tracer.SetVolumeData(this->ScalarField, this->ScalarRange, this->Cells, this->Coords);
Tracer.SetVolumeData(this->Dataset.GetField(this->FieldName),
this->ScalarRange,
this->Dataset.GetCellSet(),
this->Dataset.GetCoordinateSystem(this->CoordinateName),
this->Dataset.GetGhostCellField());
}
else
{
Tracer.SetEnergyData(this->ScalarField,
Tracer.SetEnergyData(this->Dataset.GetField(this->FieldName),
rays.Buffers.at(0).GetNumChannels(),
this->Cells,
this->Coords,
this->EmissionField);
this->Dataset.GetCellSet(),
this->Dataset.GetCoordinateSystem(this->CoordinateName),
this->Dataset.GetField(this->EmissionFieldName));
}
return Tracer.PartialTrace(rays);
@ -214,13 +232,17 @@ public:
rayCamera.SetParameters(
camera, (vtkm::Int32)canvas->GetWidth(), (vtkm::Int32)canvas->GetHeight());
vtkm::rendering::raytracing::Ray<vtkm::Float32> rays;
rayCamera.CreateRays(rays, this->Coords.GetBounds());
rayCamera.CreateRays(rays, this->Dataset.GetCoordinateSystem(this->CoordinateName).GetBounds());
rays.Buffers.at(0).InitConst(0.f);
raytracing::RayOperations::MapCanvasToRays(rays, camera, *canvas);
if (this->Mode == RenderMode::Volume)
{
Tracer.SetVolumeData(this->ScalarField, this->ScalarRange, this->Cells, this->Coords);
Tracer.SetVolumeData(this->Dataset.GetField(this->FieldName),
this->ScalarRange,
this->Dataset.GetCellSet(),
this->Dataset.GetCoordinateSystem(this->CoordinateName),
this->Dataset.GetGhostCellField());
}
else
{
@ -241,22 +263,31 @@ public:
VTKM_CONT
ConnectivityProxy::ConnectivityProxy(const vtkm::cont::DataSet& dataSet,
const std::string& fieldName)
: Internals(std::make_unique<InternalsType>(dataSet, fieldName))
: Internals(
std::make_unique<InternalsType>(dataSet, dataSet.GetCoordinateSystemName(), fieldName))
{
}
VTKM_CONT
ConnectivityProxy::ConnectivityProxy(const vtkm::cont::DataSet& dataSet,
const std::string& fieldName,
const std::string& coordinateName)
: Internals(std::make_unique<InternalsType>(dataSet, coordinateName, fieldName))
{
}
VTKM_CONT
ConnectivityProxy::ConnectivityProxy(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField)
{
vtkm::cont::DataSet dataset;
dataset.SetCellSet(cellset);
dataset.AddCoordinateSystem(coords);
dataset.AddField(scalarField);
Internals = std::make_unique<InternalsType>(dataset, scalarField.GetName());
Internals = std::make_unique<InternalsType>(dataset, coords.GetName(), scalarField.GetName());
}
ConnectivityProxy::ConnectivityProxy(const ConnectivityProxy& rhs)

5
vtkm/rendering/ConnectivityProxy.h
View File

@ -31,6 +31,11 @@ class VTKM_RENDERING_EXPORT ConnectivityProxy
{
public:
ConnectivityProxy(const vtkm::cont::DataSet& dataset, const std::string& fieldName);
ConnectivityProxy(const vtkm::cont::DataSet& dataSet,
const std::string& fieldName,
const std::string& coordinateName);
ConnectivityProxy(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField);

91
vtkm/rendering/Mapper.cxx
View File

@ -8,6 +8,7 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#include <vtkm/cont/BoundsCompute.h>
#include <vtkm/rendering/Mapper.h>
namespace vtkm
@ -17,6 +18,96 @@ namespace rendering
Mapper::~Mapper() {}
void Mapper::RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange)
{
RenderCellsImpl(
cellset,
coords,
scalarField,
colorTable,
camera,
scalarRange,
make_FieldCell(vtkm::cont::GetGlobalGhostCellFieldName(),
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(0, cellset.GetNumberOfCells())));
};
void Mapper::RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& ghostField)
{
RenderCellsImpl(cellset, coords, scalarField, colorTable, camera, scalarRange, ghostField);
};
struct CompareIndices
{
vtkm::Vec3f CameraDirection;
std::vector<vtkm::Vec3f>& Centers;
bool SortBackToFront;
CompareIndices(std::vector<vtkm::Vec3f>& centers,
vtkm::Vec3f cameraDirection,
bool sortBackToFront)
: CameraDirection(cameraDirection)
, Centers(centers)
, SortBackToFront(sortBackToFront)
{
}
bool operator()(vtkm::Id i, vtkm::Id j) const
{
if (this->SortBackToFront)
{
return (vtkm::Dot(this->Centers[i], this->CameraDirection) >
vtkm::Dot(this->Centers[j], this->CameraDirection));
}
else
{
return (vtkm::Dot(this->Centers[i], this->CameraDirection) <
vtkm::Dot(this->Centers[j], this->CameraDirection));
}
}
};
void Mapper::RenderCellsPartitioned(const vtkm::cont::PartitionedDataSet partitionedData,
const std::string fieldName,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange)
{
// sort partitions back to front for best rendering with the volume renderer
std::vector<vtkm::Vec3f> centers(partitionedData.GetNumberOfPartitions()); // vector for centers
std::vector<vtkm::Id> indices(partitionedData.GetNumberOfPartitions());
for (vtkm::Id p = 0; p < partitionedData.GetNumberOfPartitions(); p++)
{
indices[static_cast<size_t>(p)] = p;
centers[static_cast<size_t>(p)] =
vtkm::cont::BoundsCompute(partitionedData.GetPartition(p)).Center();
}
CompareIndices comparator(
centers, camera.GetLookAt() - camera.GetPosition(), this->SortBackToFront);
std::sort(indices.begin(), indices.end(), comparator);
for (vtkm::Id p = 0; p < partitionedData.GetNumberOfPartitions(); p++)
{
auto partition = partitionedData.GetPartition(indices[static_cast<size_t>(p)]);
this->RenderCells(partition.GetCellSet(),
partition.GetCoordinateSystem(),
partition.GetField(fieldName),
colorTable,
camera,
scalarRange,
partition.GetGhostCellField());
}
}
void Mapper::SetActiveColorTable(const vtkm::cont::ColorTable& colorTable)
{

29
vtkm/rendering/Mapper.h
View File

@ -13,6 +13,7 @@
#include <vtkm/cont/ColorTable.h>
#include <vtkm/cont/CoordinateSystem.h>
#include <vtkm/cont/Field.h>
#include <vtkm/cont/PartitionedDataSet.h>
#include <vtkm/cont/UnknownCellSet.h>
#include <vtkm/rendering/Camera.h>
#include <vtkm/rendering/Canvas.h>
@ -38,7 +39,21 @@ public:
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange) = 0;
const vtkm::Range& scalarRange);
void RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& ghostField);
virtual void RenderCellsPartitioned(const vtkm::cont::PartitionedDataSet partitionedData,
const std::string fieldName,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange);
virtual void SetActiveColorTable(const vtkm::cont::ColorTable& ct);
@ -54,6 +69,18 @@ protected:
vtkm::cont::ArrayHandle<vtkm::Vec4f_32> ColorMap;
bool LogarithmX = false;
bool LogarithmY = false;
// for the volume renderer sorting back to front gives better results for transarent colors, which is the default
// but for the raytracer front to back is better.
bool SortBackToFront = true;
virtual void RenderCellsImpl(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& ghostField) = 0;
};
}
} //namespace vtkm::rendering

23
vtkm/rendering/MapperConnectivity.cxx
View File

@ -59,14 +59,23 @@ vtkm::rendering::Canvas* MapperConnectivity::GetCanvas() const
VTKM_CONT
void MapperConnectivity::RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& vtkmNotUsed(colorTable),
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange)
void MapperConnectivity::RenderCellsImpl(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& vtkmNotUsed(colorTable),
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& ghostField)
{
vtkm::rendering::ConnectivityProxy tracerProxy(cellset, coords, scalarField);
vtkm::cont::DataSet dataset;
dataset.SetCellSet(cellset);
dataset.AddCoordinateSystem(coords);
dataset.AddField(scalarField);
dataset.AddField(ghostField);
vtkm::rendering::ConnectivityProxy tracerProxy(dataset, scalarField.GetName());
if (SampleDistance == -1.f)
{
// set a default distance

14
vtkm/rendering/MapperConnectivity.h
View File

@ -30,19 +30,19 @@ public:
void SetCanvas(vtkm::rendering::Canvas* canvas) override;
virtual vtkm::rendering::Canvas* GetCanvas() const override;
virtual void RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable&, //colorTable
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange) override;
vtkm::rendering::Mapper* NewCopy() const override;
void CreateDefaultView();
protected:
vtkm::Float32 SampleDistance;
CanvasRayTracer* CanvasRT;
virtual void RenderCellsImpl(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable&, //colorTable
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& ghostField) override;
};
}
} //namespace vtkm::rendering

13
vtkm/rendering/MapperCylinder.cxx
View File

@ -115,12 +115,13 @@ void MapperCylinder::SetRadiusDelta(const vtkm::Float32& delta)
this->Internals->Delta = delta;
}
void MapperCylinder::RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& vtkmNotUsed(colorTable),
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange)
void MapperCylinder::RenderCellsImpl(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& vtkmNotUsed(colorTable),
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& vtkmNotUsed(ghostField))
{
raytracing::Logger* logger = raytracing::Logger::GetInstance();
logger->OpenLogEntry("mapper_cylinder");

15
vtkm/rendering/MapperCylinder.h
View File

@ -61,13 +61,6 @@ public:
*/
void SetRadiusDelta(const vtkm::Float32& delta);
void RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange) override;
void SetCompositeBackground(bool on);
vtkm::rendering::Mapper* NewCopy() const override;
@ -76,6 +69,14 @@ private:
std::shared_ptr<InternalsType> Internals;
struct RenderFunctor;
void RenderCellsImpl(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& ghostField) override;
};
}
} //namespace vtkm::rendering

13
vtkm/rendering/MapperGlyphScalar.cxx
View File

@ -320,12 +320,13 @@ void MapperGlyphScalar::SetGlyphType(vtkm::rendering::GlyphType glyphType)
this->GlyphType = glyphType;
}
void MapperGlyphScalar::RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& vtkmNotUsed(colorTable),
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange)
void MapperGlyphScalar::RenderCellsImpl(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& vtkmNotUsed(colorTable),
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& vtkmNotUsed(ghostField))
{
raytracing::Logger* logger = raytracing::Logger::GetInstance();

15
vtkm/rendering/MapperGlyphScalar.h
View File

@ -34,17 +34,18 @@ public:
/// @copydoc GetGlyphType
void SetGlyphType(vtkm::rendering::GlyphType glyphType);
void RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange) override;
vtkm::rendering::Mapper* NewCopy() const override;
protected:
vtkm::rendering::GlyphType GlyphType;
void RenderCellsImpl(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& ghostField) override;
};
}
} //namespace vtkm::rendering

13
vtkm/rendering/MapperGlyphVector.cxx
View File

@ -50,12 +50,13 @@ void MapperGlyphVector::SetGlyphType(vtkm::rendering::GlyphType glyphType)
this->GlyphType = glyphType;
}
void MapperGlyphVector::RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& field,
const vtkm::cont::ColorTable& vtkmNotUsed(colorTable),
const vtkm::rendering::Camera& camera,
const vtkm::Range& vtkmNotUsed(fieldRange))
void MapperGlyphVector::RenderCellsImpl(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& field,
const vtkm::cont::ColorTable& vtkmNotUsed(colorTable),
const vtkm::rendering::Camera& camera,
const vtkm::Range& vtkmNotUsed(fieldRange),
const vtkm::cont::Field& vtkmNotUsed(ghostField))
{
raytracing::Logger* logger = raytracing::Logger::GetInstance();

15
vtkm/rendering/MapperGlyphVector.h
View File

@ -35,17 +35,18 @@ public:
/// @copydoc GetGlyphType
void SetGlyphType(vtkm::rendering::GlyphType glyphType);
void RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange) override;
vtkm::rendering::Mapper* NewCopy() const override;
protected:
vtkm::rendering::GlyphType GlyphType;
void RenderCellsImpl(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& ghostField) override;
};
}
} //namespace vtkm::rendering

13
vtkm/rendering/MapperPoint.cxx
View File

@ -136,12 +136,13 @@ void MapperPoint::UseVariableRadius(bool useVariableRadius)
this->Internals->UseVariableRadius = useVariableRadius;
}
void MapperPoint::RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& vtkmNotUsed(colorTable),
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange)
void MapperPoint::RenderCellsImpl(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& vtkmNotUsed(colorTable),
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& vtkmNotUsed(ghostField))
{
raytracing::Logger* logger = raytracing::Logger::GetInstance();

15
vtkm/rendering/MapperPoint.h
View File

@ -76,13 +76,6 @@ public:
/// of base +/- base * 0.5.
void SetRadiusDelta(const vtkm::Float32& delta);
void RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange) override;
void SetCompositeBackground(bool on);
vtkm::rendering::Mapper* NewCopy() const override;
@ -91,6 +84,14 @@ private:
std::shared_ptr<InternalsType> Internals;
struct RenderFunctor;
void RenderCellsImpl(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& ghostField) override;
};
}
} //namespace vtkm::rendering

13
vtkm/rendering/MapperQuad.cxx
View File

@ -70,12 +70,13 @@ vtkm::rendering::Canvas* MapperQuad::GetCanvas() const
return this->Internals->Canvas;
}
void MapperQuad::RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& vtkmNotUsed(colorTable),
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange)
void MapperQuad::RenderCellsImpl(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& vtkmNotUsed(colorTable),
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& vtkmNotUsed(ghostField))
{
raytracing::Logger* logger = raytracing::Logger::GetInstance();
logger->OpenLogEntry("mapper_ray_tracer");

15
vtkm/rendering/MapperQuad.h
View File

@ -38,13 +38,6 @@ public:
void SetCanvas(vtkm::rendering::Canvas* canvas) override;
virtual vtkm::rendering::Canvas* GetCanvas() const override;
void RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange) override;
void SetCompositeBackground(bool on);
vtkm::rendering::Mapper* NewCopy() const override;
@ -53,6 +46,14 @@ private:
std::shared_ptr<InternalsType> Internals;
struct RenderFunctor;
void RenderCellsImpl(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& ghostField) override;
};
}
} //namespace vtkm::rendering

22
vtkm/rendering/MapperRayTracer.cxx
View File

@ -10,6 +10,7 @@
#include <vtkm/rendering/MapperRayTracer.h>
#include <vtkm/cont/BoundsCompute.h>
#include <vtkm/cont/Timer.h>
#include <vtkm/cont/TryExecute.h>
@ -48,6 +49,9 @@ struct MapperRayTracer::InternalsType
MapperRayTracer::MapperRayTracer()
: Internals(new InternalsType)
{
// for the volume renderer sorting back to front gives better results, which is the default
// but for the raytracer front to back is better.
this->SortBackToFront = false;
}
MapperRayTracer::~MapperRayTracer() {}
@ -73,12 +77,13 @@ vtkm::rendering::Canvas* MapperRayTracer::GetCanvas() const
return this->Internals->Canvas;
}
void MapperRayTracer::RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& vtkmNotUsed(colorTable),
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange)
void MapperRayTracer::RenderCellsImpl(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& vtkmNotUsed(colorTable),
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& ghostField)
{
raytracing::Logger* logger = raytracing::Logger::GetInstance();
logger->OpenLogEntry("mapper_ray_tracer");
@ -93,7 +98,8 @@ void MapperRayTracer::RenderCells(const vtkm::cont::UnknownCellSet& cellset,
//
vtkm::Bounds shapeBounds;
raytracing::TriangleExtractor triExtractor;
triExtractor.ExtractCells(cellset);
triExtractor.ExtractCells(cellset, ghostField);
if (triExtractor.GetNumberOfTriangles() > 0)
{
auto triIntersector = std::make_shared<raytracing::TriangleIntersector>();
@ -116,8 +122,6 @@ void MapperRayTracer::RenderCells(const vtkm::cont::UnknownCellSet& cellset,
raytracing::RayOperations::MapCanvasToRays(
this->Internals->Rays, camera, *this->Internals->Canvas);
this->Internals->Tracer.SetField(scalarField, scalarRange);
this->Internals->Tracer.SetColorMap(this->ColorMap);

16
vtkm/rendering/MapperRayTracer.h
View File

@ -35,13 +35,6 @@ public:
void SetCanvas(vtkm::rendering::Canvas* canvas) override;
virtual vtkm::rendering::Canvas* GetCanvas() const override;
void RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange) override;
void SetCompositeBackground(bool on);
vtkm::rendering::Mapper* NewCopy() const override;
void SetShadingOn(bool on);
@ -49,6 +42,15 @@ public:
private:
struct InternalsType;
std::shared_ptr<InternalsType> Internals;
struct CompareIndices;
void RenderCellsImpl(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& ghostField) override;
};
}
} //namespace vtkm::rendering

13
vtkm/rendering/MapperVolume.cxx
View File

@ -72,12 +72,13 @@ vtkm::rendering::Canvas* MapperVolume::GetCanvas() const
return this->Internals->Canvas;
}
void MapperVolume::RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& vtkmNotUsed(colorTable),
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange)
void MapperVolume::RenderCellsImpl(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& vtkmNotUsed(colorTable),
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& vtkmNotUsed(ghostField))
{
if (!cellset.CanConvert<vtkm::cont::CellSetStructured<3>>())
{

15
vtkm/rendering/MapperVolume.h
View File

@ -30,13 +30,6 @@ public:
void SetCanvas(vtkm::rendering::Canvas* canvas) override;
virtual vtkm::rendering::Canvas* GetCanvas() const override;
virtual void RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable&, //colorTable
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange) override;
vtkm::rendering::Mapper* NewCopy() const override;
/// @brief Specify how much space is between samples of rays that traverse the volume.
///
@ -49,6 +42,14 @@ public:
private:
struct InternalsType;
std::shared_ptr<InternalsType> Internals;
virtual void RenderCellsImpl(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable&, //colorTable
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& ghostField) override;
};
}
} //namespace vtkm::rendering

19
vtkm/rendering/MapperWireframer.cxx
View File

@ -227,12 +227,13 @@ void MapperWireframer::SetIsOverlay(bool isOverlay)
this->Internals->IsOverlay = isOverlay;
}
void MapperWireframer::RenderCells(const vtkm::cont::UnknownCellSet& inCellSet,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& inScalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange)
void MapperWireframer::RenderCellsImpl(const vtkm::cont::UnknownCellSet& inCellSet,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& inScalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& ghostField)
{
vtkm::cont::UnknownCellSet cellSet = inCellSet;
@ -241,6 +242,7 @@ void MapperWireframer::RenderCells(const vtkm::cont::UnknownCellSet& inCellSet,
vtkm::cont::CoordinateSystem actualCoords = coords;
vtkm::cont::Field actualField = inScalarField;
vtkm::cont::Field actualGhostField = ghostField;
if (is1D)
{
@ -298,12 +300,14 @@ void MapperWireframer::RenderCells(const vtkm::cont::UnknownCellSet& inCellSet,
dataSet.AddCoordinateSystem(actualCoords);
dataSet.SetCellSet(inCellSet);
dataSet.AddField(inScalarField);
dataSet.AddField(ghostField);
vtkm::filter::entity_extraction::ExternalFaces externalFaces;
externalFaces.SetCompactPoints(false);
externalFaces.SetPassPolyData(true);
vtkm::cont::DataSet output = externalFaces.Execute(dataSet);
cellSet = output.GetCellSet();
actualField = output.GetField(inScalarField.GetName());
actualGhostField = output.GetGhostCellField();
}
// Extract unique edges from the cell set.
@ -331,7 +335,8 @@ void MapperWireframer::RenderCells(const vtkm::cont::UnknownCellSet& inCellSet,
MapperRayTracer raytracer;
raytracer.SetCanvas(&canvas);
raytracer.SetActiveColorTable(colorTable);
raytracer.RenderCells(cellSet, actualCoords, actualField, colorTable, camera, scalarRange);
raytracer.RenderCells(
cellSet, actualCoords, actualField, colorTable, camera, scalarRange, actualGhostField);
renderer.SetSolidDepthBuffer(canvas.GetDepthBuffer());
}
else

15
vtkm/rendering/MapperWireframer.h
View File

@ -52,18 +52,19 @@ public:
bool GetIsOverlay() const;
void SetIsOverlay(bool isOverlay);
virtual void RenderCells(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange) override;
virtual vtkm::rendering::Mapper* NewCopy() const override;
private:
struct InternalsType;
std::shared_ptr<InternalsType> Internals;
virtual void RenderCellsImpl(const vtkm::cont::UnknownCellSet& cellset,
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable,
const vtkm::rendering::Camera& camera,
const vtkm::Range& scalarRange,
const vtkm::cont::Field& ghostField) override;
}; // class MapperWireframer
}
} // namespace vtkm::rendering

2
vtkm/rendering/ScalarRenderer.cxx
View File

@ -77,7 +77,7 @@ void ScalarRenderer::SetInput(vtkm::cont::DataSet& dataSet)
raytracing::TriangleExtractor triExtractor;
vtkm::cont::UnknownCellSet cellSet = this->Internals->DataSet.GetCellSet();
vtkm::cont::CoordinateSystem coords = this->Internals->DataSet.GetCoordinateSystem();
triExtractor.ExtractCells(cellSet);
triExtractor.ExtractCells(cellSet, dataSet.GetGhostCellField());
if (triExtractor.GetNumberOfTriangles() > 0)
{

111
vtkm/rendering/Triangulator.h
View File

@ -19,8 +19,10 @@
#include <vtkm/rendering/raytracing/MeshConnectivityBuilder.h>
#include <vtkm/worklet/DispatcherMapField.h>
#include <vtkm/worklet/DispatcherMapTopology.h>
#include <vtkm/worklet/ScatterUniform.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/WorkletMapTopology.h>
namespace vtkm
{
namespace rendering
@ -34,18 +36,51 @@ namespace rendering
class Triangulator
{
public:
struct InterleaveArrays12 : vtkm::worklet::WorkletMapField
{
using ControlSignature = void(FieldIn, FieldOut);
using ExecutionSignature = void(_1, _2);
using InputDomain = _1;
using ScatterType = vtkm::worklet::ScatterUniform<12>;
template <typename T>
VTKM_EXEC void operator()(const T& input, T& output) const
{
if (int(input) == 0)
output = 1;
}
};
struct InterleaveArrays2 : vtkm::worklet::WorkletMapField
{
using ControlSignature = void(FieldIn, FieldOut);
using ExecutionSignature = void(_1, _2);
using InputDomain = _1;
using ScatterType = vtkm::worklet::ScatterUniform<2>;
template <typename T>
VTKM_EXEC void operator()(const T& input, T& output) const
{
if (int(input) == 0)
output = 1;
}
};
class CountTriangles : public vtkm::worklet::WorkletVisitCellsWithPoints
{
public:
VTKM_CONT
CountTriangles() {}
using ControlSignature = void(CellSetIn cellset, FieldOut);
using ExecutionSignature = void(CellShape, _2);
using ControlSignature = void(CellSetIn cellset, FieldInCell ghostField, FieldOut triangles);
using ExecutionSignature = void(CellShape, _2, _3);
VTKM_EXEC
void operator()(vtkm::CellShapeTagGeneric shapeType, vtkm::Id& triangles) const
template <typename ghostlArrayType>
VTKM_EXEC void operator()(vtkm::CellShapeTagGeneric shapeType,
ghostlArrayType& ghostField,
vtkm::Id& triangles) const
{
if (shapeType.Id == vtkm::CELL_SHAPE_TRIANGLE)
if (int(ghostField) != 0)
triangles = 0;
else if (shapeType.Id == vtkm::CELL_SHAPE_TRIANGLE)
triangles = 1;
else if (shapeType.Id == vtkm::CELL_SHAPE_QUAD)
triangles = 2;
@ -61,21 +96,38 @@ public:
triangles = 0;
}
VTKM_EXEC
void operator()(vtkm::CellShapeTagHexahedron vtkmNotUsed(shapeType), vtkm::Id& triangles) const
template <typename ghostlArrayType>
VTKM_EXEC void operator()(vtkm::CellShapeTagHexahedron vtkmNotUsed(shapeType),
ghostlArrayType& ghostField,
vtkm::Id& triangles) const
{
triangles = 12;
if (int(ghostField) != 0)
triangles = 0;
else
triangles = 12;
}
VTKM_EXEC
void operator()(vtkm::CellShapeTagQuad vtkmNotUsed(shapeType), vtkm::Id& triangles) const
template <typename ghostlArrayType>
VTKM_EXEC void operator()(vtkm::CellShapeTagQuad vtkmNotUsed(shapeType),
ghostlArrayType& ghostField,
vtkm::Id& triangles) const
{
triangles = 2;
if (int(ghostField) != 0)
triangles = 0;
else
triangles = 2;
}
VTKM_EXEC
void operator()(vtkm::CellShapeTagWedge vtkmNotUsed(shapeType), vtkm::Id& triangles) const
template <typename ghostlArrayType>
VTKM_EXEC void operator()(vtkm::CellShapeTagWedge vtkmNotUsed(shapeType),
ghostlArrayType& ghostField,
vtkm::Id& triangles) const
{
triangles = 8;
if (int(ghostField) != 0)
triangles = 0;
else
triangles = 8;
}
}; //class CountTriangles
@ -643,7 +695,8 @@ public:
VTKM_CONT
void Run(const vtkm::cont::UnknownCellSet& cellset,
vtkm::cont::ArrayHandle<vtkm::Id4>& outputIndices,
vtkm::Id& outputTriangles)
vtkm::Id& outputTriangles,
const vtkm::cont::Field& ghostField = vtkm::cont::Field())
{
bool fastPath = false;
if (cellset.CanConvert<vtkm::cont::CellSetStructured<3>>())
@ -665,6 +718,17 @@ public:
.Invoke(cellSetStructured3D, cellIdxs, outputIndices);
outputTriangles = numCells * 12;
// removed blanked triangles
vtkm::cont::ArrayHandle<vtkm::UInt8> triangleGhostArrayHandle;
triangleGhostArrayHandle.AllocateAndFill(outputTriangles, 0); //numCells * 12
vtkm::worklet::DispatcherMapField<InterleaveArrays12>(InterleaveArrays12())
.Invoke(ghostField.GetData().ExtractComponent<vtkm::UInt8>(0), triangleGhostArrayHandle);
vtkm::cont::ArrayHandle<vtkm::Id4> nonGhostTriangles;
vtkm::cont::Algorithm::CopyIf(outputIndices, triangleGhostArrayHandle, nonGhostTriangles);
outputTriangles = nonGhostTriangles.GetNumberOfValues();
outputIndices = nonGhostTriangles;
}
else if (cellset.CanConvert<vtkm::cont::CellSetStructured<2>>())
{
@ -678,6 +742,18 @@ public:
.Invoke(cellSetStructured2D, cellIdxs, outputIndices);
outputTriangles = numCells * 2;
// removed blanked triangles
vtkm::cont::ArrayHandle<vtkm::UInt8> triangleGhostArrayHandle;
triangleGhostArrayHandle.AllocateAndFill(outputTriangles, 0); //numCells * 2
vtkm::worklet::DispatcherMapField<InterleaveArrays2>(InterleaveArrays2())
.Invoke(ghostField.GetData().ExtractComponent<vtkm::UInt8>(0), triangleGhostArrayHandle);
vtkm::cont::ArrayHandle<vtkm::Id4> nonGhostTriangles;
vtkm::cont::Algorithm::CopyIf(outputIndices, triangleGhostArrayHandle, nonGhostTriangles);
outputTriangles = nonGhostTriangles.GetNumberOfValues();
outputIndices = nonGhostTriangles;
// no need to do external faces on 2D cell set
fastPath = true;
}
@ -686,8 +762,11 @@ public:
auto cellSetUnstructured =
cellset.ResetCellSetList(VTKM_DEFAULT_CELL_SET_LIST_UNSTRUCTURED{});
vtkm::cont::ArrayHandle<vtkm::Id> trianglesPerCell;
vtkm::worklet::DispatcherMapTopology<CountTriangles>(CountTriangles())
.Invoke(cellSetUnstructured, trianglesPerCell);
.Invoke(cellSetUnstructured,
ghostField.GetData().ExtractComponent<vtkm::UInt8>(0),
trianglesPerCell);
vtkm::Id totalTriangles = 0;
totalTriangles = vtkm::cont::Algorithm::Reduce(trianglesPerCell, vtkm::Id(0));

5
vtkm/rendering/internal/RunTriangulator.cxx
View File

@ -22,10 +22,11 @@ namespace internal
void RunTriangulator(const vtkm::cont::UnknownCellSet& cellSet,
vtkm::cont::ArrayHandle<vtkm::Id4>& indices,
vtkm::Id& numberOfTriangles)
vtkm::Id& numberOfTriangles,
const vtkm::cont::Field& ghostField)
{
vtkm::rendering::Triangulator triangulator;
triangulator.Run(cellSet, indices, numberOfTriangles);
triangulator.Run(cellSet, indices, numberOfTriangles, ghostField);
}
}
}

4
vtkm/rendering/internal/RunTriangulator.h
View File

@ -13,6 +13,7 @@
#include <vtkm/rendering/vtkm_rendering_export.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/Field.h>
#include <vtkm/cont/RuntimeDeviceTracker.h>
#include <vtkm/cont/UnknownCellSet.h>
@ -31,7 +32,8 @@ namespace internal
VTKM_RENDERING_EXPORT
void RunTriangulator(const vtkm::cont::UnknownCellSet& cellSet,
vtkm::cont::ArrayHandle<vtkm::Id4>& indices,
vtkm::Id& numberOfTriangles);
vtkm::Id& numberOfTriangles,
const vtkm::cont::Field& ghostField = vtkm::cont::Field());
}
}
} // namespace vtkm::rendering::internal

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

@ -196,10 +196,12 @@ void ConnectivityTracer::SetColorMap(const vtkm::cont::ArrayHandle<vtkm::Vec4f_3
void ConnectivityTracer::SetVolumeData(const vtkm::cont::Field& scalarField,
const vtkm::Range& scalarBounds,
const vtkm::cont::UnknownCellSet& cellSet,
const vtkm::cont::CoordinateSystem& coords)
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& ghostField)
{
//TODO: Need a way to tell if we have been updated
ScalarField = scalarField;
GhostField = ghostField;
ScalarBounds = scalarBounds;
CellSet = cellSet;
Coords = coords;
@ -892,8 +894,8 @@ public:
InvDeltaScalar = (minScalar == maxScalar) ? 1.f : 1.f / (maxScalar - minScalar);
}
using ControlSignature = void(FieldIn,
WholeArrayIn,
WholeArrayIn,
FieldIn,
FieldIn,
@ -902,11 +904,15 @@ public:
WholeArrayIn,
WholeArrayInOut,
FieldIn);
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, _7, _8, WorkIndex, _9);
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, _7, _8, _9, WorkIndex, _10);
template <typename ScalarPortalType, typename ColorMapType, typename FrameBufferType>
template <typename ScalarPortalType,
typename GhostPortalType,
typename ColorMapType,
typename FrameBufferType>
VTKM_EXEC inline void operator()(const vtkm::Id& currentCell,
ScalarPortalType& scalarPortal,
GhostPortalType& ghostPortal,
const FloatType& enterDistance,
const FloatType& exitDistance,
FloatType& currentDistance,
@ -919,6 +925,8 @@ public:
if (rayStatus != RAY_ACTIVE)
return;
if (int(ghostPortal.Get(currentCell)) != 0)
return;
vtkm::Vec4f_32 color;
BOUNDS_CHECK(frameBuffer, pixelIndex * 4 + 0);
@ -1228,6 +1236,7 @@ void ConnectivityTracer::SampleCells(Ray<FloatType>& rays, detail::RayTracking<F
dispatcher.Invoke(rays.HitIdx,
vtkm::rendering::raytracing::GetScalarFieldArray(this->ScalarField),
GhostField.GetData().ExtractComponent<vtkm::UInt8>(0),
*(tracker.EnterDist),
*(tracker.ExitDist),
tracker.CurrentDistance,

4
vtkm/rendering/raytracing/ConnectivityTracer.h
View File

@ -96,7 +96,8 @@ public:
void SetVolumeData(const vtkm::cont::Field& scalarField,
const vtkm::Range& scalarBounds,
const vtkm::cont::UnknownCellSet& cellSet,
const vtkm::cont::CoordinateSystem& coords);
const vtkm::cont::CoordinateSystem& coords,
const vtkm::cont::Field& ghostField);
void SetEnergyData(const vtkm::cont::Field& absorption,
const vtkm::Int32 numBins,
@ -181,6 +182,7 @@ protected:
// Data set info
vtkm::cont::Field ScalarField;
vtkm::cont::Field EmissionField;
vtkm::cont::Field GhostField;
vtkm::cont::UnknownCellSet CellSet;
vtkm::cont::CoordinateSystem Coords;
vtkm::Range ScalarBounds;

12
vtkm/rendering/raytracing/TriangleExtractor.cxx
View File

@ -8,6 +8,7 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#include <vtkm/cont/Field.h>
#include <vtkm/rendering/internal/RunTriangulator.h>
#include <vtkm/rendering/raytracing/TriangleExtractor.h>
@ -19,9 +20,18 @@ namespace raytracing
{
void TriangleExtractor::ExtractCells(const vtkm::cont::UnknownCellSet& cells)
{
ExtractCells(
cells,
make_FieldCell(vtkm::cont::GetGlobalGhostCellFieldName(),
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(0, cells.GetNumberOfCells())));
}
void TriangleExtractor::ExtractCells(const vtkm::cont::UnknownCellSet& cells,
const vtkm::cont::Field& ghostField)
{
vtkm::Id numberOfTriangles;
vtkm::rendering::internal::RunTriangulator(cells, this->Triangles, numberOfTriangles);
vtkm::rendering::internal::RunTriangulator(cells, this->Triangles, numberOfTriangles, ghostField);
}
vtkm::cont::ArrayHandle<vtkm::Id4> TriangleExtractor::GetTriangles()

3
vtkm/rendering/raytracing/TriangleExtractor.h
View File

@ -11,6 +11,7 @@
#define vtk_m_rendering_raytracing_Triangle_Extractor_h
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/Field.h>
#include <vtkm/rendering/vtkm_rendering_export.h>
namespace vtkm
@ -27,6 +28,8 @@ protected:
public:
void ExtractCells(const vtkm::cont::UnknownCellSet& cells);
void ExtractCells(const vtkm::cont::UnknownCellSet& cells, const vtkm::cont::Field& ghostField);
vtkm::cont::ArrayHandle<vtkm::Id4> GetTriangles();
vtkm::Id GetNumberOfTriangles() const;
}; // class TriangleExtractor