Add enable/disable arrays

Filters/HyperTree/vtkHyperTreeGridCellCenterStrategy.h

@@ -29,6 +29,7 @@ public:
   vtkTypeMacro(vtkHyperTreeGridCellCenterStrategy, vtkHyperTreeGridGenerateFieldStrategy);
   void PrintSelf(ostream& os, vtkIndent indent) override;
 
+  using vtkHyperTreeGridGenerateFieldStrategy::Initialize;
   /**
    * Init internal variables from `inputHTG`.
    */

Filters/HyperTree/vtkHyperTreeGridCellSizeStrategy.h

@@ -38,6 +38,7 @@ public:
   vtkTypeMacro(vtkHyperTreeGridCellSizeStrategy, vtkHyperTreeGridGenerateFieldStrategy);
   void PrintSelf(ostream& os, vtkIndent indent) override;
 
+  using vtkHyperTreeGridGenerateFieldStrategy::Initialize;
   /**
    * Init internal variables from `inputHTG`.
    */

Filters/HyperTree/vtkHyperTreeGridGenerateFieldStrategy.h

@@ -22,6 +22,15 @@ VTK_ABI_NAMESPACE_BEGIN
 class VTKFILTERSHYPERTREE_EXPORT vtkHyperTreeGridGenerateFieldStrategy : public vtkObject
 {
 public:
+  struct Field
+  {
+    std::string name;
+    vtkSmartPointer<vtkHyperTreeGridGenerateFieldStrategy> strategy;
+    bool enabled;      // Whether the user asked for this array to be computed.
+    bool valid = true; // Whether the array can be computed. Only make sense for Field Data (Cell
+                       // Data fields are always valid if enabled).
+  };
+
   vtkHyperTreeGridGenerateFieldStrategy() = default;
   vtkAbstractTypeMacro(vtkHyperTreeGridGenerateFieldStrategy, vtkObject);
   void PrintSelf(ostream& os, vtkIndent indent) override
@@ -36,8 +45,12 @@ public:
   ///@{
   /**
    * Reimplement to initialize internal structures based on the given input HTG.
+   * Only one of these methods should be reimplemented:
+   *  - If the strategy creates a cell data array, use `Initialize` with a void return type
+   *  - If the strategy creates a field data array, use `Initialize` with a bool return type
    */
-  virtual void Initialize(vtkHyperTreeGrid* inputHTG) = 0;
+  virtual void Initialize(vtkHyperTreeGrid* vtkMaybeUnused(inputHTG)) {}
+  virtual bool Initialize(std::unordered_map<std::string, Field>) { return true; }
   ///@}
 
   ///@{
@@ -50,7 +63,7 @@ public:
    */
   virtual void Compute(vtkHyperTreeGridNonOrientedGeometryCursor*) {}
   virtual void Compute(vtkHyperTreeGridNonOrientedGeometryCursor*, vtkCellData*,
-    std::unordered_map<std::string, std::string>)
+    std::unordered_map<std::string, Field>)
   {
   }
   ///@}

Filters/HyperTree/vtkHyperTreeGridGenerateFields.cxx

@@ -9,19 +9,29 @@
 #include "vtkHyperTreeGridTotalVisibleVolumeStrategy.h"
 #include "vtkHyperTreeGridValidCellStrategy.h"
 
-#define vtkHTGGenerateFieldsGetFieldNameMacro(name)                                                \
-  std::string vtkHyperTreeGridGenerateFields::Get##name##ArrayName() VTK_FUTURE_CONST              \
+#define fieldMacros(Name)                                                                          \
+  std::string vtkHyperTreeGridGenerateFields::Get##Name##ArrayName() VTK_FUTURE_CONST              \
   {                                                                                                \
-    return this->Fields[#name]->GetArrayName();                                                    \
-  }
-
-#define vtkHTGGenerateFieldsSetFieldNameMacro(name)                                                \
-  void vtkHyperTreeGridGenerateFields::Set##name##ArrayName(std::string _arg)                      \
+    return this->Fields[#Name].strategy->GetArrayName();                                           \
+  }                                                                                                \
+  void vtkHyperTreeGridGenerateFields::Set##Name##ArrayName(std::string _arg)                      \
+  {                                                                                                \
+    if (this->Fields[#Name].strategy->GetArrayName() != _arg)                                      \
+    {                                                                                              \
+      this->Fields[#Name].name = _arg;                                                             \
+      this->Fields[#Name].strategy->SetArrayName(_arg);                                            \
+      this->Modified();                                                                            \
+    }                                                                                              \
+  }                                                                                                \
+  bool vtkHyperTreeGridGenerateFields::GetCompute##Name##Array() VTK_FUTURE_CONST                  \
+  {                                                                                                \
+    return this->Fields[#Name].enabled;                                                            \
+  }                                                                                                \
+  void vtkHyperTreeGridGenerateFields::SetCompute##Name##Array(bool _arg)                          \
   {                                                                                                \
-    if (this->Fields[#name]->GetArrayName() != _arg)                                               \
+    if (this->Fields[#Name].enabled != _arg)                                                       \
     {                                                                                              \
-      this->Fields[#name]->SetArrayName(_arg);                                                     \
-      this->FieldsNameMap[#name] = _arg;                                                           \
+      this->Fields[#Name].enabled = _arg;                                                          \
       this->Modified();                                                                            \
     }                                                                                              \
   }
@@ -29,14 +39,10 @@
 VTK_ABI_NAMESPACE_BEGIN
 vtkStandardNewMacro(vtkHyperTreeGridGenerateFields);
 
-vtkHTGGenerateFieldsGetFieldNameMacro(CellSize);
-vtkHTGGenerateFieldsSetFieldNameMacro(CellSize);
-vtkHTGGenerateFieldsGetFieldNameMacro(ValidCell);
-vtkHTGGenerateFieldsSetFieldNameMacro(ValidCell);
-vtkHTGGenerateFieldsGetFieldNameMacro(CellCenter);
-vtkHTGGenerateFieldsSetFieldNameMacro(CellCenter);
-vtkHTGGenerateFieldsGetFieldNameMacro(TotalVisibleVolume);
-vtkHTGGenerateFieldsSetFieldNameMacro(TotalVisibleVolume);
+fieldMacros(CellSize);
+fieldMacros(ValidCell);
+fieldMacros(CellCenter);
+fieldMacros(TotalVisibleVolume);
 
 //------------------------------------------------------------------------------
 vtkHyperTreeGridGenerateFields::vtkHyperTreeGridGenerateFields()
@@ -46,28 +52,25 @@ vtkHyperTreeGridGenerateFields::vtkHyperTreeGridGenerateFields()
   vtkNew<vtkHyperTreeGridCellSizeStrategy> cellSize;
   cellSize->SetArrayName(this->DefaultCellSizeArrayName);
   cellSize->SetArrayType(vtkDataObject::AttributeTypes::CELL);
-  this->FieldsNameMap.emplace("CellSize", this->DefaultCellSizeArrayName);
-  this->Fields.emplace("CellSize", cellSize);
+  this->Fields["CellSize"] = { this->DefaultCellSizeArrayName, cellSize, true };
 
   vtkNew<vtkHyperTreeGridValidCellStrategy> validCell;
   validCell->SetArrayName(this->DefaultValidCellArrayName);
   validCell->SetArrayType(vtkDataObject::AttributeTypes::CELL);
-  this->FieldsNameMap.emplace("ValidCell", this->DefaultValidCellArrayName);
-  this->Fields.emplace("ValidCell", validCell);
+  this->Fields["ValidCell"] = { this->DefaultValidCellArrayName, validCell, true };
 
   vtkNew<vtkHyperTreeGridCellCenterStrategy> cellCenter;
   cellCenter->SetArrayName(this->DefaultCellCenterArrayName);
   cellCenter->SetArrayType(vtkDataObject::AttributeTypes::CELL);
-  this->FieldsNameMap.emplace("CellCenter", this->DefaultCellCenterArrayName);
-  this->Fields.emplace("CellCenter", cellCenter);
+  this->Fields["CellCenter"] = { this->DefaultCellCenterArrayName, cellCenter, true };
 
   // Field Data
 
   vtkNew<vtkHyperTreeGridTotalVisibleVolumeStrategy> totalVisibleVolume;
   totalVisibleVolume->SetArrayName(this->DefaultTotalVisibleVolumeArrayName);
   totalVisibleVolume->SetArrayType(vtkDataObject::AttributeTypes::FIELD);
-  this->FieldsNameMap.emplace("TotalVisibleVolume", this->DefaultTotalVisibleVolumeArrayName);
-  this->Fields.emplace("TotalVisibleVolume", totalVisibleVolume);
+  this->Fields["TotalVisibleVolume"] = { this->DefaultTotalVisibleVolumeArrayName,
+    totalVisibleVolume, true };
 
   this->AppropriateOutput = true;
 };
@@ -78,10 +81,13 @@ void vtkHyperTreeGridGenerateFields::PrintSelf(ostream& os, vtkIndent indent)
   this->Superclass::PrintSelf(os, indent);
   os << indent << "Fields:"
      << "\n";
-  for (const auto& field : this->Fields)
+  for (const auto& [key, field] : this->Fields)
   {
-    os << indent << field.first << "\n";
-    field.second->PrintSelf(os, indent.GetNextIndent());
+    os << indent << key << "\n";
+    indent = indent.GetNextIndent();
+    os << indent << "Enabled: " << field.enabled << "\n";
+    os << indent << "Valid: " << field.valid << "\n";
+    field.strategy->PrintSelf(os, indent.GetNextIndent());
   }
 }
 
@@ -89,11 +95,20 @@ void vtkHyperTreeGridGenerateFields::PrintSelf(ostream& os, vtkIndent indent)
 void vtkHyperTreeGridGenerateFields::ProcessFields(
   vtkHyperTreeGrid* outputHTG, vtkHyperTreeGrid* input, const vtkDataObject::AttributeTypes type)
 {
-  for (const auto& field : this->Fields)
+  for (auto& [key, field] : this->Fields)
   {
-    if (field.second->GetArrayType() == type)
+    field.valid = false;
+    if (field.enabled && field.strategy->GetArrayType() == type)
     {
-      field.second->Initialize(input);
+      if (type == vtkDataObject::AttributeTypes::CELL)
+      {
+        field.strategy->Initialize(input);
+        field.valid = true;
+      }
+      else if (type == vtkDataObject::AttributeTypes::FIELD)
+      {
+        field.valid = field.strategy->Initialize(this->Fields);
+      }
     }
   }
 
@@ -113,11 +128,11 @@ void vtkHyperTreeGridGenerateFields::ProcessFields(
   }
 
   // Append all field arrays to the output
-  for (const auto& field : this->Fields)
+  for (const auto& [key, field] : this->Fields)
   {
-    if (field.second->GetArrayType() == type)
+    if (field.valid && field.strategy->GetArrayType() == type)
     {
-      vtkDataArray* resultArray = field.second->GetAndFinalizeArray();
+      vtkDataArray* resultArray = field.strategy->GetAndFinalizeArray();
       if (type == vtkDataObject::AttributeTypes::CELL)
       {
         outputHTG->GetCellData()->AddArray(resultArray);
@@ -155,17 +170,17 @@ int vtkHyperTreeGridGenerateFields::ProcessTrees(vtkHyperTreeGrid* input, vtkDat
 void vtkHyperTreeGridGenerateFields::ProcessNode(vtkHyperTreeGridNonOrientedGeometryCursor* cursor,
   const vtkDataObject::AttributeTypes type, vtkCellData* outputCellData)
 {
-  for (const auto& field : this->Fields)
+  for (const auto& [key, field] : this->Fields)
   {
-    if (field.second->GetArrayType() == type)
+    if (field.valid && field.strategy->GetArrayType() == type)
     {
       if (type == vtkDataObject::AttributeTypes::CELL)
       {
-        field.second->Compute(cursor);
+        field.strategy->Compute(cursor);
       }
       else if (type == vtkDataObject::AttributeTypes::FIELD)
       {
-        field.second->Compute(cursor, outputCellData, this->FieldsNameMap);
+        field.strategy->Compute(cursor, outputCellData, this->Fields);
       }
     }
   }

Filters/HyperTree/vtkHyperTreeGridGenerateFields.h

@@ -40,6 +40,16 @@ public:
   vtkTypeMacro(vtkHyperTreeGridGenerateFields, vtkHyperTreeGridAlgorithm);
   void PrintSelf(ostream& os, vtkIndent indent) override;
 
+  ///@{
+  /**
+   * Enable/disable the computation of the CellSize array.
+   * Default is true.
+   */
+  virtual bool GetComputeCellSizeArray();
+  virtual void SetComputeCellSizeArray(bool enable);
+  vtkBooleanMacro(ComputeCellSizeArray, bool);
+  ///@}
+
   ///@{
   /**
    * Get/Set the name used for the cell size array.
@@ -49,6 +59,16 @@ public:
   virtual void SetCellSizeArrayName(std::string name);
   ///@}
 
+  ///@{
+  /**
+   * Enable/disable the computation of the ValidCell array.
+   * Default is true.
+   */
+  virtual bool GetComputeValidCellArray();
+  virtual void SetComputeValidCellArray(bool enable);
+  vtkBooleanMacro(ComputeValidCellArray, bool);
+  ///@}
+
   ///@{
   /**
    * Get/Set the name used for the cell validity array.
@@ -58,6 +78,16 @@ public:
   virtual void SetValidCellArrayName(std::string name);
   ///@}
 
+  ///@{
+  /**
+   * Enable/disable the computation of the CellCenter array.
+   * Default is true.
+   */
+  virtual bool GetComputeCellCenterArray();
+  virtual void SetComputeCellCenterArray(bool enable);
+  vtkBooleanMacro(ComputeCellCenterArray, bool);
+  ///@}
+
   ///@{
   /**
    * Get/Set the name used for the cell center array.
@@ -67,6 +97,16 @@ public:
   virtual void SetCellCenterArrayName(std::string name);
   ///@}
 
+  ///@{
+  /**
+   * Enable/disable the computation of the TotalVisibleVolume array.
+   * Default is true.
+   */
+  virtual bool GetComputeTotalVisibleVolumeArray();
+  virtual void SetComputeTotalVisibleVolumeArray(bool enable);
+  vtkBooleanMacro(ComputeTotalVisibleVolumeArray, bool);
+  ///@}
+
   ///@{
   /**
    * Get/Set the name used for the total visible volume array.
@@ -110,8 +150,7 @@ private:
   // Field Data
   std::string DefaultTotalVisibleVolumeArrayName = "TotalVisibleVolume";
 
-  std::unordered_map<std::string, vtkSmartPointer<vtkHyperTreeGridGenerateFieldStrategy>> Fields;
-  std::unordered_map<std::string, std::string> FieldsNameMap;
+  std::unordered_map<std::string, vtkHyperTreeGridGenerateFieldStrategy::Field> Fields;
 };
 
 VTK_ABI_NAMESPACE_END

Filters/HyperTree/vtkHyperTreeGridTotalVisibleVolumeStrategy.cxx

@@ -29,21 +29,30 @@ void vtkHyperTreeGridTotalVisibleVolumeStrategy::PrintSelf(ostream& os, vtkInden
 }
 
 //------------------------------------------------------------------------------
-void vtkHyperTreeGridTotalVisibleVolumeStrategy::Initialize(vtkHyperTreeGrid* vtkNotUsed(inputHTG))
+bool vtkHyperTreeGridTotalVisibleVolumeStrategy::Initialize(
+  std::unordered_map<std::string, Field> fieldMap)
 {
+  if (!fieldMap["ValidCell"].enabled || !fieldMap["CellSize"].enabled)
+  {
+    vtkWarningMacro("ValidCell and CellSize arrays must be enabled to compute TotalVisibleVolume");
+    return false;
+  }
+
   this->TotalVisibleVolume = 0;
   this->TotalVisibleVolumeArray->SetNumberOfComponents(1);
   this->TotalVisibleVolumeArray->SetNumberOfTuples(1);
   this->TotalVisibleVolumeArray->SetName(this->ArrayName.c_str());
+
+  return true;
 }
 
 //------------------------------------------------------------------------------
 void vtkHyperTreeGridTotalVisibleVolumeStrategy::Compute(
   vtkHyperTreeGridNonOrientedGeometryCursor* cursor, vtkCellData* cellData,
-  std::unordered_map<std::string, std::string> nameMap)
+  std::unordered_map<std::string, Field> fieldMap)
 {
-  vtkAbstractArray* validCellArray = cellData->GetAbstractArray(nameMap["ValidCell"].c_str());
-  vtkAbstractArray* cellSizeArray = cellData->GetAbstractArray(nameMap["CellSize"].c_str());
+  vtkAbstractArray* validCellArray = cellData->GetAbstractArray(fieldMap["ValidCell"].name.c_str());
+  vtkAbstractArray* cellSizeArray = cellData->GetAbstractArray(fieldMap["CellSize"].name.c_str());
 
   if (!validCellArray || !cellSizeArray)
   {

Filters/HyperTree/vtkHyperTreeGridTotalVisibleVolumeStrategy.h

@@ -34,10 +34,11 @@ public:
   vtkTypeMacro(vtkHyperTreeGridTotalVisibleVolumeStrategy, vtkHyperTreeGridGenerateFieldStrategy);
   void PrintSelf(ostream& os, vtkIndent indent) override;
 
+  using vtkHyperTreeGridGenerateFieldStrategy::Initialize;
   /**
    * Init internal variables from `inputHTG`.
    */
-  void Initialize(vtkHyperTreeGrid* inputHTG) override;
+  bool Initialize(std::unordered_map<std::string, Field> fieldMap) override;
 
   using vtkHyperTreeGridGenerateFieldStrategy::Compute;
   /**
@@ -45,7 +46,7 @@ public:
    * `cellData` to check if the current cell is visible and get its volume.
    */
   void Compute(vtkHyperTreeGridNonOrientedGeometryCursor* cursor, vtkCellData* cellData,
-    std::unordered_map<std::string, std::string> nameMap) override;
+    std::unordered_map<std::string, Field> fieldMap) override;
 
   /**
    * Set a unique tuple of `TotalVisibleVolumeArray` to `TotalVisibleVolume` and return the array.

Filters/HyperTree/vtkHyperTreeGridValidCellStrategy.h

@@ -31,6 +31,7 @@ public:
   vtkTypeMacro(vtkHyperTreeGridValidCellStrategy, vtkHyperTreeGridGenerateFieldStrategy);
   void PrintSelf(ostream& os, vtkIndent indent) override;
 
+  using vtkHyperTreeGridGenerateFieldStrategy::Initialize;
   /**
    * Init internal variables from `inputHTG`.
    */