mask.hpp

// This file is part of the ACTS project.
//
// Copyright (C) 2016 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 https://mozilla.org/MPL/2.0/.
 
#pragma once
 
// Project include(s)
#include "detray/definitions/algebra.hpp"
#include "detray/definitions/detail/qualifiers.hpp"
#include "detray/definitions/indexing.hpp"
#include "detray/geometry/concepts.hpp"
#include "detray/geometry/shapes/cuboid3D.hpp"
#include "detray/navigation/intersection/intersection.hpp"
 
// System include(s)
#include <algorithm>
#include <cassert>
#include <limits>
#include <ostream>
#include <sstream>
#include <string>
#include <vector>
 
namespace detray {

template <typename shape_t, concepts::algebra algebra_t,
          typename links_t = std::uint_least16_t>
  requires concepts::shape<shape_t, algebra_t>
class mask {
 public:
  using algebra_type = algebra_t;
  using scalar_type = dscalar<algebra_t>;
  using point2_type = dpoint2D<algebra_t>;
  using point3_type = dpoint3D<algebra_t>;
  using vector3_type = dvector3D<algebra_t>;
  using transform3_type = dtransform3D<algebra_t>;

  using links_type = links_t;
  using shape = shape_t;
  using boundaries = typename shape::boundaries;
  using mask_values = typename shape::template bounds_type<scalar_type>;
  using local_frame = typename shape::template local_frame_type<algebra_t>;
  using result_type = typename shape::template result_type<dbool<algebra_t>>;

  constexpr mask() = default;

  template <typename... Args>
    requires(sizeof...(Args) == shape::boundaries::e_size)
  DETRAY_HOST_DEVICE explicit constexpr mask(const links_type& link,
                                             Args&&... args)
      : _values({{std::forward<Args>(args)...}}), _volume_link(link) {}

  DETRAY_HOST_DEVICE
  constexpr mask(const mask_values& values, const links_type& link)
      : _values{values}, _volume_link{link} {}

  DETRAY_HOST mask(const std::vector<scalar_type>& values,
                   const links_type& link)
      : _volume_link(link) {
    assert(values.size() == boundaries::e_size &&
           " Given number of boundaries does not match mask shape.");
    std::ranges::copy(values, std::begin(_values));
  }

  DETRAY_HOST
  auto operator=(const mask_values& rhs) -> mask<shape_t, algebra_t, links_t>& {
    _values = rhs;
    return (*this);
  }

  bool operator==(const mask& rhs) const = default;

  DETRAY_HOST_DEVICE
  constexpr auto operator[](const std::size_t value_index) -> scalar_type& {
    return _values[value_index];
  }

  DETRAY_HOST_DEVICE
  constexpr auto operator[](const std::size_t value_index) const
      -> scalar_type {
    return _values[value_index];
  }

  DETRAY_HOST_DEVICE
  static consteval auto get_shape() -> shape { return shape{}; }

  DETRAY_HOST_DEVICE static consteval local_frame get_local_frame() {
    return local_frame{};
  }

  DETRAY_HOST_DEVICE constexpr static auto to_local_frame3D(
      const transform3_type& trf, const point3_type& glob_p,
      const point3_type& glob_dir = {}) -> point3_type {
    return get_local_frame().global_to_local_3D(trf, glob_p, glob_dir);
  }

  DETRAY_HOST_DEVICE constexpr static auto to_local_frame(
      const transform3_type& trf, const point3_type& glob_p,
      const point3_type& glob_dir = {}) -> point2_type {
    return get_local_frame().global_to_local(trf, glob_p, glob_dir);
  }

  DETRAY_HOST_DEVICE constexpr static auto to_global_frame(
      const transform3_type& trf, const point3_type& loc) -> point3_type {
    return get_local_frame().local_to_global(trf, loc);
  }

  DETRAY_HOST_DEVICE constexpr auto to_global_frame(
      const transform3_type& trf, const point2_type& loc,
      const vector3_type& dir) const -> point3_type {
    return get_local_frame().local_to_global(trf, *this, loc, dir);
  }


  template <concepts::point point_t>
  DETRAY_HOST_DEVICE constexpr result_type resolve(
      const point_t& loc_p,
      const scalar_type tol = std::numeric_limits<scalar_type>::epsilon(),
      const scalar_type edge_tol = 0.f) const {
    return get_shape().check_boundaries(_values, loc_p, tol, edge_tol);
  }

  DETRAY_HOST_DEVICE constexpr result_type resolve(
      const transform3_type& trf, const point3_type& glob_p,
      const scalar_type tol = std::numeric_limits<scalar_type>::epsilon(),
      const scalar_type edge_tol = 0.f) const {
    return get_shape().template check_boundaries<algebra_type>(
        _values, trf, glob_p, tol, edge_tol);
  }

  template <concepts::point point_t>
  DETRAY_HOST_DEVICE constexpr dbool<algebra_t> is_inside(
      const point_t& loc_p,
      const scalar_type tol =
          std::numeric_limits<scalar_type>::epsilon()) const {
    return detray::get<check_type::e_precise>(
        get_shape().check_boundaries(_values, loc_p, tol, scalar_type{0.f}));
  }

  DETRAY_HOST_DEVICE constexpr dbool<algebra_type> is_inside(
      const transform3_type& trf, const point3_type& glob_p,
      const scalar_type tol =
          std::numeric_limits<scalar_type>::epsilon()) const {
    return detray::get<check_type::e_precise>(
        get_shape().template check_boundaries<algebra_type>(
            _values, trf, glob_p, tol, scalar_type{0.f}));
  }


  DETRAY_HOST_DEVICE
  auto values() const -> const mask_values& { return _values; }

  DETRAY_HOST_DEVICE
  auto volume_link() const -> const links_type& { return _volume_link; }

  DETRAY_HOST_DEVICE
  auto volume_link() -> links_type& { return _volume_link; }

  DETRAY_HOST_DEVICE constexpr auto measure() const -> scalar_type {
    return get_shape().measure(_values);
  }

  template <typename S = shape_t>
    requires(S::dim == 2)
  DETRAY_HOST_DEVICE constexpr auto area() const -> scalar_type {
    return get_shape().area(_values);
  }

  template <typename S = shape_t>
    requires(S::dim == 3)
  DETRAY_HOST_DEVICE constexpr auto volume() const -> scalar_type {
    return get_shape().volume(_values);
  }

  DETRAY_HOST_DEVICE auto centroid() const {
    return get_shape().template centroid<algebra_t>(_values);
  }

  DETRAY_HOST_DEVICE
  auto min_dist_to_boundary(const point3_type& loc_p) const -> scalar_type {
    return get_shape().min_dist_to_boundary(_values, loc_p);
  }

  DETRAY_HOST_DEVICE
  auto local_min_bounds(
      const scalar_type env = std::numeric_limits<scalar_type>::epsilon()) const
      -> mask<cuboid3D, algebra_t, unsigned int> {
    const auto bounds =
        get_shape().template local_min_bounds<algebra_t>(_values, env);
    static_assert(bounds.size() == cuboid3D::e_size,
                  "Shape returns incompatible bounds for bound box");
    return {bounds, std::numeric_limits<unsigned int>::max()};
  }

  DETRAY_HOST
  auto vertices(const dindex n_seg) const -> dvector<point3_type> {
    return get_shape().template vertices<algebra_t>(_values, n_seg);
  }

  DETRAY_HOST
  friend mask operator+(const mask& left, const mask& right) {
    links_type vol_link{left.volume_link() == right.volume_link()
                            ? left.volume_link()
                            : detail::invalid_value<links_type>()};
    mask_values merged_vals =
        mask::get_shape().merge(left.values(), right.values());
 
    return {std::move(merged_vals), vol_link};
  }

  DETRAY_HOST
  constexpr bool self_check(std::ostream& os) const {
    const bool result = get_shape().check_consistency(_values, os);
 
    if (!result) {
      os << to_string();
    }
 
    return result;
  }

  DETRAY_HOST
  auto to_string() const -> std::string {
    std::stringstream ss;
    ss << std::string(shape::name);
    for (const auto& v : _values) {
      ss << ", " << v;
    }
    return ss.str();
  }

  DETRAY_HOST
  friend std::ostream& operator<<(std::ostream& os, const mask& m) {
    os << m.to_string();
    return os;
  }
 
 private:
  mask_values _values{};
  links_type _volume_link{std::numeric_limits<links_type>::max()};
};
 
}  // namespace detray