Box.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 <tracking/trackFindingCDC/utilities/EvalVariadic.h>
 
#include <type_traits>
#include <utility>
#include <array>
#include <cassert>
#include <numeric>
#include <ostream>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    template<class... ATypes>
    class Box;
 
    template<>
    class Box<> {
    public:
      void setBounds()
      {
      }
 
      friend std::ostream& operator<<(std::ostream& output, const Box<>& voidBox __attribute__((unused)))
      {
        return output;
      }
    };
 
    template<class AFirstType, class... ASubordinaryTypes>
    class Box<AFirstType, ASubordinaryTypes...> {
    public:
      using FirstType = AFirstType;
 
      using This = Box<AFirstType, ASubordinaryTypes...>;
 
      using Point = std::tuple<FirstType, ASubordinaryTypes...>;
 
      using Delta = std::tuple < decltype(FirstType() - FirstType()),
            decltype(ASubordinaryTypes() - ASubordinaryTypes())... >;
 
      template<std::size_t I>
      using Type = typename std::tuple_element<I, Point>::type;
 
      template<class T>
      using TypeIndex = GetIndexInTuple<T, Point>;
 
      template<class T>
      using HasType = TypeInTuple<T, Point>;
 
      template<std::size_t I>
      using Width = typename std::tuple_element<I, Delta>::type;
 
      static const size_t c_nTypes = std::tuple_size<Point>::value;
 
      using Indices = std::make_index_sequence<c_nTypes>;
 
      Box(const std::array<FirstType, 2>& firstBound,
          const std::array<ASubordinaryTypes, 2>& ... subordinaryBounds)
        : m_firstBounds{{
          std::min(firstBound[0], firstBound[1]),
          std::max(firstBound[1], firstBound[0])}}
      , m_subordinaryBox(subordinaryBounds...)
      {
      }
 
      friend std::ostream& operator<<(std::ostream& output, const This& box)
      {
        return output <<
               "Range from " << box.m_firstBounds[0] <<
               " to " << box.m_firstBounds[1] << std::endl <<
               box.getSubordinaryBox();
      }
 
      void setBounds(std::array<FirstType, 2> firstBounds,
                     std::array<ASubordinaryTypes, 2>... subordinaryBounds)
      {
        m_firstBounds[0] = std::min(firstBounds[0], firstBounds[1]);
        m_firstBounds[1] = std::max(firstBounds[0], firstBounds[1]);
        m_subordinaryBox.setBounds(subordinaryBounds...);
      }
 
      const Box<ASubordinaryTypes...>& getSubordinaryBox() const
      {
        return m_subordinaryBox;
      }
 
      template<std::size_t I>
      const std::enable_if_t<I == 0, Type<I> >& getLowerBound() const
      {
        return m_firstBounds[0];
      }
 
      template<std::size_t I>
      const std::enable_if_t < I != 0, Type<I> > & getLowerBound() const
      {
        static_assert(I < c_nTypes,
                      "Accessed index exceeds number of coordinates");
        return m_subordinaryBox.template getLowerBound < I - 1 > ();
      }
 
      template <class T>
      const std::enable_if_t<HasType<T>::value, T>& getLowerBound() const
      {
        return getLowerBound<TypeIndex<T>::value>();
      }
 
      template <std::size_t I>
      const std::enable_if_t<I == 0, Type<I>>& getUpperBound() const
      {
        return m_firstBounds[1];
      }
 
      template<std::size_t I>
      const std::enable_if_t < I != 0, Type<I> > & getUpperBound() const
      {
        static_assert(I < c_nTypes,
                      "Accessed index exceeds number of coordinates");
        return m_subordinaryBox.template getUpperBound < I - 1 > ();
      }
 
      template <class T>
      const std::enable_if_t<HasType<T>::value, T>& getUpperBound() const
      {
        return getUpperBound<TypeIndex<T>::value>();
      }
 
      template <std::size_t I>
      const std::enable_if_t<I == 0, std::array<Type<I>, 2>>& getBounds() const
      {
        return m_firstBounds;
      }
 
      template <std::size_t I>
      const std::enable_if_t < I != 0, std::array<Type<I>, 2 >>& getBounds() const
      {
        static_assert(I < c_nTypes, "Accessed index exceeds number of coordinates");
        return m_subordinaryBox.template getBounds < I - 1 > ();
      }
 
      template <class T>
      const std::enable_if_t<HasType<T>::value, std::array<T, 2>>& getBounds() const
      {
        return getBounds<TypeIndex<T>::value>();
      }
 
      template <std::size_t I>
      Width<I> getWidth() const
      {
        return getUpperBound<I>() - getLowerBound<I>();
      }
 
    public:
      template<std::size_t I>
      Type<I> getDivision(size_t nDivisions, size_t iDivision) const
      {
        assert(nDivisions >= iDivision);
        return Type<I>(getLowerBound<I>() + getWidth<I>() * iDivision / nDivisions);
      }
 
      template<std::size_t I>
      std::array<Type<I>, 2 >
      getDivisionBounds(size_t nDivisions, size_t iDivision) const
      {
        assert(nDivisions > iDivision);
        return {{getDivision<I>(nDivisions, iDivision), getDivision<I>(nDivisions, iDivision + 1)}};
      }
 
      template <std::size_t I>
      Width<I> getDivisionWidthWithOverlap(const Width<I>& overlap, size_t nDivisions) const
      {
        return (getWidth<I>() + (nDivisions - 1) * overlap) / nDivisions;
      }
 
      template<std::size_t I>
      Type<I>
      getLowerDivisionBoundWithOverlap(const Width<I>& overlap,
                                       size_t nDivisions,
                                       size_t iDivision) const
      {
        assert(nDivisions >= iDivision);
        return Type<I>(getLowerBound<I>() + (getWidth<I>() - overlap) * iDivision / nDivisions);
      }
 
      template<std::size_t I>
      Type<I>
      getUpperDivisionBoundWithOverlap(const Width<I>& overlap,
                                       size_t nDivisions,
                                       size_t iDivision) const
      {
        assert(nDivisions >= iDivision);
        return Type<I>(getUpperBound<I>() - (getWidth<I>() - overlap) * (nDivisions - iDivision - 1) / nDivisions);
      }
 
 
      template<std::size_t I>
      std::array<Type<I>, 2 >
      getDivisionBoundsWithOverlap(const Width<I>& overlap,
                                   size_t nDivisions,
                                   size_t iDivision) const
      {
        assert(nDivisions > iDivision);
        return {{
            getLowerDivisionBoundWithOverlap<I>(overlap, nDivisions, iDivision),
            getUpperDivisionBoundWithOverlap<I>(overlap, nDivisions, iDivision)
          }};
      }
 
      template <std::size_t I>
      Type<I> getCenter() const
      {
        return getDivision<I>(2, 1);
      }
 
      template <std::size_t I>
      std::array<Type<I>, 2> getLowerHalfBounds() const
      {
        return getDivisionBounds(2, 0);
      }
 
      template <std::size_t I>
      std::array<Type<I>, 2> getUpperHalfBounds() const
      {
        return getDivisionBounds(2, 1);
      }
 
      template <std::size_t I, class ASubordinaryValue>
      bool isIn(const ASubordinaryValue& value) const
      {
        return getLowerBound<I>() < value and not(getUpperBound<I>() < value);
      }
 
    private:
      static bool any(const std::initializer_list<bool>& booleans)
      {
        return std::accumulate(std::begin(booleans), std::end(booleans),
        false, [](const bool & lhs, const bool & rhs) {return lhs or rhs;});
 
      }
 
      static bool all(const std::initializer_list<bool>& booleans)
      {
        return std::accumulate(std::begin(booleans), std::end(booleans),
        true, [](const bool & lhs, const bool & rhs) {return lhs and rhs;});
      }
 
      template <size_t... Is>
      bool intersectsImpl(const This& box,
                          std::index_sequence<Is...> is __attribute__((unused))) const
      {
        return not(any({box.getUpperBound<Is>() < this->getLowerBound<Is>()... }) or
                   any({this->getUpperBound<Is>() < box.getLowerBound<Is>()... }));
      }
 
      template <size_t... Is>
      bool isInImpl(const Point& point,
                    std::index_sequence<Is...> is __attribute__((unused))) const
      {
        return not all({isIn<Is>(std::get<Is>(point))...});
      }
 
    public:
      bool intersects(const This& box) const
      {
        return intersectsImpl(box, Indices());
      }
 
      bool isIn(const Point& point) const
      {
        return isInImpl(point, Indices());
      }
 
      bool isIn(const FirstType& value, const ASubordinaryTypes& ... values) const
      {
        return isInImpl(Point(value, values...), Indices());
      }
 
    private:
      std::array<FirstType, 2> m_firstBounds;
 
      Box<ASubordinaryTypes... > m_subordinaryBox;
    };
 
  }
}