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

benchmarking/BenchmarkInSitu.cxx

@@ -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),
+          noise.SetOrigin({ static_cast<vtkm::FloatDefault>(i),
-                                    static_cast<vtkm::FloatDefault>(j),
+                            static_cast<vtkm::FloatDefault>(j),
-                                    static_cast<vtkm::FloatDefault>(k) };
+                            static_cast<vtkm::FloatDefault>(k) });
-          const vtkm::source::PerlinNoise noise{ dims,
-                                                 origin,
-                                                 static_cast<vtkm::IdComponent>(cycle) };
           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();
   }
 

benchmarking/BenchmarkRayTracing.cxx

@@ -39,9 +39,8 @@ vtkm::cont::InitializeResult Config;
 
 void BenchRayTracing(::benchmark::State& state)
 {
-  const vtkm::Id3 dims(128, 128, 128);
+  vtkm::source::Tangle maker;
-
+  maker.SetPointDimensions({ 128, 128, 128 });
-  vtkm::source::Tangle maker(dims);
   vtkm::cont::DataSet dataset = maker.Execute();
   vtkm::cont::CoordinateSystem coords = dataset.GetCoordinateSystem();
 

docs/changelog/source-parameters.md

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

examples/demo/Demo.cxx

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

vtkm/cont/testing/UnitTestCellLocatorPartitioned.cxx

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

vtkm/filter/connected_components/testing/UnitTestCellSetConnectivityFilter.cxx

@@ -24,8 +24,8 @@ class TestCellSetConnectivity
 public:
   static void TestTangleIsosurface()
   {
-    vtkm::Id3 dims(4, 4, 4);
+    vtkm::source::Tangle tangle;
-    vtkm::source::Tangle tangle(dims);
+    tangle.SetCellDimensions({ 4, 4, 4 });
     vtkm::cont::DataSet dataSet = tangle.Execute();
 
     vtkm::filter::contour::Contour filter;

vtkm/filter/contour/testing/RenderTestContourFilter.cxx

@@ -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;
-  vtkm::source::Tangle tangle(dims);
+  tangle.SetCellDimensions({ 4, 4, 4 });
   vtkm::cont::DataSet dataSet = tangle.Execute();
 
   vtkm::filter::contour::Contour contour;

vtkm/filter/contour/testing/RenderTestSliceFilter.cxx

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

vtkm/filter/contour/testing/UnitTestContourFilter.cxx

@@ -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;
-    vtkm::source::Tangle tangle(dims);
+    tangle.SetCellDimensions({ 4, 4, 4 });
     vtkm::filter::field_transform::GenerateIds genIds;
     genIds.SetUseFloat(true);
     genIds.SetGeneratePointIds(false);

vtkm/filter/density_estimate/testing/UnitTestEntropyFilter.cxx

@@ -20,8 +20,8 @@ namespace
 void TestEntropy()
 {
   ///// make a data set /////
-  vtkm::Id3 dims(32, 32, 32);
+  vtkm::source::Tangle tangle;
-  vtkm::source::Tangle tangle(dims);
+  tangle.SetCellDimensions({ 32, 32, 32 });
   vtkm::cont::DataSet dataSet = tangle.Execute();
 
   vtkm::filter::density_estimate::Entropy entropyFilter;

vtkm/filter/field_transform/testing/UnitTestGenerateIds.cxx

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

vtkm/filter/geometry_refinement/testing/UnitTestSplitSharpEdgesFilter.cxx

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

vtkm/filter/multi_block/testing/RenderTestAmrArrays.cxx

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

vtkm/filter/testing/UnitTestMultiBlockFilter.cxx

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

vtkm/source/Amr.cxx

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

vtkm/source/Amr.h

@@ -58,22 +58,39 @@ namespace source
 class VTKM_SOURCE_EXPORT Amr
 {
 public:
-  VTKM_CONT
+  VTKM_CONT Amr() = default;
-  Amr(vtkm::IdComponent dimension = 2,
-      vtkm::IdComponent cellsPerDimension = 6,
-      vtkm::IdComponent numberOfLevels = 4);
-  VTKM_CONT
-  ~Amr();
 
-  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 Dimension = 2;
-  vtkm::IdComponent CellsPerDimension;
+  vtkm::IdComponent CellsPerDimension = 6;
-  vtkm::IdComponent NumberOfLevels;
+  vtkm::IdComponent NumberOfLevels = 4;
 };
 } //namespace source
 } //namespace vtkm

vtkm/source/Oscillator.cxx

@@ -10,13 +10,10 @@
 #include <vtkm/source/Oscillator.h>
 #include <vtkm/worklet/WorkletMapField.h>
 
-namespace vtkm
+namespace
 {
-namespace source
+
-{
+struct Oscillation
-namespace internal
-{
-struct Oscillator
 {
   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<Oscillation, MAX_OSCILLATORS> PeriodicOscillators;
-  vtkm::VecVariable<internal::Oscillator, MAX_OSCILLATORS> DampedOscillators;
+  vtkm::VecVariable<Oscillation, MAX_OSCILLATORS> DampedOscillators;
-  vtkm::VecVariable<internal::Oscillator, MAX_OSCILLATORS> DecayingOscillators;
+  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)
+  : Internals(new InternalStruct)
-  , Worklet(std::make_unique<internal::OscillatorSource>())
 {
+  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]),
+  const vtkm::Vec3f spacing(1.0f / static_cast<vtkm::FloatDefault>(cellDims[0]),
-                            1.0f / static_cast<vtkm::FloatDefault>(this->Dims[1]),
+                            1.0f / static_cast<vtkm::FloatDefault>(cellDims[1]),
-                            1.0f / static_cast<vtkm::FloatDefault>(this->Dims[2]));
+                            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;

vtkm/source/Oscillator.h

@@ -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
+  VTKM_CONT VTKM_DEPRECATED(
-  explicit Oscillator(vtkm::Id3 dims);
+    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
+  VTKM_CONT ~Oscillator() override;
-  ~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;
+  struct InternalStruct;
-  std::unique_ptr<internal::OscillatorSource> Worklet;
+  std::unique_ptr<InternalStruct> Internals;
 };
 }
 }

vtkm/source/PerlinNoise.cxx

@@ -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 cellDims = this->GetCellDimensions();
-  const vtkm::Vec3f spacing(1.0f / static_cast<vtkm::FloatDefault>(this->Dims[0]),
+  const vtkm::Vec3f spacing(1.0f / cellDims[0], 1.0f / cellDims[1], 1.0f / cellDims[2]);
-                            1.0f / static_cast<vtkm::FloatDefault>(this->Dims[1]),
-                            1.0f / static_cast<vtkm::FloatDefault>(this->Dims[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>(
+  auto tableSize =
-    vtkm::Max(this->Dims[0], vtkm::Max(this->Dims[1], this->Dims[2])));
+    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);

vtkm/source/PerlinNoise.h

@@ -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::Id3 PointDimensions = { 16, 16, 16 };
-  vtkm::Vec3f Origin;
+  vtkm::Vec3f Origin = { 0, 0, 0 };
-  vtkm::IdComponent Seed;
+  vtkm::IdComponent Seed = 0;
 };
 } //namespace source
 } //namespace vtkm

vtkm/source/Tangle.cxx

@@ -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]),
+  const vtkm::Vec3f spacing(1.0f / static_cast<vtkm::FloatDefault>(cellDims[0]),
-                            1.0f / static_cast<vtkm::FloatDefault>(this->Dims[1]),
+                            1.0f / static_cast<vtkm::FloatDefault>(cellDims[1]),
-                            1.0f / static_cast<vtkm::FloatDefault>(this->Dims[2]));
+                            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));
 

vtkm/source/Tangle.h

@@ -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() = default;
-  VTKM_CONT
+  VTKM_CONT ~Tangle() = default;
-  Tangle(vtkm::Id3 dims)
+
-    : Dims(dims)
+  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

vtkm/source/Wavelet.cxx

@@ -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) }
+  : MinimumExtent(minExtent)
-  , Origin{ minExtent }
+  , MaximumExtent(maxExtent)
-  , Spacing{ 1. }
-  , Frequency{ 60., 30., 40. }
-  , Magnitude{ 10., 18., 5. }
-  , MinimumExtent{ minExtent }
-  , MaximumExtent{ maxExtent }
-  , MaximumValue{ 255. }
-  , StandardDeviation{ 0.5 }
 {
 }
 
@@ -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>())

vtkm/source/Wavelet.h

@@ -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
+  VTKM_CONT Wavelet() = default;
-  Wavelet(vtkm::Id3 minExtent = { -10 }, vtkm::Id3 maxExtent = { 10 });
+  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; }
+  ///@{
-
+  /// \brief Specifies the origin (lower left corner) of the dataset created.
-  VTKM_CONT void SetFrequency(const vtkm::Vec<FloatDefault, 3>& frequency)
+  ///
+  /// 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)
+  VTKM_CONT void SetSpacing(const vtkm::Vec3f& spacing) { this->Spacing = spacing; }
-  {
+  VTKM_CONT vtkm::Vec3f GetSpacing() const { return this->Spacing; }
-    this->Magnitude = magnitude;
+
-  }
+  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 Center = { 0, 0, 0 };
-  vtkm::Vec3f Origin;
+  vtkm::Vec3f Origin = { vtkm::Nan<vtkm::FloatDefault>() };
-  vtkm::Vec3f Spacing;
+  vtkm::Vec3f Spacing = { 1, 1, 1 };
-  vtkm::Vec3f Frequency;
+  vtkm::Vec3f Frequency = { 60.0f, 30.0f, 40.0f };
-  vtkm::Vec3f Magnitude;
+  vtkm::Vec3f Magnitude = { 10.0f, 18.0f, 5.0f };
-  vtkm::Id3 MinimumExtent;
+  vtkm::Id3 MinimumExtent = { -10, -10, -10 };
-  vtkm::Id3 MaximumExtent;
+  vtkm::Id3 MaximumExtent = { 10, 10, 10 };
-  vtkm::FloatDefault MaximumValue;
+  vtkm::FloatDefault MaximumValue = 255.0f;
-  vtkm::FloatDefault StandardDeviation;
+  vtkm::FloatDefault StandardDeviation = 0.5f;
 };
 } //namespace source
 } //namespace vtkm

vtkm/source/testing/RenderTestPerlinNoise.cxx

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

vtkm/source/testing/UnitTestOscillatorSource.cxx

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

vtkm/source/testing/UnitTestTangleSource.cxx

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