bounding_box.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
// Copyright (C) 2017 - 2026 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Detailed license information governing the source code and contributions
// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
//
// -----------------------------------------------------------------------------
 
#ifndef dealii_base_bounding_box_h
#define dealii_base_bounding_box_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/exception_macros.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/point.h>
 
#include <Kokkos_Macros.hpp>
 
#include <algorithm>
#include <iterator>
#include <limits>
#include <string>
#include <utility>
 
DEAL_II_NAMESPACE_OPEN
 
enum class NeighborType
{
  not_neighbors = 0,
 
  simple_neighbors = 1,
 
  attached_neighbors = 2,
 
  mergeable_neighbors = 3
};
 
template <int spacedim, typename Number = double>
class BoundingBox
{
public:
  static constexpr unsigned int dimension = spacedim;
 
  BoundingBox() = default;
 
  BoundingBox(const BoundingBox<spacedim, Number> &box) = default;
 
  BoundingBox<spacedim, Number> &
  operator=(const BoundingBox<spacedim, Number> &t) = default;
 
  BoundingBox(const Point<spacedim, Number> &point);
 
  BoundingBox(const std::pair<Point<spacedim, Number>, Point<spacedim, Number>>
                &boundary_points);
 
  template <class Container>
  BoundingBox(const Container &points);
 
  std::pair<Point<spacedim, Number>, Point<spacedim, Number>> &
  get_boundary_points();
 
  const std::pair<Point<spacedim, Number>, Point<spacedim, Number>> &
  get_boundary_points() const;
 
  bool
  operator==(const BoundingBox<spacedim, Number> &box) const;
 
  bool
  operator!=(const BoundingBox<spacedim, Number> &box) const;
 
  bool
  has_overlap_with(
    const BoundingBox<spacedim, Number> &other_bbox,
    const double tolerance = std::numeric_limits<Number>::epsilon()) const;
 
  NeighborType
  get_neighbor_type(
    const BoundingBox<spacedim, Number> &other_bbox,
    const double tolerance = std::numeric_limits<Number>::epsilon()) const;
 
  void
  merge_with(const BoundingBox<spacedim, Number> &other_bbox);
 
  bool
  point_inside(
    const Point<spacedim, Number> &p,
    const double tolerance = std::numeric_limits<Number>::epsilon()) const;
 
  void
  extend(const Number amount);
 
  BoundingBox<spacedim, Number>
  create_extended(const Number amount) const;
 
  BoundingBox<spacedim, Number>
  create_extended_relative(const Number relative_amount) const;
 
  double
  volume() const;
 
  Point<spacedim, Number>
  center() const;
 
  Number
  side_length(const unsigned int direction) const;
 
  Number
  lower_bound(const unsigned int direction) const;
 
  Number
  upper_bound(const unsigned int direction) const;
 
  BoundingBox<1, Number>
  bounds(const unsigned int direction) const;
 
  Point<spacedim, Number>
  vertex(const unsigned int index) const;
 
  BoundingBox<spacedim, Number>
  child(const unsigned int index) const;
 
  BoundingBox<spacedim - 1, Number>
  cross_section(const unsigned int direction) const;
 
  Point<spacedim, Number>
  real_to_unit(const Point<spacedim, Number> &point) const;
 
  Point<spacedim, Number>
  unit_to_real(const Point<spacedim, Number> &point) const;
  Number
  signed_distance(const Point<spacedim, Number> &point,
                  const unsigned int             direction) const;
 
  Number
  signed_distance(const Point<spacedim, Number> &point) const;
 
  template <class Archive>
  void
  serialize(Archive &ar, const unsigned int version);
 
private:
  std::pair<Point<spacedim, Number>, Point<spacedim, Number>> boundary_points;
};
 
template <typename Number>
class BoundingBox<0, Number>
{
public:
  BoundingBox();
 
  BoundingBox(const std::pair<Point<0, Number>, Point<0, Number>> &);
 
  template <class Container>
  BoundingBox(const Container &);
};
 
 
template <int dim, typename Number = double>
BoundingBox<dim, Number>
create_unit_bounding_box();
 
 
namespace internal
{
  template <int dim>
  inline int
  coordinate_to_one_dim_higher(const int locked_coordinate,
                               const int coordinate_in_dim)
  {
    AssertIndexRange(locked_coordinate, dim + 1);
    AssertIndexRange(coordinate_in_dim, dim);
    return (locked_coordinate + coordinate_in_dim + 1) % (dim + 1);
  }
 
} // namespace internal
 
/*------------------------ Inline functions: BoundingBox --------------------*/
 
#ifndef DOXYGEN
 
 
template <int spacedim, typename Number>
inline BoundingBox<spacedim, Number>::BoundingBox(
  const Point<spacedim, Number> &p)
  : BoundingBox({p, p})
{}
 
 
 
template <int spacedim, typename Number>
inline BoundingBox<spacedim, Number>::BoundingBox(
  const std::pair<Point<spacedim, Number>, Point<spacedim, Number>>
    &boundary_points)
{
  // We check the Bounding Box is not degenerate
  for (unsigned int i = 0; i < spacedim; ++i)
    Assert(boundary_points.first[i] <= boundary_points.second[i],
           ExcMessage("Bounding Box can't be created: the points' "
                      "order should be bottom left, top right!"));
 
  this->boundary_points = boundary_points;
}
 
 
 
template <int spacedim, typename Number>
template <class Container>
inline BoundingBox<spacedim, Number>::BoundingBox(const Container &points)
{
  // Use the default constructor in case points is empty instead of setting
  // things to +oo and -oo
  if (points.size() > 0)
    {
      auto &min = boundary_points.first;
      auto &max = boundary_points.second;
      for (unsigned int d = 0; d < spacedim; ++d)
        {
          min[d] = std::numeric_limits<Number>::infinity();
          max[d] = -std::numeric_limits<Number>::infinity();
        }
 
      for (const Point<spacedim, Number> &point : points)
        for (unsigned int d = 0; d < spacedim; ++d)
          {
            min[d] = std::min(min[d], point[d]);
            max[d] = std::max(max[d], point[d]);
          }
    }
}
 
 
 
template <int spacedim, typename Number>
inline std::pair<Point<spacedim, Number>, Point<spacedim, Number>> &
BoundingBox<spacedim, Number>::get_boundary_points()
{
  return this->boundary_points;
}
 
 
 
template <int spacedim, typename Number>
inline const std::pair<Point<spacedim, Number>, Point<spacedim, Number>> &
BoundingBox<spacedim, Number>::get_boundary_points() const
{
  return this->boundary_points;
}
 
 
 
template <int spacedim, typename Number>
inline bool
BoundingBox<spacedim, Number>::operator==(
  const BoundingBox<spacedim, Number> &box) const
{
  return boundary_points == box.boundary_points;
}
 
 
 
template <int spacedim, typename Number>
inline bool
BoundingBox<spacedim, Number>::operator!=(
  const BoundingBox<spacedim, Number> &box) const
{
  return boundary_points != box.boundary_points;
}
 
 
 
template <int spacedim, typename Number>
inline void
BoundingBox<spacedim, Number>::extend(const Number amount)
{
  for (unsigned int d = 0; d < spacedim; ++d)
    {
      boundary_points.first[d] -= amount;
      boundary_points.second[d] += amount;
      Assert(boundary_points.first[d] <= boundary_points.second[d],
             ExcMessage("Bounding Box can't be shrunk this much: the points' "
                        "order should remain bottom left, top right."));
    }
}
 
 
 
template <int spacedim, typename Number>
inline BoundingBox<spacedim, Number>
BoundingBox<spacedim, Number>::create_extended(const Number amount) const
{
  // create and modify copy
  auto bb = *this;
  bb.extend(amount);
 
  return bb;
}
 
 
 
template <int spacedim, typename Number>
inline BoundingBox<spacedim, Number>
BoundingBox<spacedim, Number>::create_extended_relative(
  const Number relative_amount) const
{
  // create and modify copy
  auto bb = *this;
 
  for (unsigned int d = 0; d < spacedim; ++d)
    {
      bb.boundary_points.first[d] -= relative_amount * side_length(d);
      bb.boundary_points.second[d] += relative_amount * side_length(d);
      Assert(bb.boundary_points.first[d] <= bb.boundary_points.second[d],
             ExcMessage("Bounding Box can't be shrunk this much: the points' "
                        "order should remain bottom left, top right."));
    }
 
  return bb;
}
 
 
 
template <int spacedim, typename Number>
template <class Archive>
void
BoundingBox<spacedim, Number>::serialize(Archive &ar,
                                         const unsigned int /*version*/)
{
  // Avoid including boost/serialization/utility.hpp by unpacking the pair
  // ourselves
  ar &boundary_points.first;
  ar &boundary_points.second;
}
 
 
 
template <typename Number>
inline BoundingBox<0, Number>::BoundingBox()
{
  AssertThrow(false, ExcImpossibleInDim(0));
}
 
 
 
template <typename Number>
inline BoundingBox<0, Number>::BoundingBox(
  const std::pair<Point<0, Number>, Point<0, Number>> &)
{
  AssertThrow(false, ExcImpossibleInDim(0));
}
 
 
 
template <typename Number>
template <class Container>
inline BoundingBox<0, Number>::BoundingBox(const Container &)
{
  AssertThrow(false, ExcImpossibleInDim(0));
}
 
 
 
#endif // DOXYGEN
DEAL_II_NAMESPACE_CLOSE
 
#endif