vtkCutter: use vtk3DLinearGridPlaneCutter when possible

For vtkUnstructuredGrid inputs with linear cells, the
vtk3DLinearGridPlaneCutter offers a potentially significant
performance boost. Incorporate that into vtkCutter and use it when
possible.

Add static function to vtk3DLinearGridPlaneCutter to check whether a
data object can be fully processed by the filter, i.e., when the
dataset consists of 3D linear cells.

One test baseline was modified to accomodate the change in cell
subdivision (there was no change in slice surface output).

Filters/Core/vtk3DLinearGridPlaneCutter.cxx

@@ -1529,6 +1529,52 @@ int vtk3DLinearGridPlaneCutter::GetOutputPointsPrecision() const
   return this->OutputPointsPrecision;
 }
 
+//-----------------------------------------------------------------------------
+bool vtk3DLinearGridPlaneCutter::CanFullyProcessDataObject(vtkDataObject* object)
+{
+  auto ug = vtkUnstructuredGrid::SafeDownCast(object);
+  auto cd = vtkCompositeDataSet::SafeDownCast(object);
+
+  if (ug)
+  {
+    // Get list of cell types in the unstructured grid
+    vtkNew<vtkCellTypes> cellTypes;
+    ug->GetCellTypes(cellTypes);
+    for (vtkIdType i = 0; i < cellTypes->GetNumberOfTypes(); ++i)
+    {
+      unsigned char cellType = cellTypes->GetCellType(i);
+      if (cellType != VTK_VOXEL && cellType != VTK_TETRA && cellType != VTK_HEXAHEDRON &&
+          cellType != VTK_WEDGE && cellType != VTK_PYRAMID)
+      {
+        // Unsupported cell type, can't process data
+        return false;
+      }
+    }
+
+    // All cell types are supported, can process data.
+    return true;
+  }
+  else if (cd)
+  {
+    bool supported = true;
+    vtkSmartPointer<vtkCompositeDataIterator> iter;
+    iter.TakeReference(cd->NewIterator());
+    iter->SkipEmptyNodesOn();
+    for (iter->InitTraversal(); !iter->IsDoneWithTraversal(); iter->GoToNextItem())
+    {
+      auto leafDS = iter->GetCurrentDataObject();
+      if (!CanFullyProcessDataObject(leafDS))
+      {
+        supported = false;
+        break;
+      }
+    }
+    return supported;
+  }
+
+  return false; // not a vtkUnstructuredGrid nor a composite dataset
+}
+
 //-----------------------------------------------------------------------------
 int vtk3DLinearGridPlaneCutter::FillInputPortInformation(int, vtkInformation *info)
 {

Filters/Core/vtk3DLinearGridPlaneCutter.h

@@ -184,6 +184,14 @@ public:
   bool GetLargeIds()
   {return this->LargeIds;}
 
+  /**
+   * Returns true if the data object passed in is fully supported by this
+   * filter, i.e., all cell types are linear. For composite datasets, this
+   * means all dataset leaves have only linear cell types that can be processed
+   * by this filter.
+   */
+  static bool CanFullyProcessDataObject(vtkDataObject* object);
+
 protected:
   vtk3DLinearGridPlaneCutter();
   ~vtk3DLinearGridPlaneCutter() override;

Filters/Core/vtkCutter.cxx

@@ -14,6 +14,7 @@
 =========================================================================*/
 #include "vtkCutter.h"
 
+#include "vtk3DLinearGridPlaneCutter.h"
 #include "vtkArrayDispatch.h"
 #include "vtkAssume.h"
 #include "vtkCellArray.h"
@@ -23,6 +24,7 @@
 #include "vtkDataArrayAccessor.h"
 #include "vtkDataSet.h"
 #include "vtkDoubleArray.h"
+#include "vtkEventForwarderCommand.h"
 #include "vtkFloatArray.h"
 #include "vtkGenericCell.h"
 #include "vtkGridSynchronizedTemplates3D.h"
@@ -389,6 +391,44 @@ int vtkCutter::RequestData(
   else if (input->GetDataObjectType() == VTK_UNSTRUCTURED_GRID_BASE ||
            input->GetDataObjectType() == VTK_UNSTRUCTURED_GRID)
   {
+    // See if the input can be fully processed by the fast vtk3DLinearGridPlaneCutter.
+    // This algorithm can provide a substantial speed improvement over the more general
+    // algorithm for vtkUnstructuredGrids.
+    if (this->GetCutFunction() && this->GetCutFunction()->IsA("vtkPlane") &&
+      this->GetNumberOfContours() == 1 &&
+      this->GetGenerateCutScalars() == 0 &&
+      (input->GetCellData() && input->GetCellData()->GetNumberOfArrays() == 0) &&
+      vtk3DLinearGridPlaneCutter::CanFullyProcessDataObject(input))
+    {
+      vtkNew<vtk3DLinearGridPlaneCutter> linear3DCutter;
+
+      // Create a copy of vtkPlane and nudge it by the single contour
+      vtkPlane* plane = vtkPlane::SafeDownCast(this->GetCutFunction());
+      vtkNew<vtkPlane> newPlane;
+      newPlane->SetNormal(plane->GetNormal());
+      newPlane->SetOrigin(plane->GetOrigin());
+
+      // Evaluate the distance the origin is from the original plane. This accomodates
+      // subclasses of vtkPlane that may have an additional offset parameter not
+      // accessible through the vtkPlane interface. Use this distance to adjust the origin
+      // in newPlane.
+      double d = plane->EvaluateFunction(plane->GetOrigin());
+
+      // In addition. We'll need to shift by the contour value.
+      newPlane->Push(-d + this->GetValue(0));
+
+      linear3DCutter->SetPlane(newPlane);
+      linear3DCutter->SetOutputPointsPrecision(this->GetOutputPointsPrecision());
+      linear3DCutter->SetInputArrayToProcess(0, this->GetInputArrayInformation(0));
+      vtkNew<vtkEventForwarderCommand> progressForwarder;
+      progressForwarder->SetTarget(this);
+      linear3DCutter->AddObserver(vtkCommand::ProgressEvent, progressForwarder);
+
+      int retval = linear3DCutter->ProcessRequest(request, inputVector, outputVector);
+
+      return retval;
+    }
+
     vtkDebugMacro(<< "Executing Unstructured Grid Cutter");
     this->UnstructuredGridCutter(input, output);
   }

Filters/HyperTree/Testing/Data/Baseline/TestHyperTreeGridTernary3DPlaneCutterDual.png.sha512

-46a598a0787416a4d4cee34bb065876e587208b3bc2ae6eed28c4727e21a7c6150f13444d91c4b1bbb5bd73b13dccc5b6b8fd5ed3e4ec86e0f4a3a5757a6980b
+6987d3fb19b67dabd42b95c038baa2cde43e4c17e8e7e227ea58866062d8bf97eb3543a2eaf332d675c27a8a8b8febed0eaa7adffd1d81e6f8a06a97c5e470e2