MOAB  4.9.3pre
Public Types | Public Member Functions | Protected Attributes
Eigen::AlignedBox< _Scalar, _AmbientDim > Class Template Reference
Geometry_Module

An axis aligned box. More...

#include <AlignedBox.h>

Collaboration diagram for Eigen::AlignedBox< _Scalar, _AmbientDim >:
Collaboration graph
[legend]

List of all members.

Public Types

enum  { AmbientDimAtCompileTime = _AmbientDim }
enum  CornerType {
  Min = 0, Max = 1, BottomLeft = 0, BottomRight = 1,
  TopLeft = 2, TopRight = 3, BottomLeftFloor = 0, BottomRightFloor = 1,
  TopLeftFloor = 2, TopRightFloor = 3, BottomLeftCeil = 4, BottomRightCeil = 5,
  TopLeftCeil = 6, TopRightCeil = 7
}
typedef _Scalar Scalar
typedef NumTraits< Scalar > ScalarTraits
typedef Eigen::Index Index
typedef ScalarTraits::Real RealScalar
typedef ScalarTraits::NonInteger NonInteger
typedef Matrix< Scalar,
AmbientDimAtCompileTime, 1 > 		VectorType

Public Member Functions

 AlignedBox ()
 AlignedBox (Index _dim)
template<typename OtherVectorType1 , typename OtherVectorType2 >
 AlignedBox (const OtherVectorType1 &_min, const OtherVectorType2 &_max)
template<typename Derived >
 AlignedBox (const MatrixBase< Derived > &p)
 ~AlignedBox ()
Index dim () const
bool isNull () const
void setNull ()
bool isEmpty () const
void setEmpty ()
const VectorType &() min () const
VectorType &() min ()
const VectorType &() max () const
VectorType &() max ()
const CwiseUnaryOp
< internal::scalar_quotient1_op
< Scalar >, const
CwiseBinaryOp
< internal::scalar_sum_op
< Scalar >, const VectorType,
const VectorType > > 		center () const
const CwiseBinaryOp
< internal::scalar_difference_op
< Scalar >, const VectorType,
const VectorType > 		sizes () const
Scalar volume () const
CwiseBinaryOp
< internal::scalar_difference_op
< Scalar >, const VectorType,
const VectorType > 		diagonal () const
VectorType corner (CornerType corner) const
VectorType sample () const
template<typename Derived >
bool contains (const MatrixBase< Derived > &p) const
bool contains (const AlignedBox &b) const
bool intersects (const AlignedBox &b) const
template<typename Derived >
AlignedBox & extend (const MatrixBase< Derived > &p)
AlignedBox & extend (const AlignedBox &b)
AlignedBox & clamp (const AlignedBox &b)
AlignedBox intersection (const AlignedBox &b) const
AlignedBox merged (const AlignedBox &b) const
template<typename Derived >
AlignedBox & translate (const MatrixBase< Derived > &a_t)
template<typename Derived >
Scalar squaredExteriorDistance (const MatrixBase< Derived > &p) const
Scalar squaredExteriorDistance (const AlignedBox &b) const
template<typename Derived >
NonInteger exteriorDistance (const MatrixBase< Derived > &p) const
NonInteger exteriorDistance (const AlignedBox &b) const
template<typename NewScalarType >
internal::cast_return_type
< AlignedBox, AlignedBox
< NewScalarType,
AmbientDimAtCompileTime >
>::type 		cast () const
template<typename OtherScalarType >
 AlignedBox (const AlignedBox< OtherScalarType, AmbientDimAtCompileTime > &other)
bool isApprox (const AlignedBox &other, const RealScalar &prec=ScalarTraits::dummy_precision()) const

Protected Attributes

VectorType m_min
VectorType m_max

Detailed Description

template<typename _Scalar, int _AmbientDim>
class Eigen::AlignedBox< _Scalar, _AmbientDim >

An axis aligned box.

Template Parameters:
_Scalarthe type of the scalar coefficients
_AmbientDimthe dimension of the ambient space, can be a compile time value or Dynamic.

This class represents an axis aligned box as a pair of the minimal and maximal corners.

Warning:
The result of most methods is undefined when applied to an empty box. You can check for empty boxes using isEmpty().
See also:
Global aligned box typedefs

Definition at line 30 of file AlignedBox.h.

Member Typedef Documentation

template<typename _Scalar, int _AmbientDim>
typedef Eigen::Index Eigen::AlignedBox< _Scalar, _AmbientDim >::Index
Deprecated:
since Eigen 3.3

Definition at line 37 of file AlignedBox.h.

template<typename _Scalar, int _AmbientDim>
typedef ScalarTraits::NonInteger Eigen::AlignedBox< _Scalar, _AmbientDim >::NonInteger

Definition at line 39 of file AlignedBox.h.

template<typename _Scalar, int _AmbientDim>
typedef ScalarTraits::Real Eigen::AlignedBox< _Scalar, _AmbientDim >::RealScalar

Definition at line 38 of file AlignedBox.h.

template<typename _Scalar, int _AmbientDim>
typedef _Scalar Eigen::AlignedBox< _Scalar, _AmbientDim >::Scalar

Definition at line 35 of file AlignedBox.h.

template<typename _Scalar, int _AmbientDim>
typedef NumTraits<Scalar> Eigen::AlignedBox< _Scalar, _AmbientDim >::ScalarTraits

Definition at line 36 of file AlignedBox.h.

template<typename _Scalar, int _AmbientDim>
typedef Matrix<Scalar,AmbientDimAtCompileTime,1> Eigen::AlignedBox< _Scalar, _AmbientDim >::VectorType

Definition at line 40 of file AlignedBox.h.

Member Enumeration Documentation

template<typename _Scalar, int _AmbientDim>
anonymous enum
Enumerator:
AmbientDimAtCompileTime 

Definition at line 34 of file AlignedBox.h.

{ AmbientDimAtCompileTime = _AmbientDim };
template<typename _Scalar, int _AmbientDim>
enum Eigen::AlignedBox::CornerType

Define constants to name the corners of a 1D, 2D or 3D axis aligned bounding box

Enumerator:
Min 

1D names

Max 

1D names

BottomLeft 

Identifier for 2D corner

BottomRight 

Identifier for 2D corner

TopLeft 

Identifier for 2D corner

TopRight 

Identifier for 2D corner

BottomLeftFloor 

Identifier for 3D corner

BottomRightFloor 

Identifier for 3D corner

TopLeftFloor 

Identifier for 3D corner

TopRightFloor 

Identifier for 3D corner

BottomLeftCeil 

Identifier for 3D corner

BottomRightCeil 

Identifier for 3D corner

TopLeftCeil 

Identifier for 3D corner

TopRightCeil 

Definition at line 43 of file AlignedBox.h.

  {
    Min=0, Max=1,
    BottomLeft=0, BottomRight=1,
    TopLeft=2, TopRight=3,
    BottomLeftFloor=0, BottomRightFloor=1,
    TopLeftFloor=2, TopRightFloor=3,
    BottomLeftCeil=4, BottomRightCeil=5,
    TopLeftCeil=6, TopRightCeil=7
  };

Constructor & Destructor Documentation

template<typename _Scalar, int _AmbientDim>
Eigen::AlignedBox< _Scalar, _AmbientDim >::AlignedBox ( ) [inline]

Default constructor initializing a null box.

Definition at line 64 of file AlignedBox.h.

  { if (AmbientDimAtCompileTime!=Dynamic) setEmpty(); }
template<typename _Scalar, int _AmbientDim>
Eigen::AlignedBox< _Scalar, _AmbientDim >::AlignedBox ( Index  _dim) [inline, explicit]

Constructs a null box with _dim the dimension of the ambient space.

Definition at line 68 of file AlignedBox.h.

                                         : m_min(_dim), m_max(_dim)
  { setEmpty(); }
template<typename _Scalar, int _AmbientDim>
template<typename OtherVectorType1 , typename OtherVectorType2 >
Eigen::AlignedBox< _Scalar, _AmbientDim >::AlignedBox ( const OtherVectorType1 &  _min,
const OtherVectorType2 &  _max 
) [inline]

Constructs a box with extremities _min and _max.

Warning:
If either component of _min is larger than the same component of _max, the constructed box is empty.

Definition at line 74 of file AlignedBox.h.

: m_min(_min), m_max(_max) {}
template<typename _Scalar, int _AmbientDim>
template<typename Derived >
Eigen::AlignedBox< _Scalar, _AmbientDim >::AlignedBox ( const MatrixBase< Derived > &  p) [inline, explicit]

Constructs a box containing a single point p.

Definition at line 78 of file AlignedBox.h.

                                                           : m_min(p), m_max(m_min)
  { }
template<typename _Scalar, int _AmbientDim>
Eigen::AlignedBox< _Scalar, _AmbientDim >::~AlignedBox ( ) [inline]

Definition at line 81 of file AlignedBox.h.

{}
template<typename _Scalar, int _AmbientDim>
template<typename OtherScalarType >
Eigen::AlignedBox< _Scalar, _AmbientDim >::AlignedBox ( const AlignedBox< OtherScalarType, AmbientDimAtCompileTime > &  other) [inline, explicit]

Copy constructor with scalar type conversion

Definition at line 292 of file AlignedBox.h.

  {
    m_min = (other.min)().template cast<Scalar>();
    m_max = (other.max)().template cast<Scalar>();
  }

Member Function Documentation

template<typename _Scalar, int _AmbientDim>
template<typename NewScalarType >
internal::cast_return_type<AlignedBox, AlignedBox<NewScalarType,AmbientDimAtCompileTime> >::type Eigen::AlignedBox< _Scalar, _AmbientDim >::cast ( ) const [inline]
Returns:
*this with scalar type casted to NewScalarType

Note that if NewScalarType is equal to the current scalar type of *this then this function smartly returns a const reference to *this.

Definition at line 284 of file AlignedBox.h.

  {
    return typename internal::cast_return_type<AlignedBox,
                    AlignedBox<NewScalarType,AmbientDimAtCompileTime> >::type(*this);
  }
template<typename _Scalar, int _AmbientDim>
const CwiseUnaryOp<internal::scalar_quotient1_op<Scalar>, const CwiseBinaryOp<internal::scalar_sum_op<Scalar>, const VectorType, const VectorType> > Eigen::AlignedBox< _Scalar, _AmbientDim >::center ( ) const [inline]
Returns:
the center of the box

Definition at line 116 of file AlignedBox.h.

  { return (m_min+m_max)/2; }
template<typename _Scalar, int _AmbientDim>
AlignedBox& Eigen::AlignedBox< _Scalar, _AmbientDim >::clamp ( const AlignedBox< _Scalar, _AmbientDim > &  b) [inline]

Clamps *this by the box b and returns a reference to *this.

Note:
If the boxes don't intersect, the resulting box is empty.
See also:
intersection(), intersects()

Definition at line 220 of file AlignedBox.h.

  {
    m_min = m_min.cwiseMax(b.m_min);
    m_max = m_max.cwiseMin(b.m_max);
    return *this;
  }
template<typename _Scalar, int _AmbientDim>
template<typename Derived >
bool Eigen::AlignedBox< _Scalar, _AmbientDim >::contains ( const MatrixBase< Derived > &  p) const [inline]
Returns:
true if the point p is inside the box *this.

Definition at line 182 of file AlignedBox.h.

  {
    typename internal::nested_eval<Derived,2>::type p_n(p.derived());
    return (m_min.array()<=p_n.array()).all() && (p_n.array()<=m_max.array()).all();
  }
template<typename _Scalar, int _AmbientDim>
bool Eigen::AlignedBox< _Scalar, _AmbientDim >::contains ( const AlignedBox< _Scalar, _AmbientDim > &  b) const [inline]
Returns:
true if the box b is entirely inside the box *this.

Definition at line 189 of file AlignedBox.h.

  { return (m_min.array()<=(b.min)().array()).all() && ((b.max)().array()<=m_max.array()).all(); }
template<typename _Scalar, int _AmbientDim>
VectorType Eigen::AlignedBox< _Scalar, _AmbientDim >::corner ( CornerType  corner) const [inline]
Returns:
the vertex of the bounding box at the corner defined by the corner-id corner. It works only for a 1D, 2D or 3D bounding box. For 1D bounding boxes corners are named by 2 enum constants: BottomLeft and BottomRight. For 2D bounding boxes, corners are named by 4 enum constants: BottomLeft, BottomRight, TopLeft, TopRight. For 3D bounding boxes, the following names are added: BottomLeftCeil, BottomRightCeil, TopLeftCeil, TopRightCeil.

Definition at line 146 of file AlignedBox.h.

  {
    EIGEN_STATIC_ASSERT(_AmbientDim <= 3, THIS_METHOD_IS_ONLY_FOR_VECTORS_OF_A_SPECIFIC_SIZE);

    VectorType res;

    Index mult = 1;
    for(Index d=0; d<dim(); ++d)
    {
      if( mult & corner ) res[d] = m_max[d];
      else                res[d] = m_min[d];
      mult *= 2;
    }
    return res;
  }
template<typename _Scalar, int _AmbientDim>
CwiseBinaryOp< internal::scalar_difference_op<Scalar>, const VectorType, const VectorType> Eigen::AlignedBox< _Scalar, _AmbientDim >::diagonal ( ) const [inline]
Returns:
an expression for the bounding box diagonal vector if the length of the diagonal is needed: diagonal().norm() will provide it.

Definition at line 134 of file AlignedBox.h.

  { return sizes(); }
template<typename _Scalar, int _AmbientDim>
Index Eigen::AlignedBox< _Scalar, _AmbientDim >::dim ( ) const [inline]
Returns:
the dimension in which the box holds

Definition at line 84 of file AlignedBox.h.

{ return AmbientDimAtCompileTime==Dynamic ? m_min.size() : Index(AmbientDimAtCompileTime); }
template<typename _Scalar, int _AmbientDim>
template<typename Derived >
AlignedBox& Eigen::AlignedBox< _Scalar, _AmbientDim >::extend ( const MatrixBase< Derived > &  p) [inline]

Extends *this such that it contains the point p and returns a reference to *this.

See also:
extend(const AlignedBox&)

Definition at line 200 of file AlignedBox.h.

  {
    typename internal::nested_eval<Derived,2>::type p_n(p.derived());
    m_min = m_min.cwiseMin(p_n);
    m_max = m_max.cwiseMax(p_n);
    return *this;
  }
template<typename _Scalar, int _AmbientDim>
AlignedBox& Eigen::AlignedBox< _Scalar, _AmbientDim >::extend ( const AlignedBox< _Scalar, _AmbientDim > &  b) [inline]

Extends *this such that it contains the box b and returns a reference to *this.

See also:
merged, extend(const MatrixBase&)

Definition at line 210 of file AlignedBox.h.

  {
    m_min = m_min.cwiseMin(b.m_min);
    m_max = m_max.cwiseMax(b.m_max);
    return *this;
  }
template<typename _Scalar, int _AmbientDim>
template<typename Derived >
NonInteger Eigen::AlignedBox< _Scalar, _AmbientDim >::exteriorDistance ( const MatrixBase< Derived > &  p) const [inline]
Returns:
the distance between the point p and the box *this, and zero if p is inside the box.
See also:
squaredExteriorDistance(const MatrixBase&), exteriorDistance(const AlignedBox&)

Definition at line 267 of file AlignedBox.h.

  { using std::sqrt; return sqrt(NonInteger(squaredExteriorDistance(p))); }
template<typename _Scalar, int _AmbientDim>
NonInteger Eigen::AlignedBox< _Scalar, _AmbientDim >::exteriorDistance ( const AlignedBox< _Scalar, _AmbientDim > &  b) const [inline]
Returns:
the distance between the boxes b and *this, and zero if the boxes intersect.
See also:
squaredExteriorDistance(const AlignedBox&), exteriorDistance(const MatrixBase&)

Definition at line 274 of file AlignedBox.h.

  { using std::sqrt; return sqrt(NonInteger(squaredExteriorDistance(b))); }
template<typename _Scalar, int _AmbientDim>
AlignedBox Eigen::AlignedBox< _Scalar, _AmbientDim >::intersection ( const AlignedBox< _Scalar, _AmbientDim > &  b) const [inline]

Returns an AlignedBox that is the intersection of b and *this

Note:
If the boxes don't intersect, the resulting box is empty.
See also:
intersects(), clamp, contains()

Definition at line 230 of file AlignedBox.h.

  {return AlignedBox(m_min.cwiseMax(b.m_min), m_max.cwiseMin(b.m_max)); }
template<typename _Scalar, int _AmbientDim>
bool Eigen::AlignedBox< _Scalar, _AmbientDim >::intersects ( const AlignedBox< _Scalar, _AmbientDim > &  b) const [inline]
Returns:
true if the box b is intersecting the box *this.
See also:
intersection, clamp

Definition at line 194 of file AlignedBox.h.

  { return (m_min.array()<=(b.max)().array()).all() && ((b.min)().array()<=m_max.array()).all(); }
template<typename _Scalar, int _AmbientDim>
bool Eigen::AlignedBox< _Scalar, _AmbientDim >::isApprox ( const AlignedBox< _Scalar, _AmbientDim > &  other,
const RealScalar &  prec = ScalarTraits::dummy_precision() 
) const [inline]
Returns:
true if *this is approximately equal to other, within the precision determined by prec.
See also:
MatrixBase::isApprox()

Definition at line 302 of file AlignedBox.h.

  { return m_min.isApprox(other.m_min, prec) && m_max.isApprox(other.m_max, prec); }
template<typename _Scalar, int _AmbientDim>
bool Eigen::AlignedBox< _Scalar, _AmbientDim >::isEmpty ( ) const [inline]
Returns:
true if the box is empty.
See also:
setEmpty

Definition at line 94 of file AlignedBox.h.

{ return (m_min.array() > m_max.array()).any(); }
template<typename _Scalar, int _AmbientDim>
bool Eigen::AlignedBox< _Scalar, _AmbientDim >::isNull ( ) const [inline]
Deprecated:
use isEmpty()

Definition at line 87 of file AlignedBox.h.

{ return isEmpty(); }
template<typename _Scalar, int _AmbientDim>
const VectorType&() Eigen::AlignedBox< _Scalar, _AmbientDim >::max ( ) const [inline]
Returns:
the maximal corner

Definition at line 109 of file AlignedBox.h.

{ return m_max; }
template<typename _Scalar, int _AmbientDim>
VectorType&() Eigen::AlignedBox< _Scalar, _AmbientDim >::max ( ) [inline]
Returns:
a non const reference to the maximal corner

Definition at line 111 of file AlignedBox.h.

{ return m_max; }
template<typename _Scalar, int _AmbientDim>
AlignedBox Eigen::AlignedBox< _Scalar, _AmbientDim >::merged ( const AlignedBox< _Scalar, _AmbientDim > &  b) const [inline]

Returns an AlignedBox that is the union of b and *this.

Note:
Merging with an empty box may result in a box bigger than *this.
See also:
extend(const AlignedBox&)

Definition at line 236 of file AlignedBox.h.

  { return AlignedBox(m_min.cwiseMin(b.m_min), m_max.cwiseMax(b.m_max)); }
template<typename _Scalar, int _AmbientDim>
const VectorType&() Eigen::AlignedBox< _Scalar, _AmbientDim >::min ( ) const [inline]
Returns:
the minimal corner

Definition at line 105 of file AlignedBox.h.

{ return m_min; }
template<typename _Scalar, int _AmbientDim>
VectorType&() Eigen::AlignedBox< _Scalar, _AmbientDim >::min ( ) [inline]
Returns:
a non const reference to the minimal corner

Definition at line 107 of file AlignedBox.h.

{ return m_min; }
template<typename _Scalar, int _AmbientDim>
VectorType Eigen::AlignedBox< _Scalar, _AmbientDim >::sample ( ) const [inline]
Returns:
a random point inside the bounding box sampled with a uniform distribution

Definition at line 164 of file AlignedBox.h.

  {
    VectorType r(dim());
    for(Index d=0; d<dim(); ++d)
    {
      if(!ScalarTraits::IsInteger)
      {
        r[d] = m_min[d] + (m_max[d]-m_min[d])
             * internal::random<Scalar>(Scalar(0), Scalar(1));
      }
      else
        r[d] = internal::random(m_min[d], m_max[d]);
    }
    return r;
  }
template<typename _Scalar, int _AmbientDim>
void Eigen::AlignedBox< _Scalar, _AmbientDim >::setEmpty ( ) [inline]

Makes *this an empty box.

See also:
isEmpty

Definition at line 98 of file AlignedBox.h.

  {
    m_min.setConstant( ScalarTraits::highest() );
    m_max.setConstant( ScalarTraits::lowest() );
  }
template<typename _Scalar, int _AmbientDim>
void Eigen::AlignedBox< _Scalar, _AmbientDim >::setNull ( ) [inline]
Deprecated:
use setEmpty()

Definition at line 90 of file AlignedBox.h.

{ setEmpty(); }
template<typename _Scalar, int _AmbientDim>
const CwiseBinaryOp< internal::scalar_difference_op<Scalar>, const VectorType, const VectorType> Eigen::AlignedBox< _Scalar, _AmbientDim >::sizes ( ) const [inline]
Returns:
the lengths of the sides of the bounding box. Note that this function does not get the same result for integral or floating scalar types: see

Definition at line 123 of file AlignedBox.h.

  { return m_max - m_min; }
template<typename Scalar , int AmbientDim>
template<typename Derived >
Scalar Eigen::AlignedBox< Scalar, AmbientDim >::squaredExteriorDistance ( const MatrixBase< Derived > &  p) const [inline]
Returns:
the squared distance between the point p and the box *this, and zero if p is inside the box.
See also:
exteriorDistance(const MatrixBase&), squaredExteriorDistance(const AlignedBox&)

Definition at line 314 of file AlignedBox.h.

{
  typename internal::nested_eval<Derived,2*AmbientDim>::type p(a_p.derived());
  Scalar dist2(0);
  Scalar aux;
  for (Index k=0; k<dim(); ++k)
  {
    if( m_min[k] > p[k] )
    {
      aux = m_min[k] - p[k];
      dist2 += aux*aux;
    }
    else if( p[k] > m_max[k] )
    {
      aux = p[k] - m_max[k];
      dist2 += aux*aux;
    }
  }
  return dist2;
}
template<typename Scalar , int AmbientDim>
Scalar Eigen::AlignedBox< Scalar, AmbientDim >::squaredExteriorDistance ( const AlignedBox< _Scalar, _AmbientDim > &  b) const [inline]
Returns:
the squared distance between the boxes b and *this, and zero if the boxes intersect.
See also:
exteriorDistance(const AlignedBox&), squaredExteriorDistance(const MatrixBase&)

Definition at line 336 of file AlignedBox.h.

{
  Scalar dist2(0);
  Scalar aux;
  for (Index k=0; k<dim(); ++k)
  {
    if( m_min[k] > b.m_max[k] )
    {
      aux = m_min[k] - b.m_max[k];
      dist2 += aux*aux;
    }
    else if( b.m_min[k] > m_max[k] )
    {
      aux = b.m_min[k] - m_max[k];
      dist2 += aux*aux;
    }
  }
  return dist2;
}
template<typename _Scalar, int _AmbientDim>
template<typename Derived >
AlignedBox& Eigen::AlignedBox< _Scalar, _AmbientDim >::translate ( const MatrixBase< Derived > &  a_t) [inline]

Translate *this by the vector t and returns a reference to *this.

Definition at line 241 of file AlignedBox.h.

  {
    const typename internal::nested_eval<Derived,2>::type t(a_t.derived());
    m_min += t;
    m_max += t;
    return *this;
  }
template<typename _Scalar, int _AmbientDim>
Scalar Eigen::AlignedBox< _Scalar, _AmbientDim >::volume ( ) const [inline]
Returns:
the volume of the bounding box

Definition at line 127 of file AlignedBox.h.

  { return sizes().prod(); }

Member Data Documentation

template<typename _Scalar, int _AmbientDim>
VectorType Eigen::AlignedBox< _Scalar, _AmbientDim >::m_max [protected]

Definition at line 307 of file AlignedBox.h.

template<typename _Scalar, int _AmbientDim>
VectorType Eigen::AlignedBox< _Scalar, _AmbientDim >::m_min [protected]

Definition at line 307 of file AlignedBox.h.

The documentation for this class was generated from the following file:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines