Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ > Class Template Reference

A hyperplane. More...

Public Types
enum	{   AmbientDimAtCompileTime ,   Options }
typedef Matrix< Scalar, Index(AmbientDimAtCompileTime)==Dynamic ? Dynamic :Index(AmbientDimAtCompileTime)+1, 1, Options >	Coefficients
typedef const Block< const Coefficients, AmbientDimAtCompileTime, 1 >	ConstNormalReturnType
typedef Eigen::Index	Index
typedef Block< Coefficients, AmbientDimAtCompileTime, 1 >	NormalReturnType
typedef NumTraits< Scalar >::Real	RealScalar
typedef Scalar_	Scalar
typedef Matrix< Scalar, AmbientDimAtCompileTime, 1 >	VectorType

Public Member Functions
Scalar	absDistance (const VectorType &p) const
template<typename NewScalarType >
internal::cast_return_type< Hyperplane, Hyperplane< NewScalarType, AmbientDimAtCompileTime, Options > >::type	cast () const
Coefficients &	coeffs ()
const Coefficients &	coeffs () const
Index	dim () const
	Hyperplane ()
template<typename OtherScalarType , int OtherOptions>
	Hyperplane (const Hyperplane< OtherScalarType, AmbientDimAtCompileTime, OtherOptions > &other)
template<int OtherOptions>
	Hyperplane (const Hyperplane< Scalar, AmbientDimAtCompileTime, OtherOptions > &other)
	Hyperplane (const ParametrizedLine< Scalar, AmbientDimAtCompileTime > &parametrized)
	Hyperplane (const VectorType &n, const Scalar &d)
	Hyperplane (const VectorType &n, const VectorType &e)
	Hyperplane (Index _dim)
VectorType	intersection (const Hyperplane &other) const
template<int OtherOptions>
bool	isApprox (const Hyperplane< Scalar, AmbientDimAtCompileTime, OtherOptions > &other, const typename NumTraits< Scalar >::Real &prec=NumTraits< Scalar >::dummy_precision()) const
NormalReturnType	normal ()
ConstNormalReturnType	normal () const
void	normalize (void)
Scalar &	offset ()
const Scalar &	offset () const
VectorType	projection (const VectorType &p) const
Scalar	signedDistance (const VectorType &p) const
template<typename XprType >
Hyperplane &	transform (const MatrixBase< XprType > &mat, TransformTraits traits=Affine)
template<int TrOptions>
Hyperplane &	transform (const Transform< Scalar, AmbientDimAtCompileTime, Affine, TrOptions > &t, TransformTraits traits=Affine)
	~Hyperplane ()

Static Public Member Functions
static Hyperplane	Through (const VectorType &p0, const VectorType &p1)
static Hyperplane	Through (const VectorType &p0, const VectorType &p1, const VectorType &p2)

Protected Attributes
Coefficients	m_coeffs

Detailed Description

template<typename Scalar_, int AmbientDim_, int Options_>
class Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >

A hyperplane.

This is defined in the Geometry module.

#include <Eigen/Geometry> 

A hyperplane is an affine subspace of dimension n-1 in a space of dimension n. For example, a hyperplane in a plane is a line; a hyperplane in 3-space is a plane.

Template Parameters

Scalar_	the scalar type, i.e., the type of the coefficients
AmbientDim_	the dimension of the ambient space, can be a compile time value or Dynamic. Notice that the dimension of the hyperplane is AmbientDim_-1.

This class represents an hyperplane as the zero set of the implicit equation \( n \cdot x + d = 0 \) where \( n \) is a unit normal vector of the plane (linear part) and \( d \) is the distance (offset) to the origin.

Definition at line 36 of file Hyperplane.h.

Member Typedef Documentation

Coefficients

template<typename Scalar_ , int AmbientDim_, int Options_>

typedef Matrix<Scalar,Index(AmbientDimAtCompileTime)==Dynamic ? Dynamic : Index(AmbientDimAtCompileTime)+1,1,Options> Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::Coefficients

Definition at line 50 of file Hyperplane.h.

ConstNormalReturnType

template<typename Scalar_ , int AmbientDim_, int Options_>

typedef const Block<const Coefficients,AmbientDimAtCompileTime,1> Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::ConstNormalReturnType

Definition at line 52 of file Hyperplane.h.

Index

template<typename Scalar_ , int AmbientDim_, int Options_>

typedef Eigen::Index Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::Index

Deprecated:

since Eigen 3.3

Definition at line 46 of file Hyperplane.h.

NormalReturnType

template<typename Scalar_ , int AmbientDim_, int Options_>

typedef Block<Coefficients,AmbientDimAtCompileTime,1> Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::NormalReturnType

Definition at line 51 of file Hyperplane.h.

RealScalar

template<typename Scalar_ , int AmbientDim_, int Options_>

typedef NumTraits<Scalar>::Real Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::RealScalar

Definition at line 45 of file Hyperplane.h.

Scalar

template<typename Scalar_ , int AmbientDim_, int Options_>

typedef Scalar_ Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::Scalar

Definition at line 44 of file Hyperplane.h.

VectorType

template<typename Scalar_ , int AmbientDim_, int Options_>

typedef Matrix<Scalar,AmbientDimAtCompileTime,1> Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::VectorType

Definition at line 47 of file Hyperplane.h.

Member Enumeration Documentation

anonymous enum

template<typename Scalar_ , int AmbientDim_, int Options_>

anonymous enum

Enumerator
AmbientDimAtCompileTime
Options

Definition at line 40 of file Hyperplane.h.

       {
    AmbientDimAtCompileTime = AmbientDim_,
    Options = Options_
  };

Constructor & Destructor Documentation

Hyperplane() [1/7]

template<typename Scalar_ , int AmbientDim_, int Options_>

Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::Hyperplane ( )

inline

Default constructor without initialization

Definition at line 55 of file Hyperplane.h.

{}

Hyperplane() [2/7]

template<typename Scalar_ , int AmbientDim_, int Options_>

template<int OtherOptions>

Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::Hyperplane ( const Hyperplane< Scalar, AmbientDimAtCompileTime, OtherOptions > &  other )

inline

Definition at line 58 of file Hyperplane.h.

   : m_coeffs(other.coeffs())
  {}

Hyperplane() [3/7]

template<typename Scalar_ , int AmbientDim_, int Options_>

Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::Hyperplane ( Index  _dim )

inlineexplicit

Constructs a dynamic-size hyperplane with _dim the dimension of the ambient space

Definition at line 64 of file Hyperplane.h.

: m_coeffs(_dim+1) {}

Hyperplane() [4/7]

template<typename Scalar_ , int AmbientDim_, int Options_>

Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::Hyperplane ( const VectorType &  n, const VectorType &  e  )

inline

Construct a plane from its normal n and a point e onto the plane.

Warning

the vector normal is assumed to be normalized.

Definition at line 69 of file Hyperplane.h.

    : m_coeffs(n.size()+1)
  {
    normal() = n;
    offset() = -n.dot(e);
  }

Hyperplane() [5/7]

template<typename Scalar_ , int AmbientDim_, int Options_>

Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::Hyperplane ( const VectorType &  n, const Scalar &  d  )

inline

Constructs a plane from its normal n and distance to the origin d such that the algebraic equation of the plane is \( n \cdot x + d = 0 \).

Warning

the vector normal is assumed to be normalized.

Definition at line 80 of file Hyperplane.h.

    : m_coeffs(n.size()+1)
  {
    normal() = n;
    offset() = d;
  }

Hyperplane() [6/7]

template<typename Scalar_ , int AmbientDim_, int Options_>

Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::Hyperplane ( const ParametrizedLine< Scalar, AmbientDimAtCompileTime > &  parametrized )

inlineexplicit

Constructs a hyperplane passing through the parametrized line parametrized. If the dimension of the ambient space is greater than 2, then there isn't uniqueness, so an arbitrary choice is made.

Definition at line 125 of file Hyperplane.h.

  {
    normal() = parametrized.direction().unitOrthogonal();
    offset() = -parametrized.origin().dot(normal());
  }

~Hyperplane()

template<typename Scalar_ , int AmbientDim_, int Options_>

Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::~Hyperplane ( )

inline

Definition at line 131 of file Hyperplane.h.

{}

Hyperplane() [7/7]

template<typename Scalar_ , int AmbientDim_, int Options_>

template<typename OtherScalarType , int OtherOptions>

Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::Hyperplane ( const Hyperplane< OtherScalarType, AmbientDimAtCompileTime, OtherOptions > &  other )

inlineexplicit

Copy constructor with scalar type conversion

Definition at line 266 of file Hyperplane.h.

  { m_coeffs = other.coeffs().template cast<Scalar>(); }

Member Function Documentation

absDistance()

template<typename Scalar_ , int AmbientDim_, int Options_>

Scalar Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::absDistance ( const VectorType &  p ) const

inline

Returns

the absolute distance between the plane *this and a point p.

See also

signedDistance()

Definition at line 150 of file Hyperplane.h.

{ return numext::abs(signedDistance(p)); }

cast()

template<typename Scalar_ , int AmbientDim_, int Options_>

template<typename NewScalarType >

internal::cast_return_type<Hyperplane, Hyperplane<NewScalarType,AmbientDimAtCompileTime,Options> >::type Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::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 258 of file Hyperplane.h.

  {
    return typename internal::cast_return_type<Hyperplane,
                    Hyperplane<NewScalarType,AmbientDimAtCompileTime,Options> >::type(*this);
  }

coeffs() [1/2]

template<typename Scalar_ , int AmbientDim_, int Options_>

Coefficients& Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::coeffs ( )

inline

Returns

a non-constant reference to the coefficients c_i of the plane equation: \( c_0*x_0 + ... + c_{d-1}*x_{d-1} + c_d = 0 \)

Definition at line 183 of file Hyperplane.h.

{ return m_coeffs; }

coeffs() [2/2]

template<typename Scalar_ , int AmbientDim_, int Options_>

const Coefficients& Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::coeffs ( ) const

inline

Returns

a constant reference to the coefficients c_i of the plane equation: \( c_0*x_0 + ... + c_{d-1}*x_{d-1} + c_d = 0 \)

Definition at line 178 of file Hyperplane.h.

{ return m_coeffs; }

dim()

template<typename Scalar_ , int AmbientDim_, int Options_>

Index Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::dim ( ) const

inline

Returns

the dimension in which the plane holds

Definition at line 134 of file Hyperplane.h.

{ return AmbientDimAtCompileTime==Dynamic ? m_coeffs.size()-1 : Index(AmbientDimAtCompileTime); }

intersection()

template<typename Scalar_ , int AmbientDim_, int Options_>

VectorType Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::intersection ( const Hyperplane< Scalar_, AmbientDim_, Options_ > &  other ) const

inline

Returns

the intersection of *this with other.

Warning

The ambient space must be a plane, i.e. have dimension 2, so that *this and other are lines.

Note

If other is approximately parallel to *this, this method will return any point on *this.

Definition at line 191 of file Hyperplane.h.

  {
    EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(VectorType, 2)
    Scalar det = coeffs().coeff(0) * other.coeffs().coeff(1) - coeffs().coeff(1) * other.coeffs().coeff(0);
    // since the line equations ax+by=c are normalized with a^2+b^2=1, the following tests
    // whether the two lines are approximately parallel.
    if(internal::isMuchSmallerThan(det, Scalar(1)))
    {   // special case where the two lines are approximately parallel. Pick any point on the first line.
        if(numext::abs(coeffs().coeff(1))>numext::abs(coeffs().coeff(0)))
            return VectorType(coeffs().coeff(1), -coeffs().coeff(2)/coeffs().coeff(1)-coeffs().coeff(0));
        else
            return VectorType(-coeffs().coeff(2)/coeffs().coeff(0)-coeffs().coeff(1), coeffs().coeff(0));
    }
    else
    {   // general case
        Scalar invdet = Scalar(1) / det;
        return VectorType(invdet*(coeffs().coeff(1)*other.coeffs().coeff(2)-other.coeffs().coeff(1)*coeffs().coeff(2)),
                          invdet*(other.coeffs().coeff(0)*coeffs().coeff(2)-coeffs().coeff(0)*other.coeffs().coeff(2)));
    }
  }

isApprox()

template<typename Scalar_ , int AmbientDim_, int Options_>

template<int OtherOptions>

bool Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::isApprox ( const Hyperplane< Scalar, AmbientDimAtCompileTime, OtherOptions > &  other, const typename NumTraits< Scalar >::Real &  prec = NumTraits<Scalar>::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 274 of file Hyperplane.h.

  { return m_coeffs.isApprox(other.m_coeffs, prec); }

normal() [1/2]

template<typename Scalar_ , int AmbientDim_, int Options_>

NormalReturnType Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::normal ( )

inline

Returns

a non-constant reference to the unit normal vector of the plane, which corresponds to the linear part of the implicit equation.

Definition at line 164 of file Hyperplane.h.

{ return NormalReturnType(m_coeffs,0,0,dim(),1); }

normal() [2/2]

template<typename Scalar_ , int AmbientDim_, int Options_>

ConstNormalReturnType Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::normal ( ) const

inline

Returns

a constant reference to the unit normal vector of the plane, which corresponds to the linear part of the implicit equation.

Definition at line 159 of file Hyperplane.h.

{ return ConstNormalReturnType(m_coeffs,0,0,dim(),1); }

normalize()

template<typename Scalar_ , int AmbientDim_, int Options_>

void Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::normalize ( void  )

inline

normalizes *this

Definition at line 137 of file Hyperplane.h.

  {
    m_coeffs /= normal().norm();
  }

offset() [1/2]

template<typename Scalar_ , int AmbientDim_, int Options_>

Scalar& Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::offset ( )

inline

Returns

a non-constant reference to the distance to the origin, which is also the constant part of the implicit equation

Definition at line 173 of file Hyperplane.h.

{ return m_coeffs(dim()); }

offset() [2/2]

template<typename Scalar_ , int AmbientDim_, int Options_>

const Scalar& Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::offset ( ) const

inline

Returns

the distance to the origin, which is also the "constant term" of the implicit equation

Warning

the vector normal is assumed to be normalized.

Definition at line 169 of file Hyperplane.h.

{ return m_coeffs.coeff(dim()); }

projection()

template<typename Scalar_ , int AmbientDim_, int Options_>

VectorType Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::projection ( const VectorType &  p ) const

inline

Returns

the projection of a point p onto the plane *this.

Definition at line 154 of file Hyperplane.h.

{ return p - signedDistance(p) * normal(); }

signedDistance()

template<typename Scalar_ , int AmbientDim_, int Options_>

Scalar Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::signedDistance ( const VectorType &  p ) const

inline

Returns

the signed distance between the plane *this and a point p.

See also

absDistance()

Definition at line 145 of file Hyperplane.h.

{ return normal().dot(p) + offset(); }

Through() [1/2]

template<typename Scalar_ , int AmbientDim_, int Options_>

static Hyperplane Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::Through ( const VectorType &  p0, const VectorType &  p1  )

inlinestatic

Constructs a hyperplane passing through the two points. If the dimension of the ambient space is greater than 2, then there isn't uniqueness, so an arbitrary choice is made.

Definition at line 90 of file Hyperplane.h.

  {
    Hyperplane result(p0.size());
    result.normal() = (p1 - p0).unitOrthogonal();
    result.offset() = -p0.dot(result.normal());
    return result;
  }

Through() [2/2]

template<typename Scalar_ , int AmbientDim_, int Options_>

static Hyperplane Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::Through ( const VectorType &  p0, const VectorType &  p1, const VectorType &  p2  )

inlinestatic

Constructs a hyperplane passing through the three points. The dimension of the ambient space is required to be exactly 3.

Definition at line 101 of file Hyperplane.h.

  {
    EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(VectorType, 3)
    Hyperplane result(p0.size());
    VectorType v0(p2 - p0), v1(p1 - p0);
    result.normal() = v0.cross(v1);
    RealScalar norm = result.normal().norm();
    if(norm <= v0.norm() * v1.norm() * NumTraits<RealScalar>::epsilon())
    {
      Matrix<Scalar,2,3> m; m << v0.transpose(), v1.transpose();
      JacobiSVD<Matrix<Scalar,2,3>, ComputeFullV> svd(m);
      result.normal() = svd.matrixV().col(2);
    }
    else
      result.normal() /= norm;
    result.offset() = -p0.dot(result.normal());
    return result;
  }

transform() [1/2]

template<typename Scalar_ , int AmbientDim_, int Options_>

template<typename XprType >

Hyperplane& Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::transform ( const MatrixBase< XprType > &  mat, TransformTraits  traits = Affine  )

inline

Applies the transformation matrix mat to *this and returns a reference to *this.

Parameters

mat	the Dim x Dim transformation matrix
traits	specifies whether the matrix mat represents an Isometry or a more generic Affine transformation. The default is Affine.

Definition at line 219 of file Hyperplane.h.

  {
    if (traits==Affine)
    {
      normal() = mat.inverse().transpose() * normal();
      m_coeffs /= normal().norm();
    }
    else if (traits==Isometry)
      normal() = mat * normal();
    else
    {
      eigen_assert(0 && "invalid traits value in Hyperplane::transform()");
    }
    return *this;
  }

transform() [2/2]

template<typename Scalar_ , int AmbientDim_, int Options_>

template<int TrOptions>

Hyperplane& Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::transform ( const Transform< Scalar, AmbientDimAtCompileTime, Affine, TrOptions > &  t, TransformTraits  traits = Affine  )

inline

Applies the transformation t to *this and returns a reference to *this.

Parameters

t	the transformation of dimension Dim
traits	specifies whether the transformation t represents an Isometry or a more generic Affine transformation. The default is Affine. Other kind of transformations are not supported.

Definition at line 243 of file Hyperplane.h.

  {
    transform(t.linear(), traits);
    offset() -= normal().dot(t.translation());
    return *this;
  }

Member Data Documentation

m_coeffs

template<typename Scalar_ , int AmbientDim_, int Options_>

Coefficients Eigen::Hyperplane< Scalar_, AmbientDim_, Options_ >::m_coeffs

protected

Definition at line 279 of file Hyperplane.h.

---

The documentation for this class was generated from the following files:

• ForwardDeclarations.h
• Hyperplane.h