Improved vtkCellDataToPointData for vtkUnstructuredGrid datasets.

vtkCellDataToPointData creates cell links when it traverses the datasets
which is an expensive operation for vtkUnstructuredGrid datasets. The
improved vtkCellDataToPointData behaves identically for all other types
of datasets as befores with the only differences working with
vtkUnstructuredGrid.  For a vtkUnstructuredGrid, it traverses the cell
array directly and keeps two auxiliary arrays holding the accumulated
quantity in question and the number of cells sharing each point. After
the traverse is done, it dose an extra division pass to get the average
of the tracked quantity which returns exact the same results as before.

Author: Meng ZHU

Graphics/vtkCellDataToPointData.cxx

@@ -15,12 +15,17 @@
 #include "vtkCellDataToPointData.h"
 
 #include "vtkCellData.h"
+#include "vtkCell.h"
 #include "vtkDataSet.h"
 #include "vtkIdList.h"
 #include "vtkInformation.h"
 #include "vtkInformationVector.h"
+#include "vtkUnstructuredGrid.h"
+#include "vtkSmartPointer.h"
+#include "vtkUnsignedIntArray.h"
 #include "vtkObjectFactory.h"
 #include "vtkPointData.h"
+#include <algorithm>
 
 vtkStandardNewMacro(vtkCellDataToPointData);
 
@@ -47,6 +52,14 @@ int vtkCellDataToPointData::RequestData(
   vtkDataSet *input = vtkDataSet::SafeDownCast(
     inInfo->Get(vtkDataObject::DATA_OBJECT()));
 
+  vtkDebugMacro(<<"Mapping cell data to point data");
+
+  // Special traversal algorithm for unstructured grid
+  if (input->IsA("vtkUnstructuredGrid"))
+    {
+    return this->RequestDataForUnstructuredGrid(0, inputVector, outputVector);
+    }
+
   vtkIdType cellId, ptId;
   vtkIdType numCells, numPts;
   vtkCellData *inPD=input->GetCellData();
@@ -129,3 +142,162 @@ void vtkCellDataToPointData::PrintSelf(ostream& os, vtkIndent indent)
 
   os << indent << "Pass Cell Data: " << (this->PassCellData ? "On\n" : "Off\n");
 }
+
+//----------------------------------------------------------------------------
+// Helper template function that implement the major part of the algorighm
+// which will be expanded by the vtkTemplateMacro. The template function is
+// provided so that coverage test can cover this function.
+namespace
+{
+  template <typename T>
+  void __spread (vtkUnstructuredGrid* const src, vtkUnsignedIntArray* const num,
+             vtkDataArray* const srcarray, vtkDataArray* const dstarray,
+             vtkIdType ncells, vtkIdType npoints, vtkIdType ncomps)
+  {
+    T const* const srcptr = static_cast<T const*>(srcarray->GetVoidPointer(0));
+    T      * const dstptr = static_cast<T      *>(dstarray->GetVoidPointer(0));
+
+    // zero initialization
+    vtkstd::fill_n(dstptr, npoints*ncomps, T(0));
+
+    // accumulate
+    T const* srcbeg = srcptr;
+    for (vtkIdType cid = 0; cid < ncells; ++cid, srcbeg += ncomps)
+      {
+      vtkIdList* const pids = src->GetCell(cid)->GetPointIds();
+      for (vtkIdType i = 0, I = pids->GetNumberOfIds(); i < I; ++i)
+        {
+        T* const dstbeg = dstptr + pids->GetId(i)*ncomps;
+        // accumulate cell data to point data <==> point_data += cell_data
+        vtkstd::transform(srcbeg,srcbeg+ncomps,dstbeg,dstbeg,vtkstd::plus<T>());
+        }
+      }
+
+    // average
+    T* dstbeg = dstptr;
+    for (vtkIdType pid = 0; pid < npoints; ++pid, dstbeg += ncomps)
+      {
+      // guard against divide by zero
+      if (unsigned int const denum = num->GetValue(pid))
+        { 
+        // divide point data by the number of cells using it <==>
+        // point_data /= denum
+        vtkstd::transform(dstbeg, dstbeg+ncomps, dstbeg,
+          vtkstd::bind2nd(vtkstd::divides<T>(), denum));
+        }
+      }
+  }
+}
+
+//----------------------------------------------------------------------------
+int vtkCellDataToPointData::RequestDataForUnstructuredGrid
+  (vtkInformation*,
+   vtkInformationVector** inputVector,
+   vtkInformationVector* outputVector)
+{
+  vtkUnstructuredGrid* const src = vtkUnstructuredGrid::SafeDownCast(
+    inputVector[0]->GetInformationObject(0)->Get(vtkDataObject::DATA_OBJECT()));
+  vtkUnstructuredGrid* const dst = vtkUnstructuredGrid::SafeDownCast(
+    outputVector->GetInformationObject(0)->Get(vtkDataObject::DATA_OBJECT()));
+
+  vtkIdType const ncells  = src->GetNumberOfCells ();
+  vtkIdType const npoints = src->GetNumberOfPoints();
+  if (ncells < 1 || npoints < 1)
+    {
+    vtkDebugMacro(<<"No input data!");
+    return 1;
+    }
+
+  // count the number of cells associated with each point
+  vtkSmartPointer<vtkUnsignedIntArray> num
+    = vtkSmartPointer<vtkUnsignedIntArray>::New();
+  num->SetNumberOfComponents(1);
+  num->SetNumberOfTuples(npoints);
+  vtkstd::fill_n(num->GetPointer(0), npoints, 0u);
+  for (vtkIdType cid = 0; cid < ncells; ++cid)
+    {
+    vtkIdList* const pids = src->GetCell(cid)->GetPointIds();
+    for (vtkIdType i = 0, I = pids->GetNumberOfIds(); i < I; ++i)
+      {
+      vtkIdType const pid = pids->GetId(i);
+      num->SetValue(pid, num->GetValue(pid)+1);
+      }
+    }
+
+  // First, copy the input to the output as a starting point
+  dst->CopyStructure(src);
+  vtkPointData* const opd = dst->GetPointData();
+
+  // Pass the point data first. The fields and attributes
+  // which also exist in the cell data of the input will
+  // be over-written during CopyAllocate
+  opd->CopyGlobalIdsOff();
+  opd->PassData(src->GetPointData());
+  opd->CopyFieldOff("vtkGhostLevels");
+
+  // Copy all existing cell fields into a temporary cell data array
+  vtkSmartPointer<vtkCellData> clean = vtkSmartPointer<vtkCellData>::New();
+  clean->PassData(src->GetCellData());
+
+  // Remove all fields that are not a data array.
+  for (vtkIdType fid = clean->GetNumberOfArrays(); fid--;)
+    {
+    if (!clean->GetAbstractArray(fid)->IsA("vtkDataArray"))
+      {
+      clean->RemoveArray(fid);
+      }
+    }
+
+  // Cell field list constructed from the filtered cell data array
+  vtkDataSetAttributes::FieldList cfl(1);
+  cfl.InitializeFieldList(clean);
+  opd->InterpolateAllocate(cfl, npoints, npoints);
+
+  for (int fid = 0, nfields = cfl.GetNumberOfFields(); fid < nfields; ++fid)
+    {
+    // update progress and check for an abort request.
+    this->UpdateProgress((fid+1.)/nfields);
+    if (this->GetAbortExecute())
+      {
+      break;
+      }
+
+    // indices into the field arrays associated with the cell and the point
+    // respectively
+    int const srcid = cfl.GetFieldIndex(fid);
+    int const dstid = cfl.GetDSAIndex(0,fid);
+    if  (srcid < 0 || dstid < 0)
+      {
+      continue;
+      }
+
+    vtkCellData * const srccelldata  = src->GetCellData ();
+    vtkPointData* const dstpointdata = dst->GetPointData();
+
+    if (!srccelldata || !dstpointdata)
+      {
+      continue;
+      }
+
+    vtkDataArray* const srcarray = srccelldata ->GetArray(srcid);
+    vtkDataArray* const dstarray = dstpointdata->GetArray(dstid);
+    dstarray->SetNumberOfTuples(npoints);
+
+    vtkIdType const ncomps = srcarray->GetNumberOfComponents();
+    switch (srcarray->GetDataType())
+      {
+      vtkTemplateMacro
+        (__spread<VTK_TT>(src,num,srcarray,dstarray,ncells,npoints,ncomps));
+      }
+    }
+
+  if (!this->PassCellData)
+    {
+    dst->GetCellData()->CopyAllOff();
+    dst->GetCellData()->CopyFieldOn("vtkGhostLevels");
+    }
+  dst->GetCellData()->PassData(src->GetCellData());
+
+  return 1;
+}
+

Graphics/vtkCellDataToPointData.h

@@ -60,6 +60,10 @@ class VTK_GRAPHICS_EXPORT vtkCellDataToPointData : public vtkDataSetAlgorithm
                           vtkInformationVector** inputVector,
                           vtkInformationVector* outputVector);
 
+  // Special traversal algorithm for unstructured grid
+  int RequestDataForUnstructuredGrid
+    (vtkInformation*, vtkInformationVector**, vtkInformationVector*);
+
   int PassCellData;
 private:
   vtkCellDataToPointData(const vtkCellDataToPointData&);  // Not implemented.