QuadTreeNode.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
 
#include <framework/logging/Logger.h>
 
#include <vector>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    template<typename AX, typename AY, class AItem>
    class QuadTreeNode {
 
    public:
      using This = QuadTreeNode<AX, AY, AItem>;
 
      using XSpan = std::array<AX, 2>;
 
      using YSpan = std::array<AY, 2>;
 
      using XBinBounds = std::array<AX, 4>;
 
      using YBinBounds = std::array<AY, 4>;
 
      using Children = std::vector<This>;
 
      // cppcheck-suppress passedByValue
      QuadTreeNode(XSpan xSpan, YSpan ySpan, int level, This* parent)
        : m_xBinBounds(
      {
        xSpan[0],
              xSpan[0] + (xSpan[1] - xSpan[0]) / 2,
              xSpan[1] - (xSpan[1] - xSpan[0]) / 2,
              xSpan[1]
      })
      , m_yBinBounds({ySpan[0],
                      ySpan[0] + (ySpan[1] - ySpan[0]) / 2,
                      ySpan[1] - (ySpan[1] - ySpan[0]) / 2,
                      ySpan[1]
                     })
      , m_level(level)
      , m_parent(level > 0 ? parent : nullptr)
      , m_filled(false)
      {
        B2ASSERT("QuadTree datastructure only supports levels < 255", level < 255);
      }
 
      void insertItem(AItem* item)
      {
        m_items.push_back(item);
      }
 
      void reserveItems(int nItems)
      {
        m_items.reserve(nItems);
      }
 
      std::vector<AItem*>& getItems()
      {
        return m_items;
      }
 
      int getNItems() const
      {
        return m_items.size();
      }
 
      void clearItems()
      {
        m_items.clear();
      }
 
      Children& getChildren()
      {
        return m_children;
      }
 
      void clearChildren()
      {
        // automatically removes all lower level objects
        m_children.clear();
        m_filled = false;
      }
 
      int getLevel() const
      {
        return m_level;
      }
 
      bool checkFilled() const
      {
        return m_filled;
      }
 
      void setFilled()
      {
        m_filled = true;
      }
 
      This* getParent() const
      {
        return m_parent;
      }
 
      constexpr int getXNbins() const
      {
        return m_xBinBounds.size() / 2;
      }
 
      AX getXMin() const
      {
        return m_xBinBounds.front();
      }
 
      AX getXMax() const
      {
        return m_xBinBounds.back();
      }
 
      AX getXBinWidth(int iBin)
      {
        return std::abs(getXUpperBound(iBin) - getXLowerBound(iBin));
      }
 
      AX getXLowerBound(int iBin) const
      {
        return m_xBinBounds[2 * iBin];
      }
 
      AX getXUpperBound(int iBin) const
      {
        return m_xBinBounds[2 * iBin + 1];
      }
 
      constexpr int getYNbins() const
      {
        return m_yBinBounds.size() / 2;
      }
 
      AY getYMin() const
      {
        return m_yBinBounds.front();
      }
 
      AY getYMax() const
      {
        return m_yBinBounds.back();
      }
 
      AY getYBinWidth(int iBin)
      {
        return std::abs(getYUpperBound(iBin) - getYLowerBound(iBin));
      }
      AY getYLowerBound(int iBin) const
      {
        return m_yBinBounds[2 * iBin];
      }
 
      AY getYUpperBound(int iBin) const
      {
        return m_yBinBounds[2 * iBin + 1];
      }
 
    private:
      XBinBounds m_xBinBounds;
 
      YBinBounds m_yBinBounds;
 
      int m_level;
 
      This* m_parent;
 
      std::vector<AItem*> m_items;
 
      std::vector<This> m_children;
 
      bool m_filled;
    };
  }
}