Add CellCenter field to HTG Generate Fields

Filters/HyperTree/CMakeLists.txt

@@ -3,6 +3,7 @@ set(classes
   vtkHyperTreeGridAxisCut
   vtkHyperTreeGridAxisReflection
   vtkHyperTreeGridCellCenters
+  vtkHyperTreeGridCellCenterStrategy
   vtkHyperTreeGridCellSizeStrategy
   vtkHyperTreeGridContour
   vtkHyperTreeGridDepthLimiter
@@ -36,7 +37,7 @@ set(private_classes
 )
 
 vtk_module_add_module(VTK::FiltersHyperTree
-  CLASSES ${classes}
   HEADERS ${headers}
+  CLASSES ${classes}
   PRIVATE_CLASSES ${private_classes})
 vtk_add_test_mangling(VTK::FiltersHyperTree)

Filters/HyperTree/Testing/Cxx/TestHyperTreeGridGenerateFields.cxx

@@ -165,7 +165,7 @@ bool TestDifferentVolumes()
   vtkNew<vtkHyperTreeGridOrientedCursor> cursor;
   inputHTG->SetDepthLimiter(MAX_DEPTH);
   inputHTG->InitializeOrientedCursor(cursor, 0);
-  cursor->SetGlobalIndexStart(inputHTG->GetNumberOfCells());
+  cursor->SetGlobalIndexStart(inputHTG->GetNumberOfCells() - 1);
   std::vector<int> levelIds(MAX_DEPTH, 0);
   for (int i = 0; i < MAX_DEPTH; i++)
   {
@@ -250,6 +250,45 @@ bool TestTotalVolume()
   return true;
 }
 
+bool TestCellCenter()
+{
+  // Create a pseudo-random HTG
+  vtkNew<vtkHyperTreeGridSource> source;
+  source->SetDimensions(3, 4, 1);
+  source->SetMaxDepth(2);
+  source->SetDescriptor("RRRRR.|.... .... .... .... ....");
+  source->UseMaskOn();
+  source->SetMask("111111|1110 1111 1111 1111 1111");
+  source->Update();
+
+  // Apply our filter
+  vtkNew<vtkHyperTreeGridGenerateFields> generateFields;
+  generateFields->SetInputConnection(source->GetOutputPort());
+  generateFields->Update();
+  vtkHyperTreeGrid* outputHTG = generateFields->GetHyperTreeGridOutput();
+
+  vtkSmartPointer<vtkDoubleArray> cellCenterArray =
+    vtkDoubleArray::SafeDownCast(outputHTG->GetCellData()->GetAbstractArray("CellCenter"));
+  std::cout << cellCenterArray->GetNumberOfTuples() << std::endl;
+
+  double* pt = cellCenterArray->GetTuple3(8);
+  if (pt[0] != 0.25 || pt[1] != 0.75)
+  {
+    std::cerr << "CellCenter is " << pt[0] << " " << pt[1] << " but expected 0.25 0.75"
+              << std::endl;
+    return false;
+  }
+
+  pt = cellCenterArray->GetTuple3(5);
+  if (pt[0] != 1.5 || pt[1] != 2.5)
+  {
+    std::cerr << "CellCenter is " << pt[0] << " " << pt[1] << " but expected 1.5 2.5" << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
 }
 
 int TestHyperTreeGridGenerateFields(int argc, char* argv[])
@@ -258,6 +297,7 @@ int TestHyperTreeGridGenerateFields(int argc, char* argv[])
   result &= ::TestMaskGhostSizes(argc, argv);
   result &= ::TestDifferentVolumes();
   result &= ::TestTotalVolume();
+  result &= ::TestCellCenter();
 
   return result ? EXIT_SUCCESS : EXIT_FAILURE;
 }

Filters/HyperTree/vtkHyperTreeGridCellCenterStrategy.cxx

+// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+// SPDX-License-Identifier: BSD-3-Clause
+
+#include "vtkHyperTreeGridCellCenterStrategy.h"
+
+#include "vtkBitArray.h"
+#include "vtkDoubleArray.h"
+#include "vtkHyperTreeGridNonOrientedGeometryCursor.h"
+#include "vtkUnsignedCharArray.h"
+
+VTK_ABI_NAMESPACE_BEGIN
+vtkStandardNewMacro(vtkHyperTreeGridCellCenterStrategy);
+
+//------------------------------------------------------------------------------
+vtkHyperTreeGridCellCenterStrategy::vtkHyperTreeGridCellCenterStrategy() = default;
+
+//------------------------------------------------------------------------------
+vtkHyperTreeGridCellCenterStrategy::~vtkHyperTreeGridCellCenterStrategy() = default;
+
+//------------------------------------------------------------------------------
+void vtkHyperTreeGridCellCenterStrategy::PrintSelf(ostream& os, vtkIndent indent)
+{
+  this->Superclass::PrintSelf(os, indent);
+  os << indent << "InputMask size: " << (this->InputMask ? this->InputMask->GetNumberOfTuples() : 0)
+     << "\n";
+  os << indent
+     << "InputGhost size: " << (this->InputGhost ? this->InputGhost->GetNumberOfTuples() : 0)
+     << "\n";
+  os << indent << "CellCentersArray size: "
+     << (this->CellCentersArray ? this->CellCentersArray->GetNumberOfTuples() : 0) << "\n";
+}
+
+//------------------------------------------------------------------------------
+void vtkHyperTreeGridCellCenterStrategy::Initialize(vtkHyperTreeGrid* inputHTG)
+{
+  this->CellCentersArray->SetName(this->ArrayName.c_str());
+  this->CellCentersArray->SetNumberOfComponents(3);
+  this->CellCentersArray->SetNumberOfTuples(inputHTG->GetNumberOfCells());
+
+  this->InputMask = inputHTG->HasMask() ? inputHTG->GetMask() : nullptr;
+  this->InputGhost = inputHTG->GetGhostCells();
+}
+
+//------------------------------------------------------------------------------
+void vtkHyperTreeGridCellCenterStrategy::Compute(vtkHyperTreeGridNonOrientedGeometryCursor* cursor)
+{
+  if (cursor->IsLeaf())
+  {
+    vtkIdType currentId = cursor->GetGlobalNodeIndex();
+    bool validity = true;
+    if (this->InputMask != nullptr && this->InputMask->GetTuple1(currentId) != 0)
+    {
+      validity = false;
+    }
+    if (this->InputGhost != nullptr && this->InputGhost->GetTuple1(currentId) != 0)
+    {
+      validity = false;
+    }
+
+    if (validity)
+    {
+      double pt[3];
+      cursor->GetPoint(pt);
+
+      this->CellCentersArray->SetTuple3(currentId, pt[0], pt[1], pt[2]);
+    }
+  }
+}
+
+//------------------------------------------------------------------------------
+vtkDataArray* vtkHyperTreeGridCellCenterStrategy::GetAndFinalizeArray()
+{
+  return this->CellCentersArray;
+}
+
+VTK_ABI_NAMESPACE_END

Filters/HyperTree/vtkHyperTreeGridCellCenterStrategy.h

+// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+// SPDX-License-Identifier: BSD-3-Clause
+/**
+ * @class vtkHyperTreeGridCellCenterStrategy
+ * @brief Define the CellCenter field used in vtkHyperTreeGridGenerateFields
+ *
+ * This is a class used by vtkHyperTreeGridGenerateFields to add and compute the CellCenter
+ * field.
+ */
+
+#ifndef vtkHyperTreeGridCellCenterStrategy_h
+#define vtkHyperTreeGridCellCenterStrategy_h
+
+#include "vtkFiltersHyperTreeModule.h" // For export macro
+#include "vtkHyperTreeGridGenerateFieldStrategy.h"
+#include "vtkNew.h"
+
+VTK_ABI_NAMESPACE_BEGIN
+
+class vtkBitArray;
+class vtkDoubleArray;
+class vtkUnsignedCharArray;
+
+class VTKFILTERSHYPERTREE_EXPORT vtkHyperTreeGridCellCenterStrategy
+  : public vtkHyperTreeGridGenerateFieldStrategy
+{
+public:
+  static vtkHyperTreeGridCellCenterStrategy* New();
+  vtkTypeMacro(vtkHyperTreeGridCellCenterStrategy, vtkHyperTreeGridGenerateFieldStrategy);
+  void PrintSelf(ostream& os, vtkIndent indent) override;
+
+  /**
+   * Init internal variables from `inputHTG`.
+   */
+  void Initialize(vtkHyperTreeGrid* inputHTG) override;
+
+  using vtkHyperTreeGridGenerateFieldStrategy::Compute;
+  /**
+   * Compute the center of the cell
+   */
+  void Compute(vtkHyperTreeGridNonOrientedGeometryCursor* cursor) override;
+
+  /**
+   * Return a vtkDoubleArray containing the center of each cell.
+   */
+  vtkDataArray* GetAndFinalizeArray() override;
+
+private:
+  vtkHyperTreeGridCellCenterStrategy();
+  ~vtkHyperTreeGridCellCenterStrategy() override;
+
+  // Input data
+  vtkBitArray* InputMask = nullptr;
+  vtkUnsignedCharArray* InputGhost = nullptr;
+
+  // Output array
+  vtkNew<vtkDoubleArray> CellCentersArray;
+};
+
+VTK_ABI_NAMESPACE_END
+#endif // vtkHyperTreeGridCellCenterStrategy_h

Filters/HyperTree/vtkHyperTreeGridGenerateFields.cxx

@@ -3,6 +3,7 @@
 #include "vtkHyperTreeGridGenerateFields.h"
 
 #include "vtkCellData.h"
+#include "vtkHyperTreeGridCellCenterStrategy.h"
 #include "vtkHyperTreeGridCellSizeStrategy.h"
 #include "vtkHyperTreeGridNonOrientedGeometryCursor.h"
 #include "vtkHyperTreeGridTotalVisibleVolumeStrategy.h"
@@ -32,6 +33,8 @@ vtkHTGGenerateFieldsGetFieldNameMacro(CellSize);
 vtkHTGGenerateFieldsSetFieldNameMacro(CellSize);
 vtkHTGGenerateFieldsGetFieldNameMacro(ValidCell);
 vtkHTGGenerateFieldsSetFieldNameMacro(ValidCell);
+vtkHTGGenerateFieldsGetFieldNameMacro(CellCenter);
+vtkHTGGenerateFieldsSetFieldNameMacro(CellCenter);
 vtkHTGGenerateFieldsGetFieldNameMacro(TotalVisibleVolume);
 vtkHTGGenerateFieldsSetFieldNameMacro(TotalVisibleVolume);
 
@@ -52,6 +55,12 @@ vtkHyperTreeGridGenerateFields::vtkHyperTreeGridGenerateFields()
   this->FieldsNameMap.emplace("ValidCell", this->DefaultValidCellArrayName);
   this->Fields.emplace("ValidCell", validCell);
 
+  vtkNew<vtkHyperTreeGridCellCenterStrategy> cellCenter;
+  cellCenter->SetArrayName(this->DefaultCellCenterArrayName);
+  cellCenter->SetArrayType(vtkDataObject::AttributeTypes::CELL);
+  this->FieldsNameMap.emplace("CellCenter", this->DefaultCellCenterArrayName);
+  this->Fields.emplace("CellCenter", cellCenter);
+
   // Field Data
 
   vtkNew<vtkHyperTreeGridTotalVisibleVolumeStrategy> totalVisibleVolume;

Filters/HyperTree/vtkHyperTreeGridGenerateFields.h

@@ -58,6 +58,15 @@ public:
   virtual void SetValidCellArrayName(std::string name);
   ///@}
 
+  ///@{
+  /**
+   * Get/Set the name used for the cell center array.
+   * Defaults to 'CellCenter'
+   */
+  virtual std::string GetCellCenterArrayName();
+  virtual void SetCellCenterArrayName(std::string name);
+  ///@}
+
   ///@{
   /**
    * Get/Set the name used for the total visible volume array.
@@ -96,6 +105,7 @@ private:
   // Cell Data
   std::string DefaultCellSizeArrayName = "CellSize";
   std::string DefaultValidCellArrayName = "ValidCell";
+  std::string DefaultCellCenterArrayName = "CellCenter";
 
   // Field Data
   std::string DefaultTotalVisibleVolumeArrayName = "TotalVisibleVolume";