Developer Documentation

Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | Private Types | List of all members
OpenMesh::CLASSNAME Class Reference
Inheritance diagram for OpenMesh::CLASSNAME:

## Public Types
typedef Scalar | value_type
| the type of the scalar used in this template
typedef VectorT< Scalar, DIM > | vector_type
| type of this vector

## Public Member Functions
| VectorT ()
| default constructor creates uninitialized values.
| VectorT (const Scalar &v)
| special constructor for 1D vectors
| VectorT (const Scalar _values[DIM])
| construct from a value array (explicit)
template<typename otherScalarType >
| VectorT (const VectorT< otherScalarType, DIM > &_rhs)
| copy & cast constructor (explicit)
template<typename otherScalarType >
vector_type & | operator= (const VectorT< otherScalarType, DIM > &_rhs)
| cast from vector with a different scalar type
Scalar * | data ()
| access to Scalar array
const Scalar * | data () const
| access to const Scalar array
Scalar & | operator[] (size_t _i)
| get i'th element read-write
const Scalar & | operator[] (size_t _i) const
| get i'th element read-only
bool | operator== (const vector_type &_rhs) const
| component-wise comparison
bool | operator!= (const vector_type &_rhs) const
| component-wise comparison
vector_type & | operator*= (const Scalar &_s)
| component-wise self-multiplication with scalar
vector_type & | operator/= (const Scalar &_s)
vector_type | operator* (const Scalar &_s) const
| component-wise multiplication with scalar
vector_type | operator/ (const Scalar &_s) const
| component-wise division by with scalar
vector_type & | operator*= (const vector_type &_rhs)
| component-wise self-multiplication
vector_type & | operator/= (const vector_type &_rhs)
| component-wise self-division
vector_type & | operator-= (const vector_type &_rhs)
| vector difference from this
vector_type & | operator+= (const vector_type &_rhs)
| vector self-addition
vector_type | operator* (const vector_type &_v) const
| component-wise vector multiplication
vector_type | operator/ (const vector_type &_v) const
| component-wise vector division
vector_type | operator+ (const vector_type &_v) const
| component-wise vector addition
vector_type | operator- (const vector_type &_v) const
| component-wise vector difference
vector_type | operator- (void) const
| unary minus
VectorT< Scalar, 3 > | operator% (const VectorT< Scalar, 3 > &_rhs) const
Scalar | operator| (const vector_type &_rhs) const
template<typename Functor >
vector_type | apply (const Functor &_func) const
| component-wise apply function object with Scalar operator()(Scalar).
vector_type & | vectorize (const Scalar &_s)
| store the same value in each component (e.g. to clear all entries)
bool | operator< (const vector_type &_rhs) const
| lexicographical comparison
Euclidean norm calculations
Scalar | norm () const
| compute euclidean norm
Scalar | length () const
| compute euclidean norm
Scalar | sqrnorm () const
| compute squared euclidean norm
vector_type & | normalize ()
const vector_type | normalized () const
vector_type & | normalize_cond ()
Non-Euclidean norm calculations
Scalar | l1_norm () const
| compute L1 (Manhattan) norm
Scalar | l8_norm () const
| compute l8_norm
Minimum maximum and mean
Scalar | max () const
| return the maximal component
Scalar | max_abs () const
| return the maximal absolute component
Scalar | min () const
| return the minimal component
Scalar | min_abs () const
| return the minimal absolute component
Scalar | mean () const
| return arithmetic mean
Scalar | mean_abs () const
| return absolute arithmetic mean
vector_type & | minimize (const vector_type &_rhs)
| minimize values: same as *this = min(*this, _rhs), but faster
bool | minimized (const vector_type &_rhs)
| minimize values and signalize coordinate minimization
vector_type & | maximize (const vector_type &_rhs)
| maximize values: same as *this = max(*this, _rhs), but faster
bool | maximized (const vector_type &_rhs)
| maximize values and signalize coordinate maximization
vector_type | min (const vector_type &_rhs) const
| component-wise min
vector_type | max (const vector_type &_rhs) const
| component-wise max

## Static Public Member Functions
static int | dim ()
| returns dimension of the vector (deprecated)
static size_t | size ()
| returns dimension of the vector
static vector_type | vectorized (const Scalar &_s)
| store the same value in each component

## Static Public Attributes
static const size_t | size_ = DIM

## Private Types
typedef DERIVED | Base

## Detailed Description

Definition at line 68 of file VectorT.hh.

## Member Function Documentation

## ◆ normalize()

vector_type& OpenMesh::CLASSNAME::normalize | ( |  | ) |
| inline

normalize vector, return normalized vector

Definition at line 433 of file VectorT.hh.

## ◆ normalize_cond()

vector_type& OpenMesh::CLASSNAME::normalize_cond | ( |  | ) |
| inline

normalize vector, return normalized vector and avoids div by zero

Definition at line 449 of file VectorT.hh.

## ◆ normalized()

const vector_type OpenMesh::CLASSNAME::normalized | ( |  | ) | const
| inline

return normalized vector

Definition at line 442 of file VectorT.hh.

## ◆ operator%()

VectorT<Scalar,3> OpenMesh::CLASSNAME::operator% | ( | const VectorT< Scalar, 3 > & | _rhs | ) | const
| inline

cross product: only defined for Vec3* as specialization

See also
  OpenMesh::cross

## ◆ operator/=()

vector_type& OpenMesh::CLASSNAME::operator/= | ( | const Scalar & | _s | ) |
| inline

component-wise self-division by scalar

Attention
  v *= (1/_s) is much faster than this

Definition at line 248 of file VectorT.hh.

## ◆ operator|()

Scalar OpenMesh::CLASSNAME::operator| | ( | const vector_type & | _rhs | ) | const
| inline

compute scalar product

See also
  OpenMesh::dot

Definition at line 394 of file VectorT.hh.

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

- OpenFlipper/libs_required/OpenMesh/src/OpenMesh/Core/Geometry/VectorT.hh