Adding PointTransform filter and updating PointTranform worklet.

vtkm/filter/CMakeLists.txt

@@ -50,6 +50,7 @@ set(headers
   NDHistogram.h
   PointAverage.h
   PointElevation.h
+  PointTransform.h
   PolicyBase.h
   PolicyDefault.h
   Probe.h
@@ -92,6 +93,7 @@ set(header_template_sources
   NDHistogram.hxx
   PointAverage.hxx
   PointElevation.hxx
+  PointTransform.hxx
   Probe.hxx
   Streamline.hxx
   SurfaceNormals.hxx
@@ -111,4 +113,3 @@ add_subdirectory(internal)
 
 #-----------------------------------------------------------------------------
 add_subdirectory(testing)
-

vtkm/filter/PointTransform.h

+//============================================================================
+//  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 2014 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014 Los Alamos National Security.
+//
+//  Under the terms of Contract DE-NA0003525 with NTESS,
+//  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_filter_PointTransform_h
+#define vtk_m_filter_PointTransform_h
+
+#include <vtkm/filter/FilterField.h>
+#include <vtkm/worklet/PointTransform.h>
+
+namespace vtkm
+{
+namespace filter
+{
+/// \brief
+///
+/// Generate scalar field from a dataset.
+template <typename S>
+class PointTransform : public vtkm::filter::FilterField<PointTransform<S>>
+{
+public:
+  VTKM_CONT
+  PointTransform();
+
+  void SetTranslation(const S& tx, const S& ty, const S& tz);
+
+  void SetTranslation(const vtkm::Vec<S, 3>& v);
+
+  void SetRotation(const S& angleDegrees, const vtkm::Vec<S, 3>& axis);
+
+  void SetRotation(const S& angleDegrees, const S& rx, const S& ry, const S& rz);
+
+  void SetRotationX(const S& angleDegrees);
+
+  void SetRotationY(const S& angleDegrees);
+
+  void SetRotationZ(const S& angleDegrees);
+
+  void SetScale(const S& s);
+
+  void SetScale(const S& sx, const S& sy, const S& sz);
+
+  void SetScale(const vtkm::Vec<S, 3>& v);
+
+  void SetTransform(const vtkm::Matrix<S, 4, 4>& mtx);
+
+  template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
+  VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
+                                          const vtkm::cont::ArrayHandle<T, StorageType>& field,
+                                          const vtkm::filter::FieldMetadata& fieldMeta,
+                                          const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
+                                          const DeviceAdapter& tag);
+
+private:
+  vtkm::worklet::PointTransform<S> Worklet;
+};
+
+template <typename S>
+class FilterTraits<PointTransform<S>>
+{
+public:
+  //Point Elevation can only convert Float and Double Vec3 arrays
+  using InputFieldTypeList = vtkm::TypeListTagFieldVec3;
+};
+}
+} // namespace vtkm::filter
+
+#include <vtkm/filter/PointTransform.hxx>
+
+#endif // vtk_m_filter_PointTransform_h

vtkm/filter/PointTransform.hxx

+//============================================================================
+//  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 2014 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014 Los Alamos National Security.
+//
+//  Under the terms of Contract DE-NA0003525 with NTESS,
+//  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.
+//============================================================================
+
+#include <vtkm/filter/internal/CreateResult.h>
+#include <vtkm/worklet/DispatcherMapField.h>
+
+namespace vtkm
+{
+namespace filter
+{
+
+//-----------------------------------------------------------------------------
+template <typename S>
+inline VTKM_CONT PointTransform<S>::PointTransform()
+  : Worklet()
+{
+  this->SetOutputFieldName("transform");
+}
+
+//-----------------------------------------------------------------------------
+template <typename S>
+inline VTKM_CONT void PointTransform<S>::SetTranslation(const S& tx, const S& ty, const S& tz)
+{
+  this->Worklet.SetTranslation(tx, ty, tz);
+}
+
+//-----------------------------------------------------------------------------
+template <typename S>
+inline VTKM_CONT void PointTransform<S>::SetTranslation(const vtkm::Vec<S, 3>& v)
+{
+  this->Worklet.SetTranslation(v);
+}
+
+//-----------------------------------------------------------------------------
+template <typename S>
+inline VTKM_CONT void PointTransform<S>::SetRotation(const S& angleDegrees,
+                                                     const vtkm::Vec<S, 3>& axis)
+{
+  this->Worklet.SetRotation(angleDegrees, axis);
+}
+
+//-----------------------------------------------------------------------------
+template <typename S>
+inline VTKM_CONT void PointTransform<S>::SetRotation(const S& angleDegrees,
+                                                     const S& rx,
+                                                     const S& ry,
+                                                     const S& rz)
+{
+  this->Worklet.SetRotation(angleDegrees, rx, ry, rz);
+}
+
+//-----------------------------------------------------------------------------
+template <typename S>
+inline VTKM_CONT void PointTransform<S>::SetRotationX(const S& angleDegrees)
+{
+  this->Worklet.SetRotationX(angleDegrees);
+}
+
+//-----------------------------------------------------------------------------
+template <typename S>
+inline VTKM_CONT void PointTransform<S>::SetRotationY(const S& angleDegrees)
+{
+  this->Worklet.SetRotationY(angleDegrees);
+}
+
+//-----------------------------------------------------------------------------
+template <typename S>
+inline VTKM_CONT void PointTransform<S>::SetRotationZ(const S& angleDegrees)
+{
+  this->Worklet.SetRotationZ(angleDegrees);
+}
+
+//-----------------------------------------------------------------------------
+template <typename S>
+inline VTKM_CONT void PointTransform<S>::SetScale(const S& s)
+{
+  this->Worklet.SetScale(s);
+}
+
+//-----------------------------------------------------------------------------
+template <typename S>
+inline VTKM_CONT void PointTransform<S>::SetScale(const S& sx, const S& sy, const S& sz)
+{
+  this->Worklet.SetScale(sx, sy, sz);
+}
+
+//-----------------------------------------------------------------------------
+template <typename S>
+inline VTKM_CONT void PointTransform<S>::SetScale(const vtkm::Vec<S, 3>& v)
+{
+  this->Worklet.SetScale(v);
+}
+
+//-----------------------------------------------------------------------------
+template <typename S>
+inline VTKM_CONT void PointTransform<S>::SetTransform(const vtkm::Matrix<S, 4, 4>& mtx)
+{
+  this->Worklet.SetTransform(mtx);
+}
+
+
+//-----------------------------------------------------------------------------
+template <typename S>
+template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
+inline VTKM_CONT vtkm::cont::DataSet PointTransform<S>::DoExecute(
+  const vtkm::cont::DataSet& inDataSet,
+  const vtkm::cont::ArrayHandle<T, StorageType>& field,
+  const vtkm::filter::FieldMetadata& fieldMetadata,
+  const vtkm::filter::PolicyBase<DerivedPolicy>&,
+  const DeviceAdapter&)
+{
+  vtkm::cont::ArrayHandle<T> outArray;
+  vtkm::worklet::DispatcherMapField<vtkm::worklet::PointTransform<S>, DeviceAdapter> dispatcher(
+    this->Worklet);
+
+  dispatcher.Invoke(field, outArray);
+
+  return internal::CreateResult(inDataSet,
+                                outArray,
+                                this->GetOutputFieldName(),
+                                fieldMetadata.GetAssociation(),
+                                fieldMetadata.GetCellSetName());
+}
+}
+} // namespace vtkm::filter

vtkm/filter/testing/CMakeLists.txt

@@ -46,6 +46,7 @@ set(unit_tests
   UnitTestNDHistogramFilter.cxx
   UnitTestPointAverageFilter.cxx
   UnitTestPointElevationFilter.cxx
+  UnitTestPointTransform.cxx
   UnitTestProbe.cxx
   UnitTestStreamlineFilter.cxx
   UnitTestSurfaceNormalsFilter.cxx

vtkm/filter/testing/UnitTestPointTransform.cxx

+//============================================================================
+//  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 2014 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014 Los Alamos National Security.
+//
+//  Under the terms of Contract DE-NA0003525 with NTESS,
+//  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.
+//============================================================================
+
+#include <vtkm/cont/testing/Testing.h>
+#include <vtkm/filter/PointTransform.h>
+
+#include <random>
+#include <string>
+#include <vector>
+
+namespace
+{
+std::mt19937 randGenerator;
+
+vtkm::cont::DataSet MakePointTransformTestDataSet()
+{
+  vtkm::cont::DataSet dataSet;
+
+  std::vector<vtkm::Vec<vtkm::FloatDefault, 3>> coordinates;
+  const vtkm::Id dim = 5;
+  for (vtkm::Id j = 0; j < dim; ++j)
+  {
+    vtkm::FloatDefault z =
+      static_cast<vtkm::FloatDefault>(j) / static_cast<vtkm::FloatDefault>(dim - 1);
+    for (vtkm::Id i = 0; i < dim; ++i)
+    {
+      vtkm::FloatDefault x =
+        static_cast<vtkm::FloatDefault>(i) / static_cast<vtkm::FloatDefault>(dim - 1);
+      vtkm::FloatDefault y = (x * x + z * z) / 2.0f;
+      coordinates.push_back(vtkm::make_Vec(x, y, z));
+    }
+  }
+
+  vtkm::Id numCells = (dim - 1) * (dim - 1);
+  dataSet.AddCoordinateSystem(
+    vtkm::cont::make_CoordinateSystem("coordinates", coordinates, vtkm::CopyFlag::On));
+
+  vtkm::cont::CellSetExplicit<> cellSet("cells");
+  cellSet.PrepareToAddCells(numCells, numCells * 4);
+  for (vtkm::Id j = 0; j < dim - 1; ++j)
+  {
+    for (vtkm::Id i = 0; i < dim - 1; ++i)
+    {
+      cellSet.AddCell(vtkm::CELL_SHAPE_QUAD,
+                      4,
+                      vtkm::make_Vec<vtkm::Id>(
+                        j * dim + i, j * dim + i + 1, (j + 1) * dim + i + 1, (j + 1) * dim + i));
+    }
+  }
+  cellSet.CompleteAddingCells(vtkm::Id(coordinates.size()));
+
+  dataSet.AddCellSet(cellSet);
+  return dataSet;
+}
+
+void ValidatePointTransform(const vtkm::cont::CoordinateSystem& coords,
+                            const std::string fieldName,
+                            const vtkm::cont::DataSet& result,
+                            const vtkm::Matrix<vtkm::FloatDefault, 4, 4>& matrix)
+{
+  //verify the result
+  VTKM_TEST_ASSERT(result.HasField(fieldName, vtkm::cont::Field::Association::POINTS),
+                   "Output field missing.");
+
+  vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>> resultArrayHandle;
+  result.GetField(fieldName, vtkm::cont::Field::Association::POINTS)
+    .GetData()
+    .CopyTo(resultArrayHandle);
+
+  auto points = coords.GetData();
+  VTKM_TEST_ASSERT(points.GetNumberOfValues() == resultArrayHandle.GetNumberOfValues(),
+                   "Incorrect number of points in point transform");
+
+  auto pointsPortal = points.GetPortalControl();
+  auto resultsPortal = resultArrayHandle.GetPortalControl();
+
+  for (vtkm::Id i = 0; i < points.GetNumberOfValues(); i++)
+    VTKM_TEST_ASSERT(
+      test_equal(resultsPortal.Get(i), vtkm::Transform3DPoint(matrix, pointsPortal.Get(i))),
+      "Wrong result for PointTransform worklet");
+}
+
+
+void TestPointTransformTranslation(const vtkm::cont::DataSet& ds,
+                                   const vtkm::Vec<vtkm::FloatDefault, 3>& trans)
+{
+  vtkm::filter::PointTransform<vtkm::FloatDefault> filter;
+
+  filter.SetOutputFieldName("translation");
+  filter.SetUseCoordinateSystemAsField(true);
+  filter.SetTranslation(trans);
+  auto result = filter.Execute(ds);
+
+  ValidatePointTransform(
+    ds.GetCoordinateSystem(), "translation", result, Transform3DTranslate(trans));
+}
+
+void TestPointTransformScale(const vtkm::cont::DataSet& ds,
+                             const vtkm::Vec<vtkm::FloatDefault, 3>& scale)
+{
+  vtkm::filter::PointTransform<vtkm::FloatDefault> filter;
+
+  filter.SetOutputFieldName("scale");
+  filter.SetUseCoordinateSystemAsField(true);
+  filter.SetScale(scale);
+  auto result = filter.Execute(ds);
+
+  ValidatePointTransform(ds.GetCoordinateSystem(), "scale", result, Transform3DScale(scale));
+}
+
+void TestPointTransformRotation(const vtkm::cont::DataSet& ds,
+                                const vtkm::FloatDefault& angle,
+                                const vtkm::Vec<vtkm::FloatDefault, 3>& axis)
+{
+  vtkm::filter::PointTransform<vtkm::FloatDefault> filter;
+
+  filter.SetOutputFieldName("rotation");
+  filter.SetUseCoordinateSystemAsField(true);
+  filter.SetRotation(angle, axis);
+  auto result = filter.Execute(ds);
+
+  ValidatePointTransform(
+    ds.GetCoordinateSystem(), "rotation", result, Transform3DRotate(angle, axis));
+}
+}
+
+void TestPointTransform()
+{
+  std::cout << "Testing PointTransform Worklet" << std::endl;
+
+  vtkm::cont::DataSet ds = MakePointTransformTestDataSet();
+  int N = 41;
+
+  //Test translation
+  TestPointTransformTranslation(ds, vtkm::Vec<vtkm::FloatDefault, 3>(0, 0, 0));
+  TestPointTransformTranslation(ds, vtkm::Vec<vtkm::FloatDefault, 3>(1, 1, 1));
+  TestPointTransformTranslation(ds, vtkm::Vec<vtkm::FloatDefault, 3>(-1, -1, -1));
+
+  std::uniform_real_distribution<vtkm::FloatDefault> transDist(-100, 100);
+  for (int i = 0; i < N; i++)
+    TestPointTransformTranslation(ds,
+                                  vtkm::Vec<vtkm::FloatDefault, 3>(transDist(randGenerator),
+                                                                   transDist(randGenerator),
+                                                                   transDist(randGenerator)));
+
+  //Test scaling
+  TestPointTransformScale(ds, vtkm::Vec<vtkm::FloatDefault, 3>(1, 1, 1));
+  TestPointTransformScale(ds, vtkm::Vec<vtkm::FloatDefault, 3>(.23f, .23f, .23f));
+  TestPointTransformScale(ds, vtkm::Vec<vtkm::FloatDefault, 3>(1, 2, 3));
+  TestPointTransformScale(ds, vtkm::Vec<vtkm::FloatDefault, 3>(3.23f, 9.23f, 4.23f));
+
+  std::uniform_real_distribution<vtkm::FloatDefault> scaleDist(0.0001f, 100);
+  for (int i = 0; i < N; i++)
+  {
+    TestPointTransformScale(ds, vtkm::Vec<vtkm::FloatDefault, 3>(scaleDist(randGenerator)));
+    TestPointTransformScale(ds,
+                            vtkm::Vec<vtkm::FloatDefault, 3>(scaleDist(randGenerator),
+                                                             scaleDist(randGenerator),
+                                                             scaleDist(randGenerator)));
+  }
+
+  //Test rotation
+  std::vector<vtkm::FloatDefault> angles;
+  std::uniform_real_distribution<vtkm::FloatDefault> angleDist(0, 360);
+  for (int i = 0; i < N; i++)
+    angles.push_back(angleDist(randGenerator));
+
+  std::vector<vtkm::Vec<vtkm::FloatDefault, 3>> axes;
+  axes.push_back(vtkm::Vec<vtkm::FloatDefault, 3>(1, 0, 0));
+  axes.push_back(vtkm::Vec<vtkm::FloatDefault, 3>(0, 1, 0));
+  axes.push_back(vtkm::Vec<vtkm::FloatDefault, 3>(0, 0, 1));
+  axes.push_back(vtkm::Vec<vtkm::FloatDefault, 3>(1, 1, 1));
+  axes.push_back(-axes[0]);
+  axes.push_back(-axes[1]);
+  axes.push_back(-axes[2]);
+  axes.push_back(-axes[3]);
+
+  std::uniform_real_distribution<vtkm::FloatDefault> axisDist(-1, 1);
+  for (int i = 0; i < N; i++)
+    axes.push_back(vtkm::Vec<vtkm::FloatDefault, 3>(
+      axisDist(randGenerator), axisDist(randGenerator), axisDist(randGenerator)));
+
+  for (std::size_t i = 0; i < angles.size(); i++)
+    for (std::size_t j = 0; j < axes.size(); j++)
+      TestPointTransformRotation(ds, angles[i], axes[j]);
+}
+
+
+int UnitTestPointTransform(int, char* [])
+{
+  return vtkm::cont::testing::Testing::Run(TestPointTransform);
+}

vtkm/worklet/PointTransform.h

@@ -62,7 +62,7 @@ public:
   }
 
   template <typename S>
-  VTKM_CONT void SetRotationX(const S& angleDegrees, const S& rx, const S& ry, const S& rz)
+  VTKM_CONT void SetRotation(const S& angleDegrees, const S& rx, const S& ry, const S& rz)
   {
     SetRotation(angleDegrees, vtkm::Vec<S, 3>(rx, ry, rz));
   }