BoundingBox.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file BoundingBox.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2018-2019 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include <algorithm>
#include <array>
#include <iostream>
#include <limits>
#include <ostream>
#include <tuple>
#include <vector>
#include "Acts/Utilities/Definitions.hpp"
#include "Acts/Utilities/Frustum.hpp"
#include "Acts/Utilities/Helpers.hpp"
#include "Acts/Utilities/Ray.hpp"
#include "Acts/Visualization/IVisualization.hpp"

namespace Acts {

template <typename entity_t, typename value_t, size_t DIM>
class AxisAlignedBoundingBox {
 private:
  using self_t = AxisAlignedBoundingBox<entity_t, value_t, DIM>;

  template <typename T, typename P>
  class NamedType {
   public:
    explicit NamedType(const T& value) : m_value(value) {}
    explicit NamedType(T&& value) : m_value(std::move(value)) {}
    T& get() { return m_value; }
    const T& get() const { return m_value; }

   private:
    T m_value;
  };

  struct SizeParameter {};

 public:
  using value_type = value_t;
  using VertexType = ActsVector<value_t, DIM>;
  using vertex_array_type = Eigen::Array<value_t, DIM, 1>;

  using entity_type = entity_t;

  using transform_type = Eigen::Transform<value_type, DIM, Eigen::Affine>;

  using Size = NamedType<VertexType, struct SizeParameter>;

  static const size_t dim = DIM;

  AxisAlignedBoundingBox(const self_t& other) = default;

  AxisAlignedBoundingBox(const entity_t* entity, const VertexType& vmin,
                         const VertexType& vmax);

  AxisAlignedBoundingBox(const entity_t* entity, const VertexType& center,
                         const Size& size);

  AxisAlignedBoundingBox(
      const std::vector<self_t*>& boxes,
      vertex_array_type envelope = vertex_array_type::Zero());

  static std::pair<VertexType, VertexType> wrap(
      const std::vector<const self_t*>& boxes,
      vertex_array_type envelope = vertex_array_type::Zero());

  static std::pair<VertexType, VertexType> wrap(
      const std::vector<self_t*>& boxes,
      vertex_array_type envelope = vertex_array_type::Zero());

  static std::pair<VertexType, VertexType> wrap(
      const std::vector<self_t>& boxes,
      vertex_array_type envelope = vertex_array_type::Zero());

  bool intersect(const VertexType& point) const;

  bool intersect(const Ray<value_type, DIM>& ray) const;

  template <size_t sides>
  bool intersect(const Frustum<value_type, DIM, sides>& fr) const;

  void setSkip(self_t* skip);

  const self_t* getSkip() const;

  const self_t* getLeftChild() const;

  bool hasEntity() const;

  const entity_t* entity() const;

  void setEntity(const entity_t* entity);

  const VertexType& center() const;

  const VertexType& min() const;

  const VertexType& max() const;

  std::ostream& toStream(std::ostream& os) const;

  void transform(const transform_type& trf);

  self_t transformed(const transform_type& trf) const;

  template <size_t D = DIM, std::enable_if_t<D == 3, int> = 0>
  void draw(IVisualization& helper, std::array<int, 3> color = {120, 120, 120},
            const transform_type& trf = transform_type::Identity()) const;

  template <size_t D = DIM, std::enable_if_t<D == 2, int> = 0>
  std::ostream& svg(std::ostream& os, value_type w, value_type h,
                    value_type unit = 10, std::string label = "",
                    std::string fillcolor = "grey") const;

 private:
  template <size_t D = DIM, std::enable_if_t<D == 2, int> = 0>
  std::pair<VertexType, VertexType> transformVertices(
      const transform_type& trf) const;

  template <size_t D = DIM, std::enable_if_t<D == 3, int> = 0>
  std::pair<VertexType, VertexType> transformVertices(
      const transform_type& trf) const;

  const entity_t* m_entity;
  VertexType m_vmin;
  VertexType m_vmax;
  VertexType m_center;
  vertex_array_type m_width;
  vertex_array_type m_iwidth;

  self_t* m_left_child{nullptr};
  self_t* m_right_child{nullptr};
  self_t* m_skip{nullptr};
};

template <typename box_t>
box_t* make_octree(std::vector<std::unique_ptr<box_t>>& store,
                   const std::vector<box_t*>& prims, size_t max_depth = 1,
                   typename box_t::value_type envelope1 = 0);

template <typename T, typename U, size_t V>
std::ostream& operator<<(std::ostream& os,
                         const AxisAlignedBoundingBox<T, U, V>& box);

}  // namespace Acts

#include "Acts/Utilities/BoundingBox.ipp"