bounding_box.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2017 - 2020 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#ifndef dealii_base_bounding_box_h
#define dealii_base_bounding_box_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/exceptions.h>
#include <deal.II/base/point.h>
#include <deal.II/base/utilities.h>
 
DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
#include <boost/geometry/algorithms/envelope.hpp>
#include <boost/geometry/geometries/multi_point.hpp>
DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
 
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:
  BoundingBox() = default;
 
  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;
 
  NeighborType
  get_neighbor_type(const BoundingBox<spacedim, Number> &other_bbox) const;
 
  void
  merge_with(const BoundingBox<spacedim, Number> &other_bbox);
 
  bool
  point_inside(const Point<spacedim, Number> &p) const;
 
  void
  extend(const Number &amount);
 
  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;
 
  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 unsigned int
  coordinate_to_one_dim_higher(const unsigned int locked_coordinate,
                               const unsigned int coordiante_in_dim)
  {
    AssertIndexRange(locked_coordinate, dim + 1);
    AssertIndexRange(coordiante_in_dim, dim);
    return (locked_coordinate + coordiante_in_dim + 1) % (dim + 1);
  }
 
} // namespace internal
 
/*------------------------ Inline functions: BoundingBox --------------------*/
 
#ifndef DOXYGEN
 
 
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)
{
  boost::geometry::envelope(
    boost::geometry::model::multi_point<Point<spacedim, Number>>(points.begin(),
                                                                 points.end()),
    *this);
}
 
 
 
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>
template <class Archive>
void
BoundingBox<spacedim, Number>::serialize(Archive &ar,
                                         const unsigned int /*version*/)
{
  ar &boundary_points;
}
 
 
 
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