vtkPointAccumulator.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkPointAccumulator_h
#define vtkPointAccumulator_h
 
#include "vtkPoints.h" // for vtkPoints
#include <exception>   // for std::bad_alloc
 
template <typename T_CPP, class T_VTK>
class vtkPointAccumulator
{
public:
  vtkPointAccumulator()
  {
    this->PtStore = nullptr;
    this->NPts = 0;
  }
  ~vtkPointAccumulator() { this->Clear(); }
 
  void Clear()
  {
    if (this->PtStore != nullptr)
    {
      free(this->PtStore);
    }
    this->PtStore = nullptr;
    this->NPts = 0;
  }
 
  bool Empty() { return this->NPts == 0; }
 
  T_CPP* Expand(vtkIdType n)
  {
    const int bytesPerPoint = 3 * sizeof(T_CPP);
    // extend
    vtkIdType newNPts = this->NPts + n;
    T_CPP* newPointStore = static_cast<T_CPP*>(realloc(this->PtStore, newNPts * bytesPerPoint));
    if (newPointStore == nullptr)
    {
#ifndef NDEBUG
      abort();
#else
      throw std::bad_alloc();
#endif
    }
    // mark begin of new
    T_CPP* writePointer = newPointStore + 3 * this->NPts;
    // update
    this->PtStore = newPointStore;
    this->NPts = newNPts;
 
    return writePointer;
  }
 
  void Accumulate(T_CPP* pts, vtkIdType n)
  {
    // extend
    T_CPP* writePointer = this->Expand(n);
    // copy at end
    const int bytesPerPoint = 3 * sizeof(T_CPP);
    memcpy(writePointer, pts, n * bytesPerPoint);
  }
 
  void Accumulate(T_VTK* pts) { this->Accumulate(pts->GetPointer(0), pts->GetNumberOfTuples()); }
 
  vtkPoints* BuildVtkPoints()
  {
    T_VTK* da = T_VTK::New();
    da->SetNumberOfComponents(3);
    da->SetArray(this->PtStore, 3 * this->NPts, 1);
    vtkPoints* pts = vtkPoints::New();
    pts->SetData(da);
    da->Delete();
 
    return pts;
  }
 
  void GetBounds(double bounds[6])
  {
    // Prepare
    for (int q = 0; q < 3; ++q)
    {
      bounds[q] = static_cast<double>(this->PtStore[q]);
      bounds[q + 1] = static_cast<double>(this->PtStore[q + 1]);
    }
    // Search
    for (vtkIdType i = 1; i < this->NPts; ++i)
    {
      double pt[3];
      vtkIdType ptIdx = 3 * i;
      pt[0] = static_cast<double>(this->PtStore[ptIdx]);
      pt[1] = static_cast<double>(this->PtStore[ptIdx + 1]);
      pt[2] = static_cast<double>(this->PtStore[ptIdx + 2]);
      if (pt[0] < bounds[0])
        bounds[0] = pt[0];
      if (pt[0] > bounds[1])
        bounds[1] = pt[0];
      if (pt[1] < bounds[2])
        bounds[2] = pt[1];
      if (pt[1] > bounds[3])
        bounds[3] = pt[1];
      if (pt[2] < bounds[4])
        bounds[4] = pt[2];
      if (pt[2] > bounds[5])
        bounds[5] = pt[2];
    }
  }
 
  vtkIdType GetNumberOfPoints() { return this->NPts; }
 
  void Print()
  {
    T_CPP* pBuf = this->PtStore;
    for (int i = 0; i < this->NPts; ++i)
    {
      cerr << i << " (" << pBuf[0];
      for (int q = 1; q < 3; ++q)
      {
        cerr << ", " << pBuf[q];
      }
      cerr << ")" << endl;
      pBuf += 3;
    }
  }
 
private:
  vtkPointAccumulator(const vtkPointAccumulator&) = delete;
  vtkPointAccumulator& operator=(const vtkPointAccumulator&) = delete;
 
  T_CPP* PtStore;
  vtkIdType NPts;
};
#endif