mirror of
https://gitlab.kitware.com/vtk/vtk-m
synced 2024-10-05 01:49:02 +00:00
Make source parameters more clear
Originally, most of the sources used constructor parameters to set the various options of the source. Although convenient, it was difficult to keep track of what each parameter meant. To make the code more clear, source parameters are now set with accessor functions (e.g. `SetPointDimensions`). Although this makes code more verbose, it helps prevent mistakes and makes the changes more resilient to future changes.
This commit is contained in:
parent
3716f920e6
commit
84bc723121
@ -118,7 +118,9 @@ void BuildInputDataSet(uint32_t cycle, bool isStructured, bool isMultiBlock, vtk
|
||||
PointVectorsName = "perlinnoisegrad";
|
||||
|
||||
// Generate uniform dataset(s)
|
||||
const vtkm::Id3 dims{ dim, dim, dim };
|
||||
vtkm::source::PerlinNoise noise;
|
||||
noise.SetPointDimensions({ dim, dim, dim });
|
||||
noise.SetSeed(static_cast<vtkm::IdComponent>(cycle));
|
||||
if (isMultiBlock)
|
||||
{
|
||||
for (auto i = 0; i < 2; ++i)
|
||||
@ -127,12 +129,9 @@ void BuildInputDataSet(uint32_t cycle, bool isStructured, bool isMultiBlock, vtk
|
||||
{
|
||||
for (auto k = 0; k < 2; ++k)
|
||||
{
|
||||
const vtkm::Vec3f origin{ static_cast<vtkm::FloatDefault>(i),
|
||||
static_cast<vtkm::FloatDefault>(j),
|
||||
static_cast<vtkm::FloatDefault>(k) };
|
||||
const vtkm::source::PerlinNoise noise{ dims,
|
||||
origin,
|
||||
static_cast<vtkm::IdComponent>(cycle) };
|
||||
noise.SetOrigin({ static_cast<vtkm::FloatDefault>(i),
|
||||
static_cast<vtkm::FloatDefault>(j),
|
||||
static_cast<vtkm::FloatDefault>(k) });
|
||||
const auto dataset = noise.Execute();
|
||||
partitionedInputDataSet.AppendPartition(dataset);
|
||||
}
|
||||
@ -141,7 +140,6 @@ void BuildInputDataSet(uint32_t cycle, bool isStructured, bool isMultiBlock, vtk
|
||||
}
|
||||
else
|
||||
{
|
||||
const vtkm::source::PerlinNoise noise{ dims, static_cast<vtkm::IdComponent>(cycle) };
|
||||
inputDataSet = noise.Execute();
|
||||
}
|
||||
|
||||
|
@ -39,9 +39,8 @@ vtkm::cont::InitializeResult Config;
|
||||
|
||||
void BenchRayTracing(::benchmark::State& state)
|
||||
{
|
||||
const vtkm::Id3 dims(128, 128, 128);
|
||||
|
||||
vtkm::source::Tangle maker(dims);
|
||||
vtkm::source::Tangle maker;
|
||||
maker.SetPointDimensions({ 128, 128, 128 });
|
||||
vtkm::cont::DataSet dataset = maker.Execute();
|
||||
vtkm::cont::CoordinateSystem coords = dataset.GetCoordinateSystem();
|
||||
|
||||
|
8
docs/changelog/source-parameters.md
Normal file
8
docs/changelog/source-parameters.md
Normal file
@ -0,0 +1,8 @@
|
||||
# Setting source parameters is more clear
|
||||
|
||||
Originally, most of the sources used constructor parameters to set the
|
||||
various options of the source. Although convenient, it was difficult to
|
||||
keep track of what each parameter meant. To make the code more clear,
|
||||
source parameters are now set with accessor functions (e.g.
|
||||
`SetPointDimensions`). Although this makes code more verbose, it helps
|
||||
prevent mistakes and makes the changes more resilient to future changes.
|
@ -34,7 +34,8 @@ int main(int argc, char* argv[])
|
||||
{
|
||||
vtkm::cont::Initialize(argc, argv, vtkm::cont::InitializeOptions::Strict);
|
||||
|
||||
auto tangle = vtkm::source::Tangle(vtkm::Id3{ 50, 50, 50 });
|
||||
vtkm::source::Tangle tangle;
|
||||
tangle.SetPointDimensions({ 50, 50, 50 });
|
||||
vtkm::cont::DataSet tangleData = tangle.Execute();
|
||||
std::string fieldName = "tangle";
|
||||
|
||||
|
@ -54,7 +54,10 @@ void Test()
|
||||
int cellsPerDimension = 8;
|
||||
|
||||
// Generate AMR
|
||||
vtkm::source::Amr source(dim, cellsPerDimension, numberOfLevels);
|
||||
vtkm::source::Amr source;
|
||||
source.SetDimension(dim);
|
||||
source.SetNumberOfLevels(numberOfLevels);
|
||||
source.SetCellsPerDimension(cellsPerDimension);
|
||||
vtkm::cont::PartitionedDataSet amrDataSet = source.Execute();
|
||||
|
||||
// one point for each partition
|
||||
|
@ -24,8 +24,8 @@ class TestCellSetConnectivity
|
||||
public:
|
||||
static void TestTangleIsosurface()
|
||||
{
|
||||
vtkm::Id3 dims(4, 4, 4);
|
||||
vtkm::source::Tangle tangle(dims);
|
||||
vtkm::source::Tangle tangle;
|
||||
tangle.SetCellDimensions({ 4, 4, 4 });
|
||||
vtkm::cont::DataSet dataSet = tangle.Execute();
|
||||
|
||||
vtkm::filter::contour::Contour filter;
|
||||
|
@ -110,8 +110,8 @@ void TestContourFilterTangle()
|
||||
{
|
||||
std::cout << "Generate Image for Contour filter on a uniform tangle grid" << std::endl;
|
||||
|
||||
vtkm::Id3 dims(4, 4, 4);
|
||||
vtkm::source::Tangle tangle(dims);
|
||||
vtkm::source::Tangle tangle;
|
||||
tangle.SetCellDimensions({ 4, 4, 4 });
|
||||
vtkm::cont::DataSet dataSet = tangle.Execute();
|
||||
|
||||
vtkm::filter::contour::Contour contour;
|
||||
|
@ -24,7 +24,8 @@ void TestSliceStructuredPointsPlane()
|
||||
{
|
||||
std::cout << "Generate Image for Slice by plane on structured points" << std::endl;
|
||||
|
||||
vtkm::source::Wavelet wavelet(vtkm::Id3(-8), vtkm::Id3(8));
|
||||
vtkm::source::Wavelet wavelet;
|
||||
wavelet.SetExtent(vtkm::Id3(-8), vtkm::Id3(8));
|
||||
auto ds = wavelet.Execute();
|
||||
|
||||
vtkm::Plane plane(vtkm::Plane::Vector{ 1, 1, 1 });
|
||||
@ -45,7 +46,8 @@ void TestSliceStructuredPointsSphere()
|
||||
{
|
||||
std::cout << "Generate Image for Slice by sphere on structured points" << std::endl;
|
||||
|
||||
vtkm::source::Wavelet wavelet(vtkm::Id3(-8), vtkm::Id3(8));
|
||||
vtkm::source::Wavelet wavelet;
|
||||
wavelet.SetExtent(vtkm::Id3(-8), vtkm::Id3(8));
|
||||
auto ds = wavelet.Execute();
|
||||
|
||||
vtkm::Sphere sphere(8.5f);
|
||||
@ -66,7 +68,8 @@ void TestSliceUnstructuredGridPlane()
|
||||
{
|
||||
std::cout << "Generate Image for Slice by plane on unstructured grid" << std::endl;
|
||||
|
||||
vtkm::source::Wavelet wavelet(vtkm::Id3(-8), vtkm::Id3(8));
|
||||
vtkm::source::Wavelet wavelet;
|
||||
wavelet.SetExtent(vtkm::Id3(-8), vtkm::Id3(8));
|
||||
auto ds = wavelet.Execute();
|
||||
vtkm::filter::geometry_refinement::Tetrahedralize tetrahedralize;
|
||||
ds = tetrahedralize.Execute(ds);
|
||||
@ -89,7 +92,8 @@ void TestSliceUnstructuredGridCylinder()
|
||||
{
|
||||
std::cout << "Generate Image for Slice by cylinder on unstructured grid" << std::endl;
|
||||
|
||||
vtkm::source::Wavelet wavelet(vtkm::Id3(-8), vtkm::Id3(8));
|
||||
vtkm::source::Wavelet wavelet;
|
||||
wavelet.SetExtent(vtkm::Id3(-8), vtkm::Id3(8));
|
||||
auto ds = wavelet.Execute();
|
||||
vtkm::filter::geometry_refinement::Tetrahedralize tetrahedralize;
|
||||
ds = tetrahedralize.Execute(ds);
|
||||
|
@ -30,8 +30,8 @@ public:
|
||||
{
|
||||
std::cout << "Testing Contour filter on a uniform grid" << std::endl;
|
||||
|
||||
vtkm::Id3 dims(4, 4, 4);
|
||||
vtkm::source::Tangle tangle(dims);
|
||||
vtkm::source::Tangle tangle;
|
||||
tangle.SetCellDimensions({ 4, 4, 4 });
|
||||
vtkm::filter::field_transform::GenerateIds genIds;
|
||||
genIds.SetUseFloat(true);
|
||||
genIds.SetGeneratePointIds(false);
|
||||
|
@ -20,8 +20,8 @@ namespace
|
||||
void TestEntropy()
|
||||
{
|
||||
///// make a data set /////
|
||||
vtkm::Id3 dims(32, 32, 32);
|
||||
vtkm::source::Tangle tangle(dims);
|
||||
vtkm::source::Tangle tangle;
|
||||
tangle.SetCellDimensions({ 32, 32, 32 });
|
||||
vtkm::cont::DataSet dataSet = tangle.Execute();
|
||||
|
||||
vtkm::filter::density_estimate::Entropy entropyFilter;
|
||||
|
@ -77,7 +77,9 @@ void TryGenerateIds(
|
||||
|
||||
void TestGenerateIds()
|
||||
{
|
||||
vtkm::cont::DataSet input = vtkm::source::Tangle{ vtkm::Id3(8) }.Execute();
|
||||
vtkm::source::Tangle tangle;
|
||||
tangle.SetCellDimensions({ 8, 8, 8 });
|
||||
vtkm::cont::DataSet input = tangle.Execute();
|
||||
vtkm::filter::field_transform::GenerateIds filter;
|
||||
|
||||
TryGenerateIds(filter, input);
|
||||
|
@ -113,7 +113,8 @@ vtkm::cont::DataSet Make3DExplicitSimpleCube()
|
||||
vtkm::cont::DataSet Make3DWavelet()
|
||||
{
|
||||
|
||||
vtkm::source::Wavelet wavelet({ -25 }, { 25 });
|
||||
vtkm::source::Wavelet wavelet;
|
||||
wavelet.SetExtent({ -25 }, { 25 });
|
||||
wavelet.SetFrequency({ 60, 30, 40 });
|
||||
wavelet.SetMagnitude({ 5 });
|
||||
|
||||
|
@ -24,7 +24,10 @@ void TestAmrArraysExecute(int dim, int numberOfLevels, int cellsPerDimension)
|
||||
std::cout << "Generate Image for AMR" << std::endl;
|
||||
|
||||
// Generate AMR
|
||||
vtkm::source::Amr source(dim, cellsPerDimension, numberOfLevels);
|
||||
vtkm::source::Amr source;
|
||||
source.SetDimension(dim);
|
||||
source.SetNumberOfLevels(numberOfLevels);
|
||||
source.SetCellsPerDimension(cellsPerDimension);
|
||||
vtkm::cont::PartitionedDataSet amrDataSet = source.Execute();
|
||||
// std::cout << "amr " << std::endl;
|
||||
// amrDataSet.PrintSummary(std::cout);
|
||||
|
@ -93,7 +93,8 @@ void TestMultiBlockFilter()
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
vtkm::Id3 dims(10 + i, 10 + i, 10 + i);
|
||||
vtkm::source::Tangle tangle(dims);
|
||||
vtkm::source::Tangle tangle;
|
||||
tangle.SetCellDimensions(dims);
|
||||
pds.AppendPartition(tangle.Execute());
|
||||
}
|
||||
|
||||
|
@ -30,8 +30,6 @@ Amr::Amr(vtkm::IdComponent dimension,
|
||||
{
|
||||
}
|
||||
|
||||
Amr::~Amr() = default;
|
||||
|
||||
template <vtkm::IdComponent Dim>
|
||||
vtkm::cont::DataSet Amr::GenerateDataSet(unsigned int level, unsigned int amrIndex) const
|
||||
{
|
||||
@ -53,10 +51,11 @@ vtkm::cont::DataSet Amr::GenerateDataSet(unsigned int level, unsigned int amrInd
|
||||
center[2] = 0;
|
||||
}
|
||||
|
||||
vtkm::source::Wavelet waveletSource(-extent, extent);
|
||||
vtkm::source::Wavelet waveletSource;
|
||||
waveletSource.SetOrigin(origin);
|
||||
waveletSource.SetSpacing(spacing);
|
||||
waveletSource.SetCenter(center);
|
||||
waveletSource.SetExtent(-extent, extent);
|
||||
waveletSource.SetFrequency(frequency);
|
||||
waveletSource.SetStandardDeviation(deviation);
|
||||
vtkm::cont::DataSet wavelet = waveletSource.Execute();
|
||||
|
@ -58,22 +58,39 @@ namespace source
|
||||
class VTKM_SOURCE_EXPORT Amr
|
||||
{
|
||||
public:
|
||||
VTKM_CONT
|
||||
Amr(vtkm::IdComponent dimension = 2,
|
||||
vtkm::IdComponent cellsPerDimension = 6,
|
||||
vtkm::IdComponent numberOfLevels = 4);
|
||||
VTKM_CONT
|
||||
~Amr();
|
||||
VTKM_CONT Amr() = default;
|
||||
|
||||
vtkm::cont::PartitionedDataSet Execute() const;
|
||||
VTKM_CONT VTKM_DEPRECATED(2.0, "Use Set* methods to set parameters.")
|
||||
Amr(vtkm::IdComponent dimension,
|
||||
vtkm::IdComponent cellsPerDimension = 6,
|
||||
vtkm::IdComponent numberOfLevels = 4);
|
||||
|
||||
VTKM_CONT ~Amr() = default;
|
||||
|
||||
VTKM_CONT void SetDimension(vtkm::IdComponent dimension) { this->Dimension = dimension; }
|
||||
VTKM_CONT vtkm::IdComponent GetDimension() const { return this->Dimension; }
|
||||
|
||||
VTKM_CONT void SetCellsPerDimension(vtkm::IdComponent cellsPerDimension)
|
||||
{
|
||||
this->CellsPerDimension = cellsPerDimension;
|
||||
}
|
||||
VTKM_CONT vtkm::IdComponent GetCellsPerDimension() const { return this->CellsPerDimension; }
|
||||
|
||||
VTKM_CONT void SetNumberOfLevels(vtkm::IdComponent numberOfLevels)
|
||||
{
|
||||
this->NumberOfLevels = numberOfLevels;
|
||||
}
|
||||
VTKM_CONT vtkm::IdComponent GetNumberOfLevels() const { return this->NumberOfLevels; }
|
||||
|
||||
VTKM_CONT vtkm::cont::PartitionedDataSet Execute() const;
|
||||
|
||||
private:
|
||||
template <vtkm::IdComponent Dim>
|
||||
vtkm::cont::DataSet GenerateDataSet(unsigned int level, unsigned int amrIndex) const;
|
||||
|
||||
vtkm::IdComponent Dimension;
|
||||
vtkm::IdComponent CellsPerDimension;
|
||||
vtkm::IdComponent NumberOfLevels;
|
||||
vtkm::IdComponent Dimension = 2;
|
||||
vtkm::IdComponent CellsPerDimension = 6;
|
||||
vtkm::IdComponent NumberOfLevels = 4;
|
||||
};
|
||||
} //namespace source
|
||||
} //namespace vtkm
|
||||
|
@ -10,13 +10,10 @@
|
||||
#include <vtkm/source/Oscillator.h>
|
||||
#include <vtkm/worklet/WorkletMapField.h>
|
||||
|
||||
namespace vtkm
|
||||
namespace
|
||||
{
|
||||
namespace source
|
||||
{
|
||||
namespace internal
|
||||
{
|
||||
struct Oscillator
|
||||
|
||||
struct Oscillation
|
||||
{
|
||||
vtkm::Vec3f Center;
|
||||
vtkm::FloatDefault Radius;
|
||||
@ -24,7 +21,7 @@ struct Oscillator
|
||||
vtkm::FloatDefault Zeta;
|
||||
};
|
||||
|
||||
class OscillatorSource : public vtkm::worklet::WorkletMapField
|
||||
class OscillatorWorklet : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn, FieldOut);
|
||||
@ -40,7 +37,7 @@ public:
|
||||
{
|
||||
if (this->PeriodicOscillators.GetNumberOfComponents() < MAX_OSCILLATORS)
|
||||
{
|
||||
this->PeriodicOscillators.Append(Oscillator{ { x, y, z }, radius, omega, zeta });
|
||||
this->PeriodicOscillators.Append(Oscillation{ { x, y, z }, radius, omega, zeta });
|
||||
}
|
||||
}
|
||||
|
||||
@ -54,7 +51,7 @@ public:
|
||||
{
|
||||
if (this->DampedOscillators.GetNumberOfComponents() < MAX_OSCILLATORS)
|
||||
{
|
||||
this->DampedOscillators.Append(Oscillator{ { x, y, z }, radius, omega, zeta });
|
||||
this->DampedOscillators.Append(Oscillation{ { x, y, z }, radius, omega, zeta });
|
||||
}
|
||||
}
|
||||
|
||||
@ -68,7 +65,7 @@ public:
|
||||
{
|
||||
if (this->DecayingOscillators.GetNumberOfComponents() < MAX_OSCILLATORS)
|
||||
{
|
||||
this->DecayingOscillators.Append(Oscillator{ { x, y, z }, radius, omega, zeta });
|
||||
this->DecayingOscillators.Append(Oscillation{ { x, y, z }, radius, omega, zeta });
|
||||
}
|
||||
}
|
||||
|
||||
@ -80,7 +77,7 @@ public:
|
||||
{
|
||||
vtkm::UInt8 oIdx;
|
||||
vtkm::FloatDefault t0, t, result = 0;
|
||||
const internal::Oscillator* oscillator;
|
||||
const Oscillation* oscillator;
|
||||
|
||||
t0 = 0.0;
|
||||
t = vtkm::FloatDefault(this->Time * 2 * 3.14159265358979323846);
|
||||
@ -136,27 +133,64 @@ public:
|
||||
|
||||
private:
|
||||
static constexpr vtkm::IdComponent MAX_OSCILLATORS = 10;
|
||||
vtkm::VecVariable<internal::Oscillator, MAX_OSCILLATORS> PeriodicOscillators;
|
||||
vtkm::VecVariable<internal::Oscillator, MAX_OSCILLATORS> DampedOscillators;
|
||||
vtkm::VecVariable<internal::Oscillator, MAX_OSCILLATORS> DecayingOscillators;
|
||||
vtkm::VecVariable<Oscillation, MAX_OSCILLATORS> PeriodicOscillators;
|
||||
vtkm::VecVariable<Oscillation, MAX_OSCILLATORS> DampedOscillators;
|
||||
vtkm::VecVariable<Oscillation, MAX_OSCILLATORS> DecayingOscillators;
|
||||
vtkm::FloatDefault Time{};
|
||||
}; // OscillatorSource
|
||||
}; // OscillatorWorklet
|
||||
|
||||
} // internal
|
||||
} // anonymous namespace
|
||||
|
||||
namespace vtkm
|
||||
{
|
||||
namespace source
|
||||
{
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
struct Oscillator::InternalStruct
|
||||
{
|
||||
vtkm::Id3 PointDimensions = { 3, 3, 3 };
|
||||
OscillatorWorklet Worklet;
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
Oscillator::Oscillator()
|
||||
: Internals(new InternalStruct)
|
||||
{
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
Oscillator::Oscillator(vtkm::Id3 dims)
|
||||
: Dims(dims)
|
||||
, Worklet(std::make_unique<internal::OscillatorSource>())
|
||||
: Internals(new InternalStruct)
|
||||
{
|
||||
this->SetCellDimensions(dims);
|
||||
}
|
||||
|
||||
Oscillator::~Oscillator() = default;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
void Oscillator::SetPointDimensions(vtkm::Id3 pointDimensions)
|
||||
{
|
||||
this->Internals->PointDimensions = pointDimensions;
|
||||
}
|
||||
vtkm::Id3 Oscillator::GetPointDimensions() const
|
||||
{
|
||||
return this->Internals->PointDimensions;
|
||||
}
|
||||
|
||||
void Oscillator::SetCellDimensions(vtkm::Id3 cellDimensions)
|
||||
{
|
||||
this->SetPointDimensions(cellDimensions + vtkm::Id3(1));
|
||||
}
|
||||
vtkm::Id3 Oscillator::GetCellDimensions() const
|
||||
{
|
||||
return this->GetPointDimensions() - vtkm::Id3(1);
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
void Oscillator::SetTime(vtkm::FloatDefault time)
|
||||
{
|
||||
this->Worklet->SetTime(time);
|
||||
this->Internals->Worklet.SetTime(time);
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
@ -167,7 +201,7 @@ void Oscillator::AddPeriodic(vtkm::FloatDefault x,
|
||||
vtkm::FloatDefault omega,
|
||||
vtkm::FloatDefault zeta)
|
||||
{
|
||||
this->Worklet->AddPeriodic(x, y, z, radius, omega, zeta);
|
||||
this->Internals->Worklet.AddPeriodic(x, y, z, radius, omega, zeta);
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
@ -178,7 +212,7 @@ void Oscillator::AddDamped(vtkm::FloatDefault x,
|
||||
vtkm::FloatDefault omega,
|
||||
vtkm::FloatDefault zeta)
|
||||
{
|
||||
this->Worklet->AddDamped(x, y, z, radius, omega, zeta);
|
||||
this->Internals->Worklet.AddDamped(x, y, z, radius, omega, zeta);
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
@ -189,7 +223,7 @@ void Oscillator::AddDecaying(vtkm::FloatDefault x,
|
||||
vtkm::FloatDefault omega,
|
||||
vtkm::FloatDefault zeta)
|
||||
{
|
||||
this->Worklet->AddDecaying(x, y, z, radius, omega, zeta);
|
||||
this->Internals->Worklet.AddDecaying(x, y, z, radius, omega, zeta);
|
||||
}
|
||||
|
||||
|
||||
@ -200,22 +234,23 @@ vtkm::cont::DataSet Oscillator::DoExecute() const
|
||||
|
||||
vtkm::cont::DataSet dataSet;
|
||||
|
||||
const vtkm::Id3 pdims{ this->Dims + vtkm::Id3{ 1, 1, 1 } };
|
||||
vtkm::cont::CellSetStructured<3> cellSet;
|
||||
cellSet.SetPointDimensions(pdims);
|
||||
vtkm::Id3 pointDims = this->GetPointDimensions();
|
||||
cellSet.SetPointDimensions(pointDims);
|
||||
dataSet.SetCellSet(cellSet);
|
||||
|
||||
vtkm::Id3 cellDims = this->GetCellDimensions();
|
||||
const vtkm::Vec3f origin(0.0f, 0.0f, 0.0f);
|
||||
const vtkm::Vec3f spacing(1.0f / static_cast<vtkm::FloatDefault>(this->Dims[0]),
|
||||
1.0f / static_cast<vtkm::FloatDefault>(this->Dims[1]),
|
||||
1.0f / static_cast<vtkm::FloatDefault>(this->Dims[2]));
|
||||
const vtkm::Vec3f spacing(1.0f / static_cast<vtkm::FloatDefault>(cellDims[0]),
|
||||
1.0f / static_cast<vtkm::FloatDefault>(cellDims[1]),
|
||||
1.0f / static_cast<vtkm::FloatDefault>(cellDims[2]));
|
||||
|
||||
vtkm::cont::ArrayHandleUniformPointCoordinates coordinates(pdims, origin, spacing);
|
||||
vtkm::cont::ArrayHandleUniformPointCoordinates coordinates(pointDims, origin, spacing);
|
||||
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates));
|
||||
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::FloatDefault> outArray;
|
||||
this->Invoke(*(this->Worklet), coordinates, outArray);
|
||||
this->Invoke(this->Internals->Worklet, coordinates, outArray);
|
||||
dataSet.AddField(vtkm::cont::make_FieldPoint("oscillating", outArray));
|
||||
|
||||
return dataSet;
|
||||
|
@ -16,10 +16,6 @@ namespace vtkm
|
||||
{
|
||||
namespace source
|
||||
{
|
||||
namespace internal
|
||||
{
|
||||
class OscillatorSource;
|
||||
}
|
||||
|
||||
/**\brief An analytical, time-varying uniform dataset with a point based array
|
||||
*
|
||||
@ -32,15 +28,22 @@ class OscillatorSource;
|
||||
class VTKM_SOURCE_EXPORT Oscillator final : public vtkm::source::Source
|
||||
{
|
||||
public:
|
||||
VTKM_CONT Oscillator();
|
||||
|
||||
///Construct a Oscillator with Cell Dimensions
|
||||
VTKM_CONT
|
||||
explicit Oscillator(vtkm::Id3 dims);
|
||||
VTKM_CONT VTKM_DEPRECATED(
|
||||
2.0,
|
||||
"Use SetCellDimensions or SetPointDimensions.") explicit Oscillator(vtkm::Id3 dims);
|
||||
|
||||
// We can not declare default destructor here since compiler does not know how
|
||||
// to create one for the Worklet at this point yet. However, the implementation
|
||||
// in Oscillator.cxx does have ~Oscillator() = default;
|
||||
VTKM_CONT
|
||||
~Oscillator() override;
|
||||
VTKM_CONT ~Oscillator() override;
|
||||
|
||||
VTKM_CONT void SetPointDimensions(vtkm::Id3 pointDimensions);
|
||||
VTKM_CONT vtkm::Id3 GetPointDimensions() const;
|
||||
VTKM_CONT void SetCellDimensions(vtkm::Id3 pointDimensions);
|
||||
VTKM_CONT vtkm::Id3 GetCellDimensions() const;
|
||||
|
||||
VTKM_CONT
|
||||
void SetTime(vtkm::FloatDefault time);
|
||||
@ -72,8 +75,8 @@ public:
|
||||
private:
|
||||
VTKM_CONT vtkm::cont::DataSet DoExecute() const override;
|
||||
|
||||
vtkm::Id3 Dims;
|
||||
std::unique_ptr<internal::OscillatorSource> Worklet;
|
||||
struct InternalStruct;
|
||||
std::unique_ptr<InternalStruct> Internals;
|
||||
};
|
||||
}
|
||||
}
|
||||
|
@ -179,26 +179,36 @@ namespace vtkm
|
||||
namespace source
|
||||
{
|
||||
|
||||
PerlinNoise::PerlinNoise(vtkm::Id3 dims)
|
||||
: PerlinNoise(dims, vtkm::Vec3f(0), static_cast<vtkm::IdComponent>(time(NULL)))
|
||||
PerlinNoise::PerlinNoise()
|
||||
: Seed(static_cast<vtkm::IdComponent>(time(NULL)))
|
||||
{
|
||||
}
|
||||
|
||||
PerlinNoise::PerlinNoise(vtkm::Id3 dims)
|
||||
: PerlinNoise()
|
||||
{
|
||||
this->SetCellDimensions(dims);
|
||||
}
|
||||
|
||||
PerlinNoise::PerlinNoise(vtkm::Id3 dims, vtkm::IdComponent seed)
|
||||
: PerlinNoise(dims, vtkm::Vec3f(0), seed)
|
||||
: PerlinNoise()
|
||||
{
|
||||
this->SetCellDimensions(dims);
|
||||
this->SetSeed(seed);
|
||||
}
|
||||
|
||||
PerlinNoise::PerlinNoise(vtkm::Id3 dims, vtkm::Vec3f origin)
|
||||
: PerlinNoise(dims, origin, static_cast<vtkm::IdComponent>(time(NULL)))
|
||||
: PerlinNoise()
|
||||
{
|
||||
this->SetCellDimensions(dims);
|
||||
this->SetOrigin(origin);
|
||||
}
|
||||
|
||||
PerlinNoise::PerlinNoise(vtkm::Id3 dims, vtkm::Vec3f origin, vtkm::IdComponent seed)
|
||||
: Dims(dims)
|
||||
, Origin(origin)
|
||||
, Seed(seed)
|
||||
{
|
||||
this->SetCellDimensions(dims);
|
||||
this->SetOrigin(origin);
|
||||
this->SetSeed(seed);
|
||||
}
|
||||
|
||||
vtkm::cont::DataSet PerlinNoise::DoExecute() const
|
||||
@ -206,20 +216,19 @@ vtkm::cont::DataSet PerlinNoise::DoExecute() const
|
||||
VTKM_LOG_SCOPE_FUNCTION(vtkm::cont::LogLevel::Perf);
|
||||
|
||||
vtkm::cont::DataSet dataSet;
|
||||
const vtkm::Id3 pdims{ this->Dims + vtkm::Id3{ 1, 1, 1 } };
|
||||
const vtkm::Vec3f spacing(1.0f / static_cast<vtkm::FloatDefault>(this->Dims[0]),
|
||||
1.0f / static_cast<vtkm::FloatDefault>(this->Dims[1]),
|
||||
1.0f / static_cast<vtkm::FloatDefault>(this->Dims[2]));
|
||||
const vtkm::Vec3f cellDims = this->GetCellDimensions();
|
||||
const vtkm::Vec3f spacing(1.0f / cellDims[0], 1.0f / cellDims[1], 1.0f / cellDims[2]);
|
||||
|
||||
|
||||
vtkm::cont::CellSetStructured<3> cellSet;
|
||||
cellSet.SetPointDimensions(pdims);
|
||||
cellSet.SetPointDimensions(this->PointDimensions);
|
||||
dataSet.SetCellSet(cellSet);
|
||||
vtkm::cont::ArrayHandleUniformPointCoordinates coordinates(pdims, this->Origin, spacing);
|
||||
vtkm::cont::ArrayHandleUniformPointCoordinates coordinates(
|
||||
this->PointDimensions, this->Origin, spacing);
|
||||
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates));
|
||||
|
||||
auto tableSize = static_cast<vtkm::IdComponent>(
|
||||
vtkm::Max(this->Dims[0], vtkm::Max(this->Dims[1], this->Dims[2])));
|
||||
auto tableSize =
|
||||
static_cast<vtkm::IdComponent>(vtkm::Max(cellDims[0], vtkm::Max(cellDims[1], cellDims[2])));
|
||||
PerlinNoiseField noiseGenerator(tableSize, this->Seed);
|
||||
noiseGenerator.SetOutputFieldName("perlinnoise");
|
||||
dataSet = noiseGenerator.Execute(dataSet);
|
||||
|
@ -29,21 +29,40 @@ namespace source
|
||||
class VTKM_SOURCE_EXPORT PerlinNoise final : public vtkm::source::Source
|
||||
{
|
||||
public:
|
||||
///Construct a PerlinNoise with Cell Dimensions
|
||||
VTKM_CONT PerlinNoise();
|
||||
VTKM_CONT ~PerlinNoise() = default;
|
||||
|
||||
VTKM_CONT PerlinNoise(const PerlinNoise&) = default;
|
||||
VTKM_CONT PerlinNoise(PerlinNoise&&) = default;
|
||||
VTKM_CONT PerlinNoise& operator=(const PerlinNoise&) = default;
|
||||
VTKM_CONT PerlinNoise& operator=(PerlinNoise&&) = default;
|
||||
|
||||
VTKM_DEPRECATED(2.0, "Use SetCellDimensions or SetPointDimensions.")
|
||||
VTKM_CONT PerlinNoise(vtkm::Id3 dims);
|
||||
VTKM_DEPRECATED(2.0, "Use Set*Dimensions and SetSeed.")
|
||||
VTKM_CONT PerlinNoise(vtkm::Id3 dims, vtkm::IdComponent seed);
|
||||
VTKM_DEPRECATED(2.0, "Use Set*Dimensions and SetOrigin.")
|
||||
VTKM_CONT PerlinNoise(vtkm::Id3 dims, vtkm::Vec3f origin);
|
||||
VTKM_DEPRECATED(2.0, "Use Set*Dimensions, SetOrigin, and SetSeed.")
|
||||
VTKM_CONT PerlinNoise(vtkm::Id3 dims, vtkm::Vec3f origin, vtkm::IdComponent seed);
|
||||
|
||||
vtkm::IdComponent GetSeed() const { return this->Seed; }
|
||||
VTKM_CONT vtkm::Id3 GetPointDimensions() const { return this->PointDimensions; }
|
||||
VTKM_CONT void SetPointDimensions(vtkm::Id3 dims) { this->PointDimensions = dims; }
|
||||
|
||||
void SetSeed(vtkm::IdComponent seed) { this->Seed = seed; }
|
||||
VTKM_CONT vtkm::Id3 GetCellDimensions() const { return this->PointDimensions - vtkm::Id3(1); }
|
||||
VTKM_CONT void SetCellDimensions(vtkm::Id3 dims) { this->PointDimensions = dims + vtkm::Id3(1); }
|
||||
|
||||
VTKM_CONT vtkm::Vec3f GetOrigin() const { return this->Origin; }
|
||||
VTKM_CONT void SetOrigin(const vtkm::Vec3f& origin) { this->Origin = origin; }
|
||||
|
||||
VTKM_CONT vtkm::IdComponent GetSeed() const { return this->Seed; }
|
||||
VTKM_CONT void SetSeed(vtkm::IdComponent seed) { this->Seed = seed; }
|
||||
|
||||
private:
|
||||
vtkm::cont::DataSet DoExecute() const override;
|
||||
|
||||
vtkm::Id3 Dims;
|
||||
vtkm::Vec3f Origin;
|
||||
vtkm::Id3 PointDimensions = { 16, 16, 16 };
|
||||
vtkm::Vec3f Origin = { 0, 0, 0 };
|
||||
vtkm::IdComponent Seed;
|
||||
};
|
||||
} //namespace source
|
||||
|
@ -66,23 +66,25 @@ vtkm::cont::DataSet Tangle::DoExecute() const
|
||||
|
||||
vtkm::cont::DataSet dataSet;
|
||||
|
||||
const vtkm::Id3 pdims{ this->Dims + vtkm::Id3{ 1, 1, 1 } };
|
||||
const vtkm::Vec3f mins = { -1.0f, -1.0f, -1.0f };
|
||||
const vtkm::Vec3f maxs = { 1.0f, 1.0f, 1.0f };
|
||||
|
||||
vtkm::cont::CellSetStructured<3> cellSet;
|
||||
cellSet.SetPointDimensions(pdims);
|
||||
cellSet.SetPointDimensions(this->PointDimensions);
|
||||
dataSet.SetCellSet(cellSet);
|
||||
|
||||
vtkm::Id3 cellDims = this->GetCellDimensions();
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Float32> pointFieldArray;
|
||||
this->Invoke(tangle::TangleField{ this->Dims, mins, maxs }, cellSet, pointFieldArray);
|
||||
this->Invoke(tangle::TangleField{ cellDims, mins, maxs }, cellSet, pointFieldArray);
|
||||
|
||||
const vtkm::Vec3f origin(0.0f, 0.0f, 0.0f);
|
||||
const vtkm::Vec3f spacing(1.0f / static_cast<vtkm::FloatDefault>(this->Dims[0]),
|
||||
1.0f / static_cast<vtkm::FloatDefault>(this->Dims[1]),
|
||||
1.0f / static_cast<vtkm::FloatDefault>(this->Dims[2]));
|
||||
const vtkm::Vec3f spacing(1.0f / static_cast<vtkm::FloatDefault>(cellDims[0]),
|
||||
1.0f / static_cast<vtkm::FloatDefault>(cellDims[1]),
|
||||
1.0f / static_cast<vtkm::FloatDefault>(cellDims[2]));
|
||||
|
||||
vtkm::cont::ArrayHandleUniformPointCoordinates coordinates(pdims, origin, spacing);
|
||||
vtkm::cont::ArrayHandleUniformPointCoordinates coordinates(
|
||||
this->PointDimensions, origin, spacing);
|
||||
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates));
|
||||
dataSet.AddField(vtkm::cont::make_FieldPoint("tangle", pointFieldArray));
|
||||
|
||||
|
@ -35,17 +35,25 @@ namespace source
|
||||
class VTKM_SOURCE_EXPORT Tangle final : public vtkm::source::Source
|
||||
{
|
||||
public:
|
||||
///Construct a Tangle with Cell Dimensions
|
||||
VTKM_CONT
|
||||
Tangle(vtkm::Id3 dims)
|
||||
: Dims(dims)
|
||||
VTKM_CONT Tangle() = default;
|
||||
VTKM_CONT ~Tangle() = default;
|
||||
|
||||
VTKM_DEPRECATED(2.0, "Use SetCellDimensions or SetPointDimensions.")
|
||||
VTKM_CONT Tangle(vtkm::Id3 dims)
|
||||
: PointDimensions(dims + vtkm::Id3(1))
|
||||
{
|
||||
}
|
||||
|
||||
VTKM_CONT vtkm::Id3 GetPointDimensions() const { return this->PointDimensions; }
|
||||
VTKM_CONT void SetPointDimensions(vtkm::Id3 dims) { this->PointDimensions = dims; }
|
||||
|
||||
VTKM_CONT vtkm::Id3 GetCellDimensions() const { return this->PointDimensions - vtkm::Id3(1); }
|
||||
VTKM_CONT void SetCellDimensions(vtkm::Id3 dims) { this->PointDimensions = dims + vtkm::Id3(1); }
|
||||
|
||||
private:
|
||||
vtkm::cont::DataSet DoExecute() const override;
|
||||
|
||||
vtkm::Id3 Dims;
|
||||
vtkm::Id3 PointDimensions = { 16, 16, 16 };
|
||||
};
|
||||
} //namespace source
|
||||
} //namespace vtkm
|
||||
|
@ -97,15 +97,8 @@ struct WaveletField : public vtkm::worklet::WorkletVisitPointsWithCells
|
||||
} // namespace wavelet
|
||||
|
||||
Wavelet::Wavelet(vtkm::Id3 minExtent, vtkm::Id3 maxExtent)
|
||||
: Center{ minExtent - ((minExtent - maxExtent) / 2) }
|
||||
, Origin{ minExtent }
|
||||
, Spacing{ 1. }
|
||||
, Frequency{ 60., 30., 40. }
|
||||
, Magnitude{ 10., 18., 5. }
|
||||
, MinimumExtent{ minExtent }
|
||||
, MaximumExtent{ maxExtent }
|
||||
, MaximumValue{ 255. }
|
||||
, StandardDeviation{ 0.5 }
|
||||
: MinimumExtent(minExtent)
|
||||
, MaximumExtent(maxExtent)
|
||||
{
|
||||
}
|
||||
|
||||
@ -139,7 +132,7 @@ vtkm::cont::DataSet Wavelet::DoExecute() const
|
||||
|
||||
// Create points:
|
||||
const vtkm::Id3 dims{ this->MaximumExtent - this->MinimumExtent + vtkm::Id3{ 1 } };
|
||||
vtkm::cont::CoordinateSystem coords{ "coordinates", dims, this->Origin, this->Spacing };
|
||||
vtkm::cont::CoordinateSystem coords{ "coordinates", dims, this->GetOrigin(), this->Spacing };
|
||||
|
||||
// Compile the dataset:
|
||||
if (this->MaximumExtent[2] - this->MinimumExtent[2] < vtkm::Epsilon<vtkm::FloatDefault>())
|
||||
|
@ -13,6 +13,8 @@
|
||||
|
||||
#include <vtkm/source/Source.h>
|
||||
|
||||
#include <vtkm/Math.h>
|
||||
|
||||
namespace vtkm
|
||||
{
|
||||
namespace source
|
||||
@ -59,28 +61,54 @@ namespace source
|
||||
class VTKM_SOURCE_EXPORT Wavelet final : public vtkm::source::Source
|
||||
{
|
||||
public:
|
||||
VTKM_CONT
|
||||
Wavelet(vtkm::Id3 minExtent = { -10 }, vtkm::Id3 maxExtent = { 10 });
|
||||
VTKM_CONT Wavelet() = default;
|
||||
VTKM_CONT ~Wavelet() = default;
|
||||
|
||||
VTKM_CONT void SetCenter(const vtkm::Vec<FloatDefault, 3>& center) { this->Center = center; }
|
||||
VTKM_DEPRECATED(2.0, "Use SetExtent.")
|
||||
VTKM_CONT Wavelet(vtkm::Id3 minExtent, vtkm::Id3 maxExtent = { 10 });
|
||||
|
||||
VTKM_CONT void SetOrigin(const vtkm::Vec<FloatDefault, 3>& origin) { this->Origin = origin; }
|
||||
///@{
|
||||
/// \brief Specifies the center of the wavelet function.
|
||||
///
|
||||
/// Note that the center of the function can be anywhere in space including
|
||||
/// outside the domain of the data created (as specified by the origin,
|
||||
/// spacing and extent).
|
||||
VTKM_CONT void SetCenter(const vtkm::Vec3f& center) { this->Center = center; }
|
||||
VTKM_CONT vtkm::Vec3f GetCenter() const { return this->Center; }
|
||||
///@}
|
||||
|
||||
VTKM_CONT void SetSpacing(const vtkm::Vec<FloatDefault, 3>& spacing) { this->Spacing = spacing; }
|
||||
|
||||
VTKM_CONT void SetFrequency(const vtkm::Vec<FloatDefault, 3>& frequency)
|
||||
///@{
|
||||
/// \brief Specifies the origin (lower left corner) of the dataset created.
|
||||
///
|
||||
/// If the origin is not specified, it will be placed such that extent
|
||||
/// index (0, 0, 0) is at the coordinate system origin.
|
||||
VTKM_CONT void SetOrigin(const vtkm::Vec3f& origin) { this->Origin = origin; }
|
||||
VTKM_CONT vtkm::Vec3f GetOrigin() const
|
||||
{
|
||||
this->Frequency = frequency;
|
||||
if (!vtkm::IsNan(this->Origin[0]))
|
||||
{
|
||||
return this->Origin;
|
||||
}
|
||||
else
|
||||
{
|
||||
return this->MinimumExtent * this->Spacing;
|
||||
}
|
||||
}
|
||||
|
||||
VTKM_CONT void SetMagnitude(const vtkm::Vec<FloatDefault, 3>& magnitude)
|
||||
{
|
||||
this->Magnitude = magnitude;
|
||||
}
|
||||
VTKM_CONT void SetSpacing(const vtkm::Vec3f& spacing) { this->Spacing = spacing; }
|
||||
VTKM_CONT vtkm::Vec3f GetSpacing() const { return this->Spacing; }
|
||||
|
||||
VTKM_CONT void SetFrequency(const vtkm::Vec3f& frequency) { this->Frequency = frequency; }
|
||||
VTKM_CONT vtkm::Vec3f GetFrequency() const { return this->Frequency; }
|
||||
|
||||
VTKM_CONT void SetMagnitude(const vtkm::Vec3f& magnitude) { this->Magnitude = magnitude; }
|
||||
VTKM_CONT vtkm::Vec3f GetMagnitude() const { return this->Magnitude; }
|
||||
|
||||
VTKM_CONT void SetMinimumExtent(const vtkm::Id3& minExtent) { this->MinimumExtent = minExtent; }
|
||||
VTKM_CONT vtkm::Id3 GetMinimumExtent() const { return this->MinimumExtent; }
|
||||
|
||||
VTKM_CONT void SetMaximumExtent(const vtkm::Id3& maxExtent) { this->MaximumExtent = maxExtent; }
|
||||
VTKM_CONT vtkm::Id3 GetMaximumExtent() const { return this->MaximumExtent; }
|
||||
|
||||
VTKM_CONT void SetExtent(const vtkm::Id3& minExtent, const vtkm::Id3& maxExtent)
|
||||
{
|
||||
@ -89,11 +117,13 @@ public:
|
||||
}
|
||||
|
||||
VTKM_CONT void SetMaximumValue(const vtkm::FloatDefault& maxVal) { this->MaximumValue = maxVal; }
|
||||
VTKM_CONT vtkm::FloatDefault GetMaximumValue() const { return this->MaximumValue; }
|
||||
|
||||
VTKM_CONT void SetStandardDeviation(const vtkm::FloatDefault& stdev)
|
||||
{
|
||||
this->StandardDeviation = stdev;
|
||||
}
|
||||
VTKM_CONT vtkm::FloatDefault GetStandardDeviation() const { return this->StandardDeviation; }
|
||||
|
||||
private:
|
||||
vtkm::cont::DataSet DoExecute() const override;
|
||||
@ -105,15 +135,15 @@ private:
|
||||
template <vtkm::IdComponent Dim>
|
||||
vtkm::cont::DataSet GenerateDataSet(vtkm::cont::CoordinateSystem coords) const;
|
||||
|
||||
vtkm::Vec3f Center;
|
||||
vtkm::Vec3f Origin;
|
||||
vtkm::Vec3f Spacing;
|
||||
vtkm::Vec3f Frequency;
|
||||
vtkm::Vec3f Magnitude;
|
||||
vtkm::Id3 MinimumExtent;
|
||||
vtkm::Id3 MaximumExtent;
|
||||
vtkm::FloatDefault MaximumValue;
|
||||
vtkm::FloatDefault StandardDeviation;
|
||||
vtkm::Vec3f Center = { 0, 0, 0 };
|
||||
vtkm::Vec3f Origin = { vtkm::Nan<vtkm::FloatDefault>() };
|
||||
vtkm::Vec3f Spacing = { 1, 1, 1 };
|
||||
vtkm::Vec3f Frequency = { 60.0f, 30.0f, 40.0f };
|
||||
vtkm::Vec3f Magnitude = { 10.0f, 18.0f, 5.0f };
|
||||
vtkm::Id3 MinimumExtent = { -10, -10, -10 };
|
||||
vtkm::Id3 MaximumExtent = { 10, 10, 10 };
|
||||
vtkm::FloatDefault MaximumValue = 255.0f;
|
||||
vtkm::FloatDefault StandardDeviation = 0.5f;
|
||||
};
|
||||
} //namespace source
|
||||
} //namespace vtkm
|
||||
|
@ -24,7 +24,9 @@ namespace
|
||||
|
||||
void TestPerlinNoise()
|
||||
{
|
||||
vtkm::source::PerlinNoise noiseSource(vtkm::Id3(16), 77698);
|
||||
vtkm::source::PerlinNoise noiseSource;
|
||||
noiseSource.SetCellDimensions(vtkm::Id3(16));
|
||||
noiseSource.SetSeed(77698);
|
||||
vtkm::cont::DataSet noise = noiseSource.Execute();
|
||||
|
||||
noise.PrintSummary(std::cout);
|
||||
|
@ -18,7 +18,8 @@ void OscillatorSourceTest()
|
||||
vtkm::cont::Timer timer;
|
||||
timer.Start();
|
||||
|
||||
vtkm::source::Oscillator source(vtkm::Id3{ 20, 20, 20 });
|
||||
vtkm::source::Oscillator source;
|
||||
source.SetPointDimensions({ 21, 21, 21 });
|
||||
source.SetTime(0.5);
|
||||
source.AddDamped(0.25f, 0.25f, 0.25f, 0.5f, 0.1f, 0.2f);
|
||||
source.AddDecaying(0.5f, 0.5f, 0.5f, 0.35f, 0.2f, 0.1f);
|
||||
|
@ -18,7 +18,8 @@ void TangleSourceTest()
|
||||
vtkm::cont::Timer timer;
|
||||
timer.Start();
|
||||
|
||||
vtkm::source::Tangle source(vtkm::Id3{ 20, 20, 20 });
|
||||
vtkm::source::Tangle source;
|
||||
source.SetCellDimensions({ 20, 20, 20 });
|
||||
vtkm::cont::DataSet ds = source.Execute();
|
||||
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user