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
#ifdef NDEBUG
#include <exception> // for std::bad_alloc
#endif
#include <iostream> // for std::cerr

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]);
      bounds[0] = std::min(bounds[0], pt[0]);
      bounds[1] = std::max(bounds[1], pt[0]);
      bounds[2] = std::min(bounds[2], pt[1]);
      bounds[3] = std::max(bounds[3], pt[1]);
      bounds[4] = std::min(bounds[4], pt[2]);
      bounds[5] = std::max(bounds[5], pt[2]);
    }
  }

  vtkIdType GetNumberOfPoints() { return this->NPts; }

  void Print()
  {
    T_CPP* pBuf = this->PtStore;
    for (int i = 0; i < this->NPts; ++i)
    {
      std::cerr << i << " (" << pBuf[0];
      for (int q = 1; q < 3; ++q)
      {
        std::cerr << ", " << pBuf[q];
      }
      std::cerr << ")" << endl;
      pBuf += 3;
    }
  }

private:
  vtkPointAccumulator(const vtkPointAccumulator&) = delete;
  vtkPointAccumulator& operator=(const vtkPointAccumulator&) = delete;

  T_CPP* PtStore;
  vtkIdType NPts;
};
#endif