Update ArrayPortalUniformPointCoordinates

Move ArrayPortalUniformPointCoordinates to the vtkm::internal namespace
since it is going to be actively used in both control and execution
environments.

Replace usage of extent with simple dimensions. We have decided that
there is not a lot of value in supporting extent in VTK-m.

vtkm/cont/ArrayHandleUniformPointCoordinates.h

@@ -20,94 +20,13 @@
 #ifndef vtk_m_cont_ArrayHandleUniformPointCoordinates_h
 #define vtk_m_cont_ArrayHandleUniformPointCoordinates_h
 
-#include <vtkm/Extent.h>
+#include <vtkm/internal/ArrayPortalUniformPointCoordinates.h>
-
 #include <vtkm/cont/ArrayHandle.h>
 #include <vtkm/cont/StorageImplicit.h>
 
 namespace vtkm {
 namespace cont {
 
-namespace internal {
-
-/// \brief An implicit array port that computes point coordinates for a uniform
-/// grid.
-///
-class ArrayPortalUniformPointCoordinates
-{
-public:
-  typedef vtkm::Vec<vtkm::FloatDefault,3> ValueType;
-
-  VTKM_EXEC_CONT_EXPORT
-  ArrayPortalUniformPointCoordinates() : NumberOfValues(0) {  }
-
-  VTKM_EXEC_CONT_EXPORT
-  ArrayPortalUniformPointCoordinates(vtkm::Extent3 extent,
-                                     ValueType origin,
-                                     ValueType spacing)
-    : Extent(extent),
-      Dimensions(vtkm::ExtentPointDimensions(extent)),
-      NumberOfValues(vtkm::ExtentNumberOfPoints(extent)),
-      Origin(origin),
-      Spacing(spacing)
-  {  }
-
-  VTKM_EXEC_CONT_EXPORT
-  ArrayPortalUniformPointCoordinates(
-      const ArrayPortalUniformPointCoordinates &src)
-    : Extent(src.Extent),
-      Dimensions(src.Dimensions),
-      NumberOfValues(src.NumberOfValues),
-      Origin(src.Origin),
-      Spacing(src.Spacing)
-  {  }
-
-  VTKM_EXEC_CONT_EXPORT
-  ArrayPortalUniformPointCoordinates &
-  operator=(const ArrayPortalUniformPointCoordinates &src)
-  {
-    this->Extent = src.Extent;
-    this->Dimensions = src.Dimensions;
-    this->NumberOfValues = src.NumberOfValues;
-    this->Origin = src.Origin;
-    this->Spacing = src.Spacing;
-    return *this;
-  }
-
-  VTKM_EXEC_CONT_EXPORT
-  vtkm::Id GetNumberOfValues() const { return this->NumberOfValues; }
-
-  VTKM_EXEC_CONT_EXPORT
-  ValueType Get(vtkm::Id index) const {
-    return this->GetCoordinatesForTopologyIndex(
-          vtkm::ExtentPointFlatIndexToTopologyIndex(index, this->Extent));
-  }
-
-  VTKM_EXEC_CONT_EXPORT
-  vtkm::Id3 GetRange3() const { return this->Dimensions; }
-
-  VTKM_EXEC_CONT_EXPORT
-  ValueType Get(vtkm::Id3 index) const {
-    return this->GetCoordinatesForTopologyIndex(index + this->Extent.Min);
-  }
-
-private:
-  vtkm::Extent3 Extent;
-  vtkm::Id3 Dimensions;
-  vtkm::Id NumberOfValues;
-  ValueType Origin;
-  ValueType Spacing;
-
-  VTKM_EXEC_CONT_EXPORT
-  ValueType GetCoordinatesForTopologyIndex(vtkm::Id3 ijk) const {
-    return ValueType(this->Origin[0] + this->Spacing[0] * static_cast<vtkm::FloatDefault>(ijk[0]),
-                     this->Origin[1] + this->Spacing[1] * static_cast<vtkm::FloatDefault>(ijk[1]),
-                     this->Origin[2] + this->Spacing[2] * static_cast<vtkm::FloatDefault>(ijk[2]));
-  }
-};
-
-} // namespace internal
-
 /// ArrayHandleUniformPointCoordinates is a specialization of ArrayHandle. It
 /// contains the information necessary to compute the point coordinates in a
 /// uniform orthogonal grid (extent, origin, and spacing) and implicitly
@@ -117,31 +36,29 @@ class ArrayHandleUniformPointCoordinates
     : public vtkm::cont::ArrayHandle<
         vtkm::Vec<vtkm::FloatDefault,3>,
         vtkm::cont::StorageTagImplicit<
-          internal::ArrayPortalUniformPointCoordinates> >
+          vtkm::internal::ArrayPortalUniformPointCoordinates> >
 {
 public:
   typedef vtkm::Vec<vtkm::FloatDefault,3> ValueType;
-
-private:
   typedef vtkm::cont::StorageTagImplicit<
-      internal::ArrayPortalUniformPointCoordinates> StorageTag;
+      vtkm::internal::ArrayPortalUniformPointCoordinates> StorageTag;
-
-  typedef vtkm::cont::internal::Storage<ValueType, StorageTag> StorageType;
 
   typedef vtkm::cont::ArrayHandle<ValueType, StorageTag> Superclass;
 
+private:
+  typedef vtkm::cont::internal::Storage<ValueType, StorageTag> StorageType;
+
 public:
   VTKM_CONT_EXPORT
   ArrayHandleUniformPointCoordinates() : Superclass() {  }
 
   VTKM_CONT_EXPORT
-  ArrayHandleUniformPointCoordinates(vtkm::Extent3 extent,
+  ArrayHandleUniformPointCoordinates(vtkm::Id3 dimensions,
                                      ValueType origin,
                                      ValueType spacing)
     : Superclass(
-        StorageType(internal::ArrayPortalUniformPointCoordinates(extent,
+        StorageType(vtkm::internal::ArrayPortalUniformPointCoordinates(
-                                                                 origin,
+                      dimensions, origin, spacing)))
-                                                                 spacing)))
   {  }
 };
 

vtkm/cont/PointCoordinatesUniform.h

@@ -45,10 +45,10 @@ public:
   PointCoordinatesUniform() {  }
 
   VTKM_CONT_EXPORT
-  PointCoordinatesUniform(const vtkm::Extent3 &extent,
+  PointCoordinatesUniform(const vtkm::Id3 &dimensions,
                           const ValueType &origin,
                           const ValueType &spacing)
-    : Array(extent, origin, spacing)
+    : Array(dimensions, origin, spacing)
   {  }
 
   /// In this \c CastAndCall, both \c TypeList and \c StorageList are

vtkm/cont/testing/UnitTestArrayHandleUniformPointCoordinates.cxx

@@ -26,44 +26,41 @@ namespace {
 
 typedef vtkm::Vec<vtkm::FloatDefault, 3> Vector3;
 
-const vtkm::Id3 MIN_VALUES(-5, 8, 40);
+const vtkm::Id3 DIMENSIONS(16, 18,  5);
-const vtkm::Id3 MAX_VALUES(10, 25, 44);
-const vtkm::Id3 POINT_DIMS(16, 18,  5);
 const vtkm::Id NUM_POINTS = 1440;
 
-const Vector3 ORIGIN(30, -3, -14);
+const Vector3 ORIGIN(-20, 5, -10);
 const Vector3 SPACING(10, 1, 0.1f);
-const Vector3 LOWER_LEFT(-20, 5, -10); // MIN_VALUES*SPACING + ORIGIN
 
 void TestArrayHandleUniformPointCoordinates()
 {
   std::cout << "Creating ArrayHandleUniformPointCoordinates" << std::endl;
 
   vtkm::cont::ArrayHandleUniformPointCoordinates arrayHandle(
-        vtkm::Extent3(MIN_VALUES, MAX_VALUES), ORIGIN, SPACING);
+        DIMENSIONS, ORIGIN, SPACING);
   VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == NUM_POINTS,
                    "Array computed wrong number of points.");
 
   std::cout << "Getting array portal." << std::endl;
-  vtkm::cont::internal::ArrayPortalUniformPointCoordinates portal =
+  vtkm::internal::ArrayPortalUniformPointCoordinates portal =
       arrayHandle.GetPortalConstControl();
   VTKM_TEST_ASSERT(portal.GetNumberOfValues() == NUM_POINTS,
                    "Portal has wrong number of points.");
-  VTKM_TEST_ASSERT(portal.GetRange3() == POINT_DIMS,
+  VTKM_TEST_ASSERT(portal.GetRange3() == DIMENSIONS,
                    "Portal range is wrong.");
 
   std::cout << "Checking computed values of portal." << std::endl;
   Vector3 expectedValue;
   vtkm::Id flatIndex = 0;
   vtkm::Id3 blockIndex;
-  expectedValue[2] = LOWER_LEFT[2];
+  expectedValue[2] = ORIGIN[2];
-  for (blockIndex[2] = 0; blockIndex[2] < POINT_DIMS[2]; blockIndex[2]++)
+  for (blockIndex[2] = 0; blockIndex[2] < DIMENSIONS[2]; blockIndex[2]++)
   {
-    expectedValue[1] = LOWER_LEFT[1];
+    expectedValue[1] = ORIGIN[1];
-    for (blockIndex[1] = 0; blockIndex[1] < POINT_DIMS[1]; blockIndex[1]++)
+    for (blockIndex[1] = 0; blockIndex[1] < DIMENSIONS[1]; blockIndex[1]++)
     {
-      expectedValue[0] = LOWER_LEFT[0];
+      expectedValue[0] = ORIGIN[0];
-      for (blockIndex[0] = 0; blockIndex[0] < POINT_DIMS[0]; blockIndex[0]++)
+      for (blockIndex[0] = 0; blockIndex[0] < DIMENSIONS[0]; blockIndex[0]++)
       {
         VTKM_TEST_ASSERT(test_equal(expectedValue, portal.Get(flatIndex)),
                          "Got wrong value for flat index.");

vtkm/cont/testing/UnitTestDynamicPointCoordinates.cxx

@@ -31,21 +31,20 @@
 
 namespace {
 
-const vtkm::Extent3 EXTENT = vtkm::Extent3(vtkm::Id3(0,0,0), vtkm::Id3(9,9,9));
+const vtkm::Id3 DIMENSIONS = vtkm::Id3(9,9,9);
 const vtkm::Vec<vtkm::FloatDefault,3> ORIGIN =
     vtkm::Vec<vtkm::FloatDefault,3>(0, 0, 0);
 const vtkm::Vec<vtkm::FloatDefault,3> SPACING =
     vtkm::Vec<vtkm::FloatDefault,3>(1, 1, 1);
 
-const vtkm::Id3 DIMENSION = vtkm::ExtentPointDimensions(EXTENT);
+const vtkm::Id ARRAY_SIZE = DIMENSIONS[0]*DIMENSIONS[1]*DIMENSIONS[2];
-const vtkm::Id ARRAY_SIZE = DIMENSION[0]*DIMENSION[1]*DIMENSION[2];
 
 vtkm::Vec<vtkm::FloatDefault,3> ExpectedCoordinates(vtkm::Id index)
 {
-  vtkm::Id3 index3d = vtkm::ExtentPointFlatIndexToTopologyIndex(index, EXTENT);
+  return vtkm::make_Vec(
-  return vtkm::make_Vec(vtkm::FloatDefault(index3d[0]),
+        vtkm::FloatDefault(index%DIMENSIONS[0]),
-                        vtkm::FloatDefault(index3d[1]),
+        vtkm::FloatDefault((index/DIMENSIONS[0])%DIMENSIONS[1]),
-                        vtkm::FloatDefault(index3d[2]));
+        vtkm::FloatDefault(index/(DIMENSIONS[0]*DIMENSIONS[1])));
 }
 
 int g_CheckArrayInvocations;
@@ -178,7 +177,7 @@ void TryUniformPointCoordinates()
 
   vtkm::cont::DynamicPointCoordinates pointCoordinates =
       vtkm::cont::DynamicPointCoordinates(
-        vtkm::cont::PointCoordinatesUniform(EXTENT, ORIGIN, SPACING));
+        vtkm::cont::PointCoordinatesUniform(DIMENSIONS, ORIGIN, SPACING));
 
   pointCoordinates.CastAndCall(CheckArray());
 

vtkm/cont/testing/UnitTestPointCoordinates.cxx

@@ -29,7 +29,6 @@
 #include <vtkm/cont/PointCoordinatesArray.h>
 #include <vtkm/cont/PointCoordinatesUniform.h>
 
-#include <vtkm/Extent.h>
 #include <vtkm/TypeListTag.h>
 
 #include <vtkm/cont/DeviceAdapterSerial.h>
@@ -41,14 +40,13 @@
 
 namespace {
 
-const vtkm::Extent3 EXTENT = vtkm::Extent3(vtkm::Id3(0,0,0), vtkm::Id3(9,9,9));
+const vtkm::Id3 DIMENSIONS = vtkm::Id3(9,9,9);
 const vtkm::Vec<vtkm::FloatDefault,3> ORIGIN =
     vtkm::Vec<vtkm::FloatDefault,3>(0, 0, 0);
 const vtkm::Vec<vtkm::FloatDefault,3> SPACING =
     vtkm::Vec<vtkm::FloatDefault,3>(1, 1, 1);
 
-const vtkm::Id3 DIMENSION = vtkm::ExtentPointDimensions(EXTENT);
+const vtkm::Id ARRAY_SIZE = DIMENSIONS[0]*DIMENSIONS[1]*DIMENSIONS[2];
-const vtkm::Id ARRAY_SIZE = DIMENSION[0]*DIMENSION[1]*DIMENSION[2];
 
 typedef vtkm::cont::StorageTagBasic StorageTag;
 
@@ -56,10 +54,10 @@ struct StorageListTag : vtkm::cont::StorageListTagBasic {  };
 
 vtkm::Vec<vtkm::FloatDefault,3> ExpectedCoordinates(vtkm::Id index)
 {
-  vtkm::Id3 index3d = vtkm::ExtentPointFlatIndexToTopologyIndex(index, EXTENT);
+  return vtkm::make_Vec(
-  return vtkm::make_Vec(vtkm::FloatDefault(index3d[0]),
+        vtkm::FloatDefault(index%DIMENSIONS[0]),
-                        vtkm::FloatDefault(index3d[1]),
+        vtkm::FloatDefault((index/DIMENSIONS[0])%DIMENSIONS[1]),
-                        vtkm::FloatDefault(index3d[2]));
+        vtkm::FloatDefault(index/(DIMENSIONS[0]*DIMENSIONS[1])));
 }
 
 struct CheckArray
@@ -122,7 +120,7 @@ void TestPointCoordinatesUniform()
   std::cout << "Testing PointCoordinatesUniform" << std::endl;
 
   vtkm::cont::PointCoordinatesUniform pointCoordinates =
-      vtkm::cont::PointCoordinatesUniform(EXTENT, ORIGIN, SPACING);
+      vtkm::cont::PointCoordinatesUniform(DIMENSIONS, ORIGIN, SPACING);
   pointCoordinates.CastAndCall(
         CheckArray(),
         vtkm::ListTagEmpty(), // Not used

vtkm/internal/ArrayPortalUniformPointCoordinates.h

@@ -0,0 +1,108 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2015 Sandia Corporation.
+//  Copyright 2015 UT-Battelle, LLC.
+//  Copyright 2015 Los Alamos National Security.
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtk_m_internal_ArrayPortalUniformPointCoordinates_h
+#define vtk_m_internal_ArrayPortalUniformPointCoordinates_h
+
+#include <vtkm/Types.h>
+
+namespace vtkm {
+namespace internal {
+
+/// \brief An implicit array port that computes point coordinates for a uniform grid.
+///
+class ArrayPortalUniformPointCoordinates
+{
+public:
+  typedef vtkm::Vec<vtkm::FloatDefault,3> ValueType;
+
+  VTKM_EXEC_CONT_EXPORT
+  ArrayPortalUniformPointCoordinates() : NumberOfValues(0) {  }
+
+  VTKM_EXEC_CONT_EXPORT
+  ArrayPortalUniformPointCoordinates(vtkm::Id3 dimensions,
+                                     ValueType origin,
+                                     ValueType spacing)
+    : Dimensions(dimensions),
+      NumberOfValues(dimensions[0]*dimensions[1]*dimensions[2]),
+      Origin(origin),
+      Spacing(spacing)
+  {  }
+
+  VTKM_EXEC_CONT_EXPORT
+  ArrayPortalUniformPointCoordinates(
+      const ArrayPortalUniformPointCoordinates &src)
+    : Dimensions(src.Dimensions),
+      NumberOfValues(src.NumberOfValues),
+      Origin(src.Origin),
+      Spacing(src.Spacing)
+  {  }
+
+  VTKM_EXEC_CONT_EXPORT
+  ArrayPortalUniformPointCoordinates &
+  operator=(const ArrayPortalUniformPointCoordinates &src)
+  {
+    this->Dimensions = src.Dimensions;
+    this->NumberOfValues = src.NumberOfValues;
+    this->Origin = src.Origin;
+    this->Spacing = src.Spacing;
+    return *this;
+  }
+
+  VTKM_EXEC_CONT_EXPORT
+  vtkm::Id GetNumberOfValues() const { return this->NumberOfValues; }
+
+  VTKM_EXEC_CONT_EXPORT
+  ValueType Get(vtkm::Id index) const {
+    return this->Get(
+          vtkm::Id3(index%this->Dimensions[0],
+                    (index/this->Dimensions[0])%this->Dimensions[1],
+                    index/(this->Dimensions[0]*this->Dimensions[1])));
+  }
+
+  VTKM_EXEC_CONT_EXPORT
+  vtkm::Id3 GetRange3() const { return this->Dimensions; }
+
+  VTKM_EXEC_CONT_EXPORT
+  ValueType Get(vtkm::Id3 index) const {
+    return ValueType(this->Origin[0] + this->Spacing[0] * static_cast<vtkm::FloatDefault>(index[0]),
+                     this->Origin[1] + this->Spacing[1] * static_cast<vtkm::FloatDefault>(index[1]),
+                     this->Origin[2] + this->Spacing[2] * static_cast<vtkm::FloatDefault>(index[2]));
+  }
+
+  VTKM_EXEC_CONT_EXPORT
+  const vtkm::Id3 &GetDimensions() const { return this->Dimensions; }
+
+  VTKM_EXEC_CONT_EXPORT
+  const ValueType &GetOrigin() const { return this->Origin; }
+
+  VTKM_EXEC_CONT_EXPORT
+  const ValueType &GetSpacing() const { return this->Spacing; }
+
+private:
+  vtkm::Id3 Dimensions;
+  vtkm::Id NumberOfValues;
+  ValueType Origin;
+  ValueType Spacing;
+};
+
+}
+} // namespace vtkm::internal
+
+#endif //vtk_m_internal_ArrayPortalUniformPointCoordinates_h

vtkm/internal/CMakeLists.txt

@@ -19,6 +19,7 @@
 ##============================================================================
 
 set(headers
+  ArrayPortalUniformPointCoordinates.h
   ConfigureFor32.h
   ConfigureFor64.h
   ConnectivityStructuredInternals.h