Definition of a analytical line embedded in 2D space. More...

#include <hyperplane2D.h>

Collaboration diagram for olb::Hyperplane2D< T >:

Public Member Functions
	Hyperplane2D ()=default

Hyperplane2D &	originAt (const Vector< T, 2 > &origin)
	Center the line at the given origin vector.

Hyperplane2D &	centeredIn (const Cuboid2D< T > &cuboid)
	Center the line relative to the given cuboid.

Hyperplane2D &	parallelTo (const Vector< T, 2 > &direction)
	Set the direction of the line parallel to a vector.

Hyperplane2D &	normalTo (const Vector< T, 2 > &normal)
	Calculate the direction vector of the line to be orthogonal to the given normal.

bool	isParallelToX () const

bool	isParallelToY () const

Public Attributes
Vector< T, 2 >	origin

Vector< T, 2 >	u

Vector< T, 2 >	normal

Detailed Description

template<typename T>
struct olb::Hyperplane2D< T >

Definition of a analytical line embedded in 2D space.

Hyperplane2D defines a line using its origin and a direction vector.

Definition at line 37 of file hyperplane2D.h.

Constructor & Destructor Documentation

◆ Hyperplane2D()

template<typename T >

olb::Hyperplane2D< T >::Hyperplane2D ( )

default

Member Function Documentation

◆ centeredIn()

template<typename T >

Hyperplane2D< T > & olb::Hyperplane2D< T >::centeredIn ( const Cuboid2D< T > & cuboid )

Center the line relative to the given cuboid.

Returns: Hyperplane2D reference for further construction

Definition at line 44 of file hyperplane2D.hh.

{
  const Vector<T,2>& cuboidOrigin = cuboid.getOrigin();
  const Vector<int,2>& extend     = cuboid.getExtent();
  const T deltaR = cuboid.getDeltaR();
 
  origin[0] = (cuboidOrigin[0] + 0.5 * deltaR * extend[0]);
  origin[1] = (cuboidOrigin[1] + 0.5 * deltaR * extend[1]);
  origin[0] -= 2*std::numeric_limits<T>::epsilon()*util::fabs(origin[0]);
  origin[1] -= 2*std::numeric_limits<T>::epsilon()*util::fabs(origin[1]);
 
  return *this;
}

References olb::util::fabs(), olb::Cuboid2D< T >::getDeltaR(), olb::Cuboid2D< T >::getExtent(), and olb::Cuboid2D< T >::getOrigin().

Here is the call graph for this function:

◆ isParallelToX()

template<typename T >

bool olb::Hyperplane2D< T >::isParallelToX ( ) const

Returns: true iff normal is orthogonal to X axis

Definition at line 95 of file hyperplane2D.hh.

{
  return util::nearZero(util::dotProduct2D(normal, {1,0}));
}

References olb::util::dotProduct2D(), and olb::util::nearZero().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isParallelToY()

template<typename T >

bool olb::Hyperplane2D< T >::isParallelToY ( ) const

Returns: true iff normal is orthogonal to Y axis

Definition at line 101 of file hyperplane2D.hh.

{
  return util::nearZero(util::dotProduct2D(normal, {0,1}));
}

References olb::util::dotProduct2D(), and olb::util::nearZero().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ normalTo()

template<typename T >

Hyperplane2D< T > & olb::Hyperplane2D< T >::normalTo ( const Vector< T, 2 > & normal )

Calculate the direction vector of the line to be orthogonal to the given normal.

Returns: Hyperplane2D reference for further construction

Definition at line 70 of file hyperplane2D.hh.

{
  normal = n;
 
  if ( util::nearZero(normal[0]*normal[1]) ) {
    if ( util::nearZero(normal[0]) ) {
      u = {T(1), T()};
    }
    else if ( util::nearZero(normal[1]) ) {
      u = {T(), T(1)};
    }
  }
  else {
    u = {normal[1], -normal[0]};
  }
 
  u = normalize(u);
  normal = normalize(normal);
 
  OLB_POSTCONDITION(util::nearZero(util::dotProduct2D(u,normal)));
 
  return *this;
}

References olb::util::dotProduct2D(), olb::util::nearZero(), olb::normalize(), and OLB_POSTCONDITION.

Here is the call graph for this function:

◆ originAt()

template<typename T >

Hyperplane2D< T > & olb::Hyperplane2D< T >::originAt ( const Vector< T, 2 > & origin )

Center the line at the given origin vector.

Returns: Hyperplane2D reference for further construction

Definition at line 35 of file hyperplane2D.hh.

{
  origin[0] = o[0] - 2*std::numeric_limits<T>::epsilon()*util::fabs(o[0]);
  origin[1] = o[1] - 2*std::numeric_limits<T>::epsilon()*util::fabs(o[1]);
 
  return *this;
}

References olb::util::fabs().

Here is the call graph for this function:

◆ parallelTo()

template<typename T >

Hyperplane2D< T > & olb::Hyperplane2D< T >::parallelTo ( const Vector< T, 2 > & direction )

Set the direction of the line parallel to a vector.

Returns: Hyperplane2D reference for further construction

Definition at line 59 of file hyperplane2D.hh.

{
  u = direction;
  normal = normalize(Vector<T,2>({ u[1], -u[0] }));
 
  OLB_POSTCONDITION(util::nearZero(util::dotProduct2D(u,normal)));
 
  return *this;
}