mirror of
https://gitlab.kitware.com/vtk/vtk-m
synced 2024-10-05 01:49:02 +00:00
Merge topic 'source-point-dims'
aa7b83bb2 Handle random seed generation better for PerlinNoise 84bc72312 Make source parameters more clear Acked-by: Kitware Robot <kwrobot@kitware.com> Acked-by: Li-Ta Lo <ollie@lanl.gov> Merge-request: !2933
This commit is contained in:
commit
22e2e5ff32
@ -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;
|
||||
};
|
||||
}
|
||||
}
|
||||
|
@ -149,7 +149,26 @@ private:
|
||||
VTKM_CONT void GeneratePermutations()
|
||||
{
|
||||
std::mt19937_64 rng;
|
||||
rng.seed(this->Seed);
|
||||
if (this->Seed != 0)
|
||||
{
|
||||
rng.seed(this->Seed);
|
||||
}
|
||||
else
|
||||
{
|
||||
// If a seed has not been chosen, create a unique seed here. It is done here instead
|
||||
// of the `PerlinNoise` source constructor for 2 reasons. First, `std::random_device`
|
||||
// can be slow. If the user wants to specify a seed, it makes no sense to spend
|
||||
// time generating a random seed only to overwrite it. Second, creating the seed
|
||||
// here allows subsequent runs of the `PerlinNoise` source to have different random
|
||||
// results if a seed is not specified.
|
||||
//
|
||||
// It is also worth noting that the current time is added to the random number.
|
||||
// This is because the spec for std::random_device allows it to be deterministic
|
||||
// if nondeterministic hardware is unavailable and the deterministic numbers can
|
||||
// be the same for every execution of the program. Adding the current time is
|
||||
// a fallback for that case.
|
||||
rng.seed(std::random_device{}() + time(NULL));
|
||||
}
|
||||
std::uniform_int_distribution<vtkm::IdComponent> distribution(0, this->TableSize - 1);
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> perms;
|
||||
@ -180,25 +199,30 @@ namespace source
|
||||
{
|
||||
|
||||
PerlinNoise::PerlinNoise(vtkm::Id3 dims)
|
||||
: PerlinNoise(dims, vtkm::Vec3f(0), static_cast<vtkm::IdComponent>(time(NULL)))
|
||||
: 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 +230,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,22 +29,44 @@ namespace source
|
||||
class VTKM_SOURCE_EXPORT PerlinNoise final : public vtkm::source::Source
|
||||
{
|
||||
public:
|
||||
///Construct a PerlinNoise with Cell Dimensions
|
||||
VTKM_CONT PerlinNoise() = default;
|
||||
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; }
|
||||
|
||||
/// \brief The seed used for the pseudorandom number generation of the noise.
|
||||
///
|
||||
/// If the seed is set to 0, then a new, unique seed is picked each time `Execute` is run.
|
||||
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::IdComponent Seed;
|
||||
vtkm::Id3 PointDimensions = { 16, 16, 16 };
|
||||
vtkm::Vec3f Origin = { 0, 0, 0 };
|
||||
vtkm::IdComponent Seed = 0;
|
||||
};
|
||||
} //namespace source
|
||||
} //namespace vtkm
|
||||
|
@ -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