vtkStaticElementLocator.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkStaticElementLocator_h
#define vtkStaticElementLocator_h
 
#include "vtkABINamespace.h"
#include "vtkKeys.h" // For the scatter of the elements by key
#include "vtkType.h" // For vtkIdType
 
#include <type_traits> // For std::is_void_v
#include <utility>     // For std::forward, std::swap
 
VTK_ABI_NAMESPACE_BEGIN
 
template <typename TID, typename TElement>
class vtkStaticElementLocator
{
public:
  using IDType = TID;
  using ElementType = TElement;
  // The keys of the elements, whose number is not bounded by IDType.
  using KeysType = vtk::keys::DenseArrayKeys<ElementType, vtkIdType>;

  using GroupedElements = vtk::keys::GroupedElements<KeysType>;

  vtkStaticElementLocator() = default;
  ~vtkStaticElementLocator() = default;

  vtkStaticElementLocator(vtkStaticElementLocator&&) = default;
  vtkStaticElementLocator& operator=(vtkStaticElementLocator&&) = default;

  vtkIdType BuildLocator(vtkIdType numElements, ElementType* elementArray);

  IDType IsInsertedElement(const ElementType& query) const;

  template <typename Arg0, typename Arg1, typename... Args>
  IDType IsInsertedElement(Arg0&& arg0, Arg1&& arg1, Args&&... args) const
  {
    return this->IsInsertedElement(
      ElementType(std::forward<Arg0>(arg0), std::forward<Arg1>(arg1), std::forward<Args>(args)...));
  }

  IDType GetNumberOfElements() const { return this->NumElements; }

  const ElementType& GetElement(IDType i) const { return this->ElementArray[i]; }

  const GroupedElements& GroupElements(vtkIdType numElements, ElementType* elementArray);
 
protected:
  IDType NumElements = 0;
  ElementType* ElementArray = nullptr; // Non-owning pointer to external memory
  // The search index of BuildLocator(): the unique elements of key id k are
  // [GetOffset(k), GetOffset(k + 1)) of ElementArray.
  vtk::keys::ReducedKeys<KeysType> Index;
  // The groups of equal elements of GroupElements().
  GroupedElements Groups;
 
private:
  vtkStaticElementLocator(const vtkStaticElementLocator&) = delete;
  void operator=(const vtkStaticElementLocator&) = delete;
};
 
// ============================================================================
// Common Elements
// ============================================================================

template <typename TData>
struct vtkTupleData
{
  TData Data;
};
template <>
struct vtkTupleData<void>
{
};

template <typename TId, typename TED = void>
struct EdgeTuple : vtkTupleData<TED>
{
  TId V0;
  TId V1;
 
  EdgeTuple() = default;
 
  // Construct an edge with its data.
  template <typename D = TED, typename = std::enable_if_t<!std::is_void_v<D>>>
  EdgeTuple(TId v0, TId v1, const std::common_type_t<D>& data)
    : vtkTupleData<TED>{ data }
    , V0(v0)
    , V1(v1)
  {
    if (this->V0 > this->V1)
    {
      std::swap(this->V0, this->V1);
    }
  }
 
  // Construct an edge without data, e.g., a query.
  EdgeTuple(TId v0, TId v1)
    : vtkTupleData<TED>()
    , V0(v0)
    , V1(v1)
  {
    if (this->V0 > this->V1)
    {
      std::swap(this->V0, this->V1);
    }
  }
 
  // The key of the element: required by vtkStaticElementLocator, see the Element concept of
  // vtkKeys.h.
  TId GetKey() const { return this->V0; }
 
  // Set the points of the edge, ordered.
  void Define(TId v0, TId v1)
  {
    if (v0 < v1)
    {
      this->V0 = v0;
      this->V1 = v1;
    }
    else
    {
      this->V0 = v1;
      this->V1 = v0;
    }
  }
 
  bool operator==(const EdgeTuple& et) const { return this->V0 == et.V0 && this->V1 == et.V1; }
  bool operator!=(const EdgeTuple& et) const { return !(*this == et); }
 
  // Whether the points of the edge are v0 and v1, in any order.
  bool IsEdge(TId v0, TId v1) const
  {
    return v0 < v1 ? this->V0 == v0 && this->V1 == v1 : this->V0 == v1 && this->V1 == v0;
  }
 
  // Sort on V0 first, then V1.
  bool operator<(const EdgeTuple& et) const
  {
    return this->V0 < et.V0 || (this->V0 == et.V0 && this->V1 < et.V1);
  }
};

template <typename TId, typename TData = void>
struct TriangleTuple : vtkTupleData<TData>
{
  TId V0;
  TId V1;
  TId V2;
 
  TriangleTuple() = default;
 
  // Construct a triangle with its data.
  template <typename D = TData, typename = std::enable_if_t<!std::is_void_v<D>>>
  TriangleTuple(TId v0, TId v1, TId v2, const std::common_type_t<D>& data)
    : vtkTupleData<TData>{ data }
    , V0(v0)
    , V1(v1)
    , V2(v2)
  {
    this->Sort();
  }
 
  // Construct a triangle without data, e.g., a query.
  TriangleTuple(TId v0, TId v1, TId v2)
    : vtkTupleData<TData>()
    , V0(v0)
    , V1(v1)
    , V2(v2)
  {
    this->Sort();
  }
 
  // The key of the element, see EdgeTuple::GetKey().
  TId GetKey() const { return this->V0; }
 
  bool operator==(const TriangleTuple& t) const
  {
    return this->V0 == t.V0 && this->V1 == t.V1 && this->V2 == t.V2;
  }
  bool operator!=(const TriangleTuple& t) const { return !(*this == t); }
 
  // Sort on V0 first, then V1, then V2.
  bool operator<(const TriangleTuple& t) const
  {
    if (this->V0 != t.V0)
    {
      return this->V0 < t.V0;
    }
    return this->V1 != t.V1 ? this->V1 < t.V1 : this->V2 < t.V2;
  }
 
private:
  // A 3-element sorting network.
  void Sort()
  {
    if (this->V0 > this->V1)
      std::swap(this->V0, this->V1);
    if (this->V1 > this->V2)
      std::swap(this->V1, this->V2);
    if (this->V0 > this->V1)
      std::swap(this->V0, this->V1);
  }
};

template <typename TId, typename TData = void>
struct QuadTuple : vtkTupleData<TData>
{
  TId V0;
  TId V1;
  TId V2;
  TId V3;
 
  QuadTuple() = default;
 
  // Construct a quad with its data.
  template <typename D = TData, typename = std::enable_if_t<!std::is_void_v<D>>>
  QuadTuple(TId v0, TId v1, TId v2, TId v3, const std::common_type_t<D>& data)
    : vtkTupleData<TData>{ data }
    , V0(v0)
    , V1(v1)
    , V2(v2)
    , V3(v3)
  {
    this->Sort();
  }
 
  // Construct a quad without data, e.g., a query.
  QuadTuple(TId v0, TId v1, TId v2, TId v3)
    : vtkTupleData<TData>()
    , V0(v0)
    , V1(v1)
    , V2(v2)
    , V3(v3)
  {
    this->Sort();
  }
 
  // The key of the element, see EdgeTuple::GetKey().
  TId GetKey() const { return this->V0; }
 
  bool operator==(const QuadTuple& q) const
  {
    return this->V0 == q.V0 && this->V1 == q.V1 && this->V2 == q.V2 && this->V3 == q.V3;
  }
  bool operator!=(const QuadTuple& q) const { return !(*this == q); }
 
  // Sort on V0 first, then V1, then V2, then V3.
  bool operator<(const QuadTuple& q) const
  {
    if (this->V0 != q.V0)
    {
      return this->V0 < q.V0;
    }
    if (this->V1 != q.V1)
    {
      return this->V1 < q.V1;
    }
    return this->V2 != q.V2 ? this->V2 < q.V2 : this->V3 < q.V3;
  }
 
private:
  // A 4-element sorting network.
  void Sort()
  {
    if (this->V0 > this->V1)
      std::swap(this->V0, this->V1);
    if (this->V2 > this->V3)
      std::swap(this->V2, this->V3);
    if (this->V0 > this->V2)
      std::swap(this->V0, this->V2);
    if (this->V1 > this->V3)
      std::swap(this->V1, this->V3);
    if (this->V1 > this->V2)
      std::swap(this->V1, this->V2);
  }
};
 
// ============================================================================
// Common Locators
// ============================================================================

template <typename TId = vtkIdType, typename TData = void>
using vtkStaticEdgeLocator = vtkStaticElementLocator<TId, EdgeTuple<TId, TData>>;

template <typename TId = vtkIdType, typename TData = void>
using vtkStaticTriangleLocator = vtkStaticElementLocator<TId, TriangleTuple<TId, TData>>;

template <typename TId = vtkIdType, typename TData = void>
using vtkStaticQuadLocator = vtkStaticElementLocator<TId, QuadTuple<TId, TData>>;
 
VTK_ABI_NAMESPACE_END
#include "vtkStaticElementLocator.txx"
 
#endif
// VTK-HeaderTest-Exclude: vtkStaticElementLocator.h