g2o::Plane3D Class Reference

#include <plane3d.h>

Public Member Functions
	Plane3D ()
	Plane3D (const Vector4 &v)
Vector4	toVector () const
const Vector4 &	coeffs () const
void	fromVector (const Vector4 &coeffs_)
double	distance () const
Vector3	normal () const
void	oplus (const Vector3 &v)
Vector3	ominus (const Plane3D &plane)

Static Public Member Functions
static double	azimuth (const Vector3 &v)
static double	elevation (const Vector3 &v)
static Matrix3	rotation (const Vector3 &v)

Public Attributes
	EIGEN_MAKE_ALIGNED_OPERATOR_NEW

Static Protected Member Functions
static void	normalize (Vector4 &coeffs)

Protected Attributes
Vector4	_coeffs

Friends
Plane3D	operator* (const Isometry3 &t, const Plane3D &plane)

Detailed Description

Definition at line 38 of file plane3d.h.

Constructor & Destructor Documentation

Plane3D() [1/2]

g2o::Plane3D::Plane3D ( )

inline

Definition at line 44 of file plane3d.h.

{ fromVector(Vector4(1., 0., 0., -1.)); }

References fromVector().

Referenced by ominus(), and operator*.

Plane3D() [2/2]

g2o::Plane3D::Plane3D ( const Vector4 & v )

inline

Definition at line 46 of file plane3d.h.

{ fromVector(v); }

References fromVector().

Member Function Documentation

azimuth()

double g2o::Plane3D::azimuth ( const Vector3 & v )

inlinestatic

Definition at line 57 of file plane3d.h.

{ return std::atan2(v(1), v(0)); }

Referenced by main(), ominus(), and rotation().

coeffs()

const Vector4 & g2o::Plane3D::coeffs ( ) const

inline

Definition at line 50 of file plane3d.h.

{ return _coeffs; }

References _coeffs.

Referenced by normalize().

distance()

double g2o::Plane3D::distance ( ) const

inline

Definition at line 63 of file plane3d.h.

{ return -_coeffs(3); }

References _coeffs.

Referenced by ominus(), and oplus().

elevation()

double g2o::Plane3D::elevation ( const Vector3 & v )

inlinestatic

Definition at line 59 of file plane3d.h.

                                            {
    return std::atan2(v(2), v.head<2>().norm());
  }

Referenced by main(), ominus(), and rotation().

fromVector()

void g2o::Plane3D::fromVector ( const Vector4 & coeffs_ )

inline

Definition at line 52 of file plane3d.h.

                                                 {
    _coeffs = coeffs_;
    normalize(_coeffs);
  }

References _coeffs, and normalize().

Referenced by main(), main(), Plane3D(), and Plane3D().

normal()

Vector3 g2o::Plane3D::normal ( ) const

inline

Definition at line 65 of file plane3d.h.

{ return _coeffs.head<3>(); }

References _coeffs.

Referenced by main(), ominus(), and oplus().

normalize()

void g2o::Plane3D::normalize ( Vector4 & coeffs )

inlinestaticprotected

Definition at line 99 of file plane3d.h.

                                                {
    double n = coeffs.head<3>().norm();
    coeffs = coeffs * (1. / n);
  }

References coeffs().

Referenced by fromVector(), and oplus().

ominus()

Vector3 g2o::Plane3D::ominus ( const Plane3D & plane )

inline

Definition at line 90 of file plane3d.h.

                                              {
    // construct the rotation that would bring the plane normal in (1 0 0)
    Matrix3 R = rotation(normal()).transpose();
    Vector3 n = R * plane.normal();
    double d = distance() - plane.distance();
    return Vector3(azimuth(n), elevation(n), d);
  }

References azimuth(), distance(), elevation(), normal(), Plane3D(), and rotation().

Referenced by g2o::EdgeSE3PlaneSensorCalib::computeError(), and main().

oplus()

void g2o::Plane3D::oplus ( const Vector3 & v )

inline

Definition at line 75 of file plane3d.h.

                                      {
    // construct a normal from azimuth and elevation;
    double _azimuth = v[0];
    double _elevation = v[1];
    double s = std::sin(_elevation), c = std::cos(_elevation);
    Vector3 n(c * std::cos(_azimuth), c * std::sin(_azimuth), s);
 
    // rotate the normal
    Matrix3 R = rotation(normal());
    double d = distance() + v[2];
    _coeffs.head<3>() = R * n;
    _coeffs(3) = -d;
    normalize(_coeffs);
  }

References _coeffs, distance(), normal(), normalize(), and rotation().

Referenced by main(), and PlaneSensor::sense().

rotation()

Matrix3 g2o::Plane3D::rotation ( const Vector3 & v )

inlinestatic

Definition at line 67 of file plane3d.h.

                                            {
    double _azimuth = azimuth(v);
    double _elevation = elevation(v);
    return (AngleAxis(_azimuth, Vector3::UnitZ()) *
            AngleAxis(-_elevation, Vector3::UnitY()))
        .toRotationMatrix();
  }

References azimuth(), and elevation().

Referenced by ominus(), and oplus().

toVector()

Vector4 g2o::Plane3D::toVector ( ) const

inline

Definition at line 48 of file plane3d.h.

{ return _coeffs; }

References _coeffs.

Referenced by g2o::EdgePlane::computeError(), operator<<(), and g2o::EdgePlane::setMeasurementFromState().

Friends And Related Symbol Documentation

operator*

Plane3D operator* ( const Isometry3 & t, const Plane3D & plane )

friend

Definition at line 107 of file plane3d.h.

                                                                   {
  Vector4 v = plane._coeffs;
  Vector4 v2;
  Matrix3 R = t.rotation();
  v2.head<3>() = R * v.head<3>();
  v2(3) = v(3) - t.translation().dot(v2.head<3>());
  return Plane3D(v2);
};

References _coeffs, and Plane3D().

Member Data Documentation

_coeffs

Vector4 g2o::Plane3D::_coeffs

protected

Definition at line 104 of file plane3d.h.

Referenced by coeffs(), distance(), fromVector(), normal(), operator*, oplus(), and toVector().

EIGEN_MAKE_ALIGNED_OPERATOR_NEW

g2o::Plane3D::EIGEN_MAKE_ALIGNED_OPERATOR_NEW

Definition at line 40 of file plane3d.h.

---

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

• /build/reproducible-path/g2o-0~20230806/g2o/types/slam3d_addons/plane3d.h