mirror of
https://gitlab.kitware.com/vtk/vtk-m
synced 2024-09-20 02:55:47 +00:00
d9cfb8687f
33a154337 add deprecation a7363c283 alter interface of scalar renderer result 5fc77cb58 warnings and store depth separately aa468f5c0 more warning fixes 0943784c2 fix warning 094758e55 make result public? 70584ac8f fix benchmarks 458be65e9 fix logic error ... Acked-by: Kitware Robot <kwrobot@kitware.com> Acked-by: Kenneth Moreland <kmorel@sandia.gov> Merge-request: !1962
441 lines
11 KiB
C++
441 lines
11 KiB
C++
//============================================================================
|
|
// Copyright (c) Kitware, Inc.
|
|
// All rights reserved.
|
|
// See LICENSE.txt for details.
|
|
//
|
|
// This software is distributed WITHOUT ANY WARRANTY; without even
|
|
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
// PURPOSE. See the above copyright notice for more information.
|
|
//============================================================================
|
|
|
|
#include <vtkm/rendering/CanvasRayTracer.h>
|
|
#include <vtkm/rendering/ConnectivityProxy.h>
|
|
#include <vtkm/rendering/Mapper.h>
|
|
#include <vtkm/rendering/raytracing/ConnectivityTracer.h>
|
|
#include <vtkm/rendering/raytracing/Logger.h>
|
|
#include <vtkm/rendering/raytracing/RayOperations.h>
|
|
|
|
|
|
namespace vtkm
|
|
{
|
|
namespace rendering
|
|
{
|
|
struct ConnectivityProxy::InternalsType
|
|
{
|
|
protected:
|
|
using ColorMapType = vtkm::cont::ArrayHandle<vtkm::Vec4f_32>;
|
|
using TracerType = vtkm::rendering::raytracing::ConnectivityTracer;
|
|
|
|
TracerType Tracer;
|
|
vtkm::cont::Field ScalarField;
|
|
vtkm::cont::Field EmissionField;
|
|
vtkm::cont::DynamicCellSet Cells;
|
|
vtkm::cont::CoordinateSystem Coords;
|
|
RenderMode Mode;
|
|
vtkm::Bounds SpatialBounds;
|
|
ColorMapType ColorMap;
|
|
vtkm::cont::DataSet Dataset;
|
|
vtkm::Range ScalarRange;
|
|
bool CompositeBackground;
|
|
|
|
public:
|
|
InternalsType(vtkm::cont::DataSet& dataSet)
|
|
{
|
|
Dataset = dataSet;
|
|
Cells = dataSet.GetCellSet();
|
|
Coords = dataSet.GetCoordinateSystem();
|
|
Mode = VOLUME_MODE;
|
|
CompositeBackground = true;
|
|
//
|
|
// Just grab a default scalar field
|
|
//
|
|
|
|
if (Dataset.GetNumberOfFields() > 0)
|
|
{
|
|
this->SetScalarField(Dataset.GetField(0).GetName());
|
|
}
|
|
}
|
|
|
|
~InternalsType() {}
|
|
|
|
VTKM_CONT
|
|
void SetUnitScalar(vtkm::Float32 unitScalar) { Tracer.SetUnitScalar(unitScalar); }
|
|
|
|
void SetSampleDistance(const vtkm::Float32& distance)
|
|
{
|
|
if (Mode != VOLUME_MODE)
|
|
{
|
|
throw vtkm::cont::ErrorBadValue(
|
|
"Conn Proxy: volume mode must be set before sample distance set");
|
|
}
|
|
Tracer.SetSampleDistance(distance);
|
|
}
|
|
|
|
VTKM_CONT
|
|
void SetRenderMode(RenderMode mode) { Mode = mode; }
|
|
|
|
VTKM_CONT
|
|
RenderMode GetRenderMode() { return Mode; }
|
|
|
|
VTKM_CONT
|
|
void SetScalarField(const std::string& fieldName)
|
|
{
|
|
ScalarField = Dataset.GetField(fieldName);
|
|
const vtkm::cont::ArrayHandle<vtkm::Range> range = this->ScalarField.GetRange();
|
|
ScalarRange = range.ReadPortal().Get(0);
|
|
}
|
|
|
|
VTKM_CONT
|
|
void SetColorMap(vtkm::cont::ArrayHandle<vtkm::Vec4f_32>& colormap)
|
|
{
|
|
Tracer.SetColorMap(colormap);
|
|
}
|
|
|
|
VTKM_CONT
|
|
void SetCompositeBackground(bool on) { CompositeBackground = on; }
|
|
|
|
VTKM_CONT
|
|
void SetDebugPrints(bool on) { Tracer.SetDebugOn(on); }
|
|
|
|
VTKM_CONT
|
|
void SetEpsilon(vtkm::Float64 epsilon) { Tracer.SetEpsilon(epsilon); }
|
|
|
|
VTKM_CONT
|
|
void SetEmissionField(const std::string& fieldName)
|
|
{
|
|
if (Mode != ENERGY_MODE)
|
|
{
|
|
throw vtkm::cont::ErrorBadValue(
|
|
"Conn Proxy: energy mode must be set before setting emission field");
|
|
}
|
|
EmissionField = Dataset.GetField(fieldName);
|
|
}
|
|
|
|
VTKM_CONT
|
|
vtkm::Bounds GetSpatialBounds() const { return SpatialBounds; }
|
|
|
|
VTKM_CONT
|
|
vtkm::Range GetScalarFieldRange()
|
|
{
|
|
const vtkm::cont::ArrayHandle<vtkm::Range> range = this->ScalarField.GetRange();
|
|
ScalarRange = range.ReadPortal().Get(0);
|
|
return ScalarRange;
|
|
}
|
|
|
|
VTKM_CONT
|
|
void SetScalarRange(const vtkm::Range& range) { this->ScalarRange = range; }
|
|
|
|
VTKM_CONT
|
|
vtkm::Range GetScalarRange() { return this->ScalarRange; }
|
|
|
|
VTKM_CONT
|
|
void Trace(vtkm::rendering::raytracing::Ray<vtkm::Float64>& rays)
|
|
{
|
|
|
|
if (Mode == VOLUME_MODE)
|
|
{
|
|
Tracer.SetVolumeData(this->ScalarField, this->ScalarRange, this->Cells, this->Coords);
|
|
}
|
|
else
|
|
{
|
|
Tracer.SetEnergyData(this->ScalarField,
|
|
rays.Buffers.at(0).GetNumChannels(),
|
|
this->Cells,
|
|
this->Coords,
|
|
this->EmissionField);
|
|
}
|
|
|
|
Tracer.FullTrace(rays);
|
|
}
|
|
|
|
VTKM_CONT
|
|
void Trace(vtkm::rendering::raytracing::Ray<vtkm::Float32>& rays)
|
|
{
|
|
if (Mode == VOLUME_MODE)
|
|
{
|
|
Tracer.SetVolumeData(this->ScalarField, this->ScalarRange, this->Cells, this->Coords);
|
|
}
|
|
else
|
|
{
|
|
Tracer.SetEnergyData(this->ScalarField,
|
|
rays.Buffers.at(0).GetNumChannels(),
|
|
this->Cells,
|
|
this->Coords,
|
|
this->EmissionField);
|
|
}
|
|
|
|
Tracer.FullTrace(rays);
|
|
}
|
|
|
|
VTKM_CONT
|
|
PartialVector64 PartialTrace(vtkm::rendering::raytracing::Ray<vtkm::Float64>& rays)
|
|
{
|
|
|
|
if (Mode == VOLUME_MODE)
|
|
{
|
|
Tracer.SetVolumeData(this->ScalarField, this->ScalarRange, this->Cells, this->Coords);
|
|
}
|
|
else
|
|
{
|
|
Tracer.SetEnergyData(this->ScalarField,
|
|
rays.Buffers.at(0).GetNumChannels(),
|
|
this->Cells,
|
|
this->Coords,
|
|
this->EmissionField);
|
|
}
|
|
|
|
return Tracer.PartialTrace(rays);
|
|
}
|
|
|
|
VTKM_CONT
|
|
PartialVector32 PartialTrace(vtkm::rendering::raytracing::Ray<vtkm::Float32>& rays)
|
|
{
|
|
if (Mode == VOLUME_MODE)
|
|
{
|
|
Tracer.SetVolumeData(this->ScalarField, this->ScalarRange, this->Cells, this->Coords);
|
|
}
|
|
else
|
|
{
|
|
Tracer.SetEnergyData(this->ScalarField,
|
|
rays.Buffers.at(0).GetNumChannels(),
|
|
this->Cells,
|
|
this->Coords,
|
|
this->EmissionField);
|
|
}
|
|
|
|
return Tracer.PartialTrace(rays);
|
|
}
|
|
|
|
VTKM_CONT
|
|
void Trace(const vtkm::rendering::Camera& camera, vtkm::rendering::CanvasRayTracer* canvas)
|
|
{
|
|
|
|
if (canvas == nullptr)
|
|
{
|
|
throw vtkm::cont::ErrorBadValue("Conn Proxy: null canvas");
|
|
}
|
|
vtkm::rendering::raytracing::Camera rayCamera;
|
|
rayCamera.SetParameters(
|
|
camera, (vtkm::Int32)canvas->GetWidth(), (vtkm::Int32)canvas->GetHeight());
|
|
vtkm::rendering::raytracing::Ray<vtkm::Float32> rays;
|
|
rayCamera.CreateRays(rays, this->Coords.GetBounds());
|
|
rays.Buffers.at(0).InitConst(0.f);
|
|
raytracing::RayOperations::MapCanvasToRays(rays, camera, *canvas);
|
|
|
|
if (Mode == VOLUME_MODE)
|
|
{
|
|
Tracer.SetVolumeData(this->ScalarField, this->ScalarRange, this->Cells, this->Coords);
|
|
}
|
|
else
|
|
{
|
|
throw vtkm::cont::ErrorBadValue("ENERGY MODE Not implemented for this use case\n");
|
|
}
|
|
|
|
Tracer.FullTrace(rays);
|
|
|
|
canvas->WriteToCanvas(rays, rays.Buffers.at(0).Buffer, camera);
|
|
if (CompositeBackground)
|
|
{
|
|
canvas->BlendBackground();
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
VTKM_CONT
|
|
ConnectivityProxy::ConnectivityProxy(vtkm::cont::DataSet& dataSet)
|
|
: Internals(new InternalsType(dataSet))
|
|
{
|
|
}
|
|
|
|
VTKM_CONT
|
|
ConnectivityProxy::ConnectivityProxy(const vtkm::cont::DynamicCellSet& 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::shared_ptr<InternalsType>(new InternalsType(dataset));
|
|
}
|
|
|
|
VTKM_CONT
|
|
ConnectivityProxy::~ConnectivityProxy()
|
|
{
|
|
}
|
|
|
|
VTKM_CONT
|
|
void ConnectivityProxy::SetSampleDistance(const vtkm::Float32& distance)
|
|
{
|
|
Internals->SetSampleDistance(distance);
|
|
}
|
|
|
|
VTKM_CONT
|
|
void ConnectivityProxy::SetRenderMode(RenderMode mode)
|
|
{
|
|
Internals->SetRenderMode(mode);
|
|
}
|
|
|
|
VTKM_CONT
|
|
void ConnectivityProxy::SetScalarField(const std::string& fieldName)
|
|
{
|
|
Internals->SetScalarField(fieldName);
|
|
}
|
|
|
|
VTKM_CONT
|
|
void ConnectivityProxy::SetColorMap(vtkm::cont::ArrayHandle<vtkm::Vec4f_32>& colormap)
|
|
{
|
|
Internals->SetColorMap(colormap);
|
|
}
|
|
|
|
VTKM_CONT
|
|
void ConnectivityProxy::SetEmissionField(const std::string& fieldName)
|
|
{
|
|
Internals->SetEmissionField(fieldName);
|
|
}
|
|
|
|
VTKM_CONT
|
|
vtkm::Bounds ConnectivityProxy::GetSpatialBounds()
|
|
{
|
|
return Internals->GetSpatialBounds();
|
|
}
|
|
|
|
VTKM_CONT
|
|
vtkm::Range ConnectivityProxy::GetScalarFieldRange()
|
|
{
|
|
return Internals->GetScalarFieldRange();
|
|
}
|
|
|
|
VTKM_CONT
|
|
void ConnectivityProxy::SetCompositeBackground(bool on)
|
|
{
|
|
return Internals->SetCompositeBackground(on);
|
|
}
|
|
|
|
VTKM_CONT
|
|
void ConnectivityProxy::SetScalarRange(const vtkm::Range& range)
|
|
{
|
|
Internals->SetScalarRange(range);
|
|
}
|
|
|
|
VTKM_CONT
|
|
vtkm::Range ConnectivityProxy::GetScalarRange()
|
|
{
|
|
return Internals->GetScalarRange();
|
|
}
|
|
|
|
VTKM_CONT
|
|
void ConnectivityProxy::Trace(vtkm::rendering::raytracing::Ray<vtkm::Float64>& rays)
|
|
{
|
|
raytracing::Logger* logger = raytracing::Logger::GetInstance();
|
|
logger->OpenLogEntry("connectivity_trace_64");
|
|
if (Internals->GetRenderMode() == VOLUME_MODE)
|
|
{
|
|
logger->AddLogData("volume_mode", "true");
|
|
}
|
|
else
|
|
{
|
|
logger->AddLogData("volume_mode", "false");
|
|
}
|
|
|
|
Internals->Trace(rays);
|
|
logger->CloseLogEntry(-1.0);
|
|
}
|
|
|
|
VTKM_CONT
|
|
PartialVector32 ConnectivityProxy::PartialTrace(
|
|
vtkm::rendering::raytracing::Ray<vtkm::Float32>& rays)
|
|
{
|
|
raytracing::Logger* logger = raytracing::Logger::GetInstance();
|
|
logger->OpenLogEntry("connectivity_trace_32");
|
|
if (Internals->GetRenderMode() == VOLUME_MODE)
|
|
{
|
|
logger->AddLogData("volume_mode", "true");
|
|
}
|
|
else
|
|
{
|
|
logger->AddLogData("volume_mode", "false");
|
|
}
|
|
|
|
PartialVector32 res = Internals->PartialTrace(rays);
|
|
|
|
logger->CloseLogEntry(-1.0);
|
|
return res;
|
|
}
|
|
|
|
VTKM_CONT
|
|
void ConnectivityProxy::Trace(vtkm::rendering::raytracing::Ray<vtkm::Float32>& rays)
|
|
{
|
|
raytracing::Logger* logger = raytracing::Logger::GetInstance();
|
|
logger->OpenLogEntry("connectivity_trace_32");
|
|
if (Internals->GetRenderMode() == VOLUME_MODE)
|
|
{
|
|
logger->AddLogData("volume_mode", "true");
|
|
}
|
|
else
|
|
{
|
|
logger->AddLogData("volume_mode", "false");
|
|
}
|
|
|
|
Internals->Trace(rays);
|
|
|
|
logger->CloseLogEntry(-1.0);
|
|
}
|
|
|
|
VTKM_CONT
|
|
PartialVector64 ConnectivityProxy::PartialTrace(
|
|
vtkm::rendering::raytracing::Ray<vtkm::Float64>& rays)
|
|
{
|
|
raytracing::Logger* logger = raytracing::Logger::GetInstance();
|
|
logger->OpenLogEntry("connectivity_trace_64");
|
|
if (Internals->GetRenderMode() == VOLUME_MODE)
|
|
{
|
|
logger->AddLogData("volume_mode", "true");
|
|
}
|
|
else
|
|
{
|
|
logger->AddLogData("volume_mode", "false");
|
|
}
|
|
|
|
PartialVector64 res = Internals->PartialTrace(rays);
|
|
|
|
logger->CloseLogEntry(-1.0);
|
|
return res;
|
|
}
|
|
|
|
VTKM_CONT
|
|
void ConnectivityProxy::Trace(const vtkm::rendering::Camera& camera,
|
|
vtkm::rendering::CanvasRayTracer* canvas)
|
|
{
|
|
raytracing::Logger* logger = raytracing::Logger::GetInstance();
|
|
logger->OpenLogEntry("connectivity_trace_32");
|
|
logger->AddLogData("volume_mode", "true");
|
|
|
|
Internals->Trace(camera, canvas);
|
|
|
|
logger->CloseLogEntry(-1.0);
|
|
}
|
|
|
|
VTKM_CONT
|
|
void ConnectivityProxy::SetDebugPrints(bool on)
|
|
{
|
|
Internals->SetDebugPrints(on);
|
|
}
|
|
|
|
VTKM_CONT
|
|
void ConnectivityProxy::SetEpsilon(vtkm::Float64 epsilon)
|
|
{
|
|
Internals->SetEpsilon(epsilon);
|
|
}
|
|
|
|
VTKM_CONT
|
|
void ConnectivityProxy::SetUnitScalar(vtkm::Float32 unitScalar)
|
|
{
|
|
Internals->SetUnitScalar(unitScalar);
|
|
}
|
|
}
|
|
} // namespace vtkm::rendering
|