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

Merge topic 'source-point-dims'

Browse Source 
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:
Kenneth Moreland 2022-12-04 14:27:13 +00:00 committed by Kitware Robot
commit 22e2e5ff32
27 changed files with 304 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
benchmarking/BenchmarkInSitu.cxx
View File

@ -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();
}

5
benchmarking/BenchmarkRayTracing.cxx
View File

@ -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
View 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.

3
examples/demo/Demo.cxx
View File

@ -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";

5
vtkm/cont/testing/UnitTestCellLocatorPartitioned.cxx
View File

@ -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

4
vtkm/filter/connected_components/testing/UnitTestCellSetConnectivityFilter.cxx
View File

@ -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;

4
vtkm/filter/contour/testing/RenderTestContourFilter.cxx
View File

@ -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;

12
vtkm/filter/contour/testing/RenderTestSliceFilter.cxx
View File

@ -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);

4
vtkm/filter/contour/testing/UnitTestContourFilter.cxx
View File

@ -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);

4
vtkm/filter/density_estimate/testing/UnitTestEntropyFilter.cxx
View File

@ -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;

4
vtkm/filter/field_transform/testing/UnitTestGenerateIds.cxx
View File

@ -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);

3
vtkm/filter/geometry_refinement/testing/UnitTestSplitSharpEdgesFilter.cxx
View File

@ -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 });

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

@ -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);

3
vtkm/filter/testing/UnitTestMultiBlockFilter.cxx
View File

@ -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());
}

5
vtkm/source/Amr.cxx
View File

@ -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();

37
vtkm/source/Amr.h
View File

@ -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

93
vtkm/source/Oscillator.cxx
View File

@ -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;

23
vtkm/source/Oscillator.h
View File

@ -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;
};
}
}

53
vtkm/source/PerlinNoise.cxx
View File

@ -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);

34
vtkm/source/PerlinNoise.h
View File

@ -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

16
vtkm/source/Tangle.cxx
View File

@ -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));

18
vtkm/source/Tangle.h
View File

@ -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

13
vtkm/source/Wavelet.cxx
View File

@ -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>())

72
vtkm/source/Wavelet.h
View File

@ -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

4
vtkm/source/testing/RenderTestPerlinNoise.cxx
View File

@ -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);

3
vtkm/source/testing/UnitTestOscillatorSource.cxx
View File

@ -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);

3
vtkm/source/testing/UnitTestTangleSource.cxx
View File

@ -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();