open3d::utility Namespace Reference

Namespaces
	detail_
	filesystem

Data Structures
class	bad_optional_access
class	ConsoleProgressBar
struct	ConsoleProgressUpdater
	update_progress(double percent) functor for ConsoleProgressBar More...
struct	constexpr_optional_base
union	constexpr_storage_t
class	CountingProgressReporter
class	FPSTimer
struct	hash_eigen
struct	hash_enum_class
struct	hash_tuple
struct	hash_tuple< std::tuple< TT... > >
class	IJsonConvertible
struct	in_place_t
class	Logger
struct	MiniVec
struct	nullopt_t
class	optional
class	optional< T & >
class	optional< T && >
struct	optional_base
class	ScopeTimer
union	storage_t
class	Timer
struct	trivial_init_t
class	VerbosityContextManager

Typedefs
using	Matrix4d_allocator = Eigen::aligned_allocator< Eigen::Matrix4d >
using	Matrix6d_allocator = Eigen::aligned_allocator< Eigen::Matrix6d >
using	Vector2d_allocator = Eigen::aligned_allocator< Eigen::Vector2d >
using	Vector3uint8_allocator = Eigen::aligned_allocator< Eigen::Vector3uint8 >
using	Vector4i_allocator = Eigen::aligned_allocator< Eigen::Vector4i >
using	Vector4d_allocator = Eigen::aligned_allocator< Eigen::Vector4d >
using	Vector6d_allocator = Eigen::aligned_allocator< Eigen::Vector6d >
template<class T >
using	OptionalBase = typename std::conditional< std::is_trivially_destructible< T >::value, constexpr_optional_base< typename std::remove_const< T >::type >, optional_base< typename std::remove_const< T >::type > >::type

Enumerations
enum	VerbosityLevel { VerbosityLevel::Error = 0, VerbosityLevel::Warning = 1, VerbosityLevel::Info = 2, VerbosityLevel::Debug = 3 }

Functions
std::string	GetCurrentTimeStamp ()
std::string	GetProgramOptionAsString (int argc, char **argv, const std::string &option, const std::string &default_value)
int	GetProgramOptionAsInt (int argc, char **argv, const std::string &option, const int default_value)
double	GetProgramOptionAsDouble (int argc, char **argv, const std::string &option, const double default_value)
Eigen::VectorXd	GetProgramOptionAsEigenVectorXd (int argc, char **argv, const std::string &option, const Eigen::VectorXd default_value)
bool	ProgramOptionExists (int argc, char **argv, const std::string &option)
bool	ProgramOptionExistsAny (int argc, char **argv, const std::vector< std::string > &options)
void	SetVerbosityLevel (VerbosityLevel level)
VerbosityLevel	GetVerbosityLevel ()
	Get global verbosity level of Open3D. More...
template<typename... Args>
void	LogError (const char *format, const Args &... args)
template<typename... Args>
void	LogWarning (const char *format, const Args &... args)
template<typename... Args>
void	LogInfo (const char *format, const Args &... args)
template<typename... Args>
void	LogDebug (const char *format, const Args &... args)
std::tuple< bool, Eigen::VectorXd >	SolveLinearSystemPSD (const Eigen::MatrixXd &A, const Eigen::VectorXd &b, bool prefer_sparse, bool check_symmetric, bool check_det, bool check_psd)
	Function to solve Ax=b. More...
Eigen::Matrix4d	TransformVector6dToMatrix4d (const Eigen::Vector6d &input)
Eigen::Vector6d	TransformMatrix4dToVector6d (const Eigen::Matrix4d &input)
std::tuple< bool, Eigen::Matrix4d >	SolveJacobianSystemAndObtainExtrinsicMatrix (const Eigen::Matrix6d &JTJ, const Eigen::Vector6d &JTr)
std::tuple< bool, std::vector< Eigen::Matrix4d, Matrix4d_allocator > >	SolveJacobianSystemAndObtainExtrinsicMatrixArray (const Eigen::MatrixXd &JTJ, const Eigen::VectorXd &JTr)
template<typename MatType , typename VecType >
std::tuple< MatType, VecType, double >	ComputeJTJandJTr (std::function< void(int, VecType &, double &, double &)> f, int iteration_num, bool verbose)
template<typename MatType , typename VecType >
std::tuple< MatType, VecType, double >	ComputeJTJandJTr (std::function< void(int, std::vector< VecType, Eigen::aligned_allocator< VecType >> &, std::vector< double > &, std::vector< double > &)> f, int iteration_num, bool verbose)
template std::tuple< Eigen::Matrix6d, Eigen::Vector6d, double >	ComputeJTJandJTr (std::function< void(int, Eigen::Vector6d &, double &, double &)> f, int iteration_num, bool verbose)
template std::tuple< Eigen::Matrix6d, Eigen::Vector6d, double >	ComputeJTJandJTr (std::function< void(int, std::vector< Eigen::Vector6d, Vector6d_allocator > &, std::vector< double > &, std::vector< double > &)> f, int iteration_num, bool verbose)
Eigen::Matrix3d	RotationMatrixX (double radians)
Eigen::Matrix3d	RotationMatrixY (double radians)
Eigen::Matrix3d	RotationMatrixZ (double radians)
Eigen::Vector3uint8	ColorToUint8 (const Eigen::Vector3d &color)
Eigen::Vector3d	ColorToDouble (uint8_t r, uint8_t g, uint8_t b)
	Color conversion from uint8_t 0-255 to double [0,1]. More...
Eigen::Vector3d	ColorToDouble (const Eigen::Vector3uint8 &rgb)
template<typename IdxType >
Eigen::Matrix3d	ComputeCovariance (const std::vector< Eigen::Vector3d > &points, const std::vector< IdxType > &indices)
	Function to compute the covariance matrix of a set of points. More...
template<typename IdxType >
std::tuple< Eigen::Vector3d, Eigen::Matrix3d >	ComputeMeanAndCovariance (const std::vector< Eigen::Vector3d > &points, const std::vector< IdxType > &indices)
	Function to compute the mean and covariance matrix of a set of points. More...
template Eigen::Matrix3d	ComputeCovariance (const std::vector< Eigen::Vector3d > &points, const std::vector< size_t > &indices)
template std::tuple< Eigen::Vector3d, Eigen::Matrix3d >	ComputeMeanAndCovariance (const std::vector< Eigen::Vector3d > &points, const std::vector< size_t > &indices)
template Eigen::Matrix3d	ComputeCovariance (const std::vector< Eigen::Vector3d > &points, const std::vector< int > &indices)
template std::tuple< Eigen::Vector3d, Eigen::Matrix3d >	ComputeMeanAndCovariance (const std::vector< Eigen::Vector3d > &points, const std::vector< int > &indices)
void	SplitString (std::vector< std::string > &tokens, const std::string &str, const std::string &delimiters, bool trim_empty_str)
std::string &	LeftStripString (std::string &str, const std::string &chars)
std::string &	RightStripString (std::string &str, const std::string &chars)
std::string &	StripString (std::string &str, const std::string &chars)
std::string	ToLower (const std::string &s)
	Convert string to the lower case. More...
std::string	ToUpper (const std::string &s)
	Convert string to the upper case. More...
size_t	WordLength (const std::string &doc, size_t start_pos, const std::string &valid_chars)
void	Sleep (int milliseconds)
int	UniformRandInt (const int min, const int max)
int	DivUp (int x, int y)
	Computes the quotient of x/y with rounding up. More...
template<typename T >
T	UniformRandFloatBinaryFriendly (unsigned int power=5)
template<int N>
FN_SPECIFIERS MiniVec< float, N >	floor (const MiniVec< float, N > &a)
template<int N>
FN_SPECIFIERS MiniVec< double, N >	floor (const MiniVec< double, N > &a)
template<int N>
FN_SPECIFIERS MiniVec< float, N >	ceil (const MiniVec< float, N > &a)
template<int N>
FN_SPECIFIERS MiniVec< double, N >	ceil (const MiniVec< double, N > &a)
template<class T , int N>
FN_SPECIFIERS MiniVec< T, N >	operator- (const MiniVec< T, N > &a)
template<class T , int N>
FN_SPECIFIERS MiniVec< T, N >	operator! (const MiniVec< T, N > &a)
template<class T >
constexpr T &&	constexpr_forward (typename std::remove_reference< T >::type &t) noexcept
template<class T >
constexpr T &&	constexpr_forward (typename std::remove_reference< T >::type &&t) noexcept
template<class T >
constexpr std::remove_reference< T >::type &&	constexpr_move (T &&t) noexcept
template<class T >
constexpr bool	operator== (const optional< T > &x, const optional< T > &y)
template<class T >
constexpr bool	operator!= (const optional< T > &x, const optional< T > &y)
template<class T >
constexpr bool	operator< (const optional< T > &x, const optional< T > &y)
template<class T >
constexpr bool	operator> (const optional< T > &x, const optional< T > &y)
template<class T >
constexpr bool	operator<= (const optional< T > &x, const optional< T > &y)
template<class T >
constexpr bool	operator>= (const optional< T > &x, const optional< T > &y)
template<class T >
constexpr bool	operator== (const optional< T > &x, nullopt_t) noexcept
template<class T >
constexpr bool	operator== (nullopt_t, const optional< T > &x) noexcept
template<class T >
constexpr bool	operator!= (const optional< T > &x, nullopt_t) noexcept
template<class T >
constexpr bool	operator!= (nullopt_t, const optional< T > &x) noexcept
template<class T >
constexpr bool	operator< (const optional< T > &, nullopt_t) noexcept
template<class T >
constexpr bool	operator< (nullopt_t, const optional< T > &x) noexcept
template<class T >
constexpr bool	operator<= (const optional< T > &x, nullopt_t) noexcept
template<class T >
constexpr bool	operator<= (nullopt_t, const optional< T > &) noexcept
template<class T >
constexpr bool	operator> (const optional< T > &x, nullopt_t) noexcept
template<class T >
constexpr bool	operator> (nullopt_t, const optional< T > &) noexcept
template<class T >
constexpr bool	operator>= (const optional< T > &, nullopt_t) noexcept
template<class T >
constexpr bool	operator>= (nullopt_t, const optional< T > &x) noexcept
template<class T >
constexpr bool	operator== (const optional< T > &x, const T &v)
template<class T >
constexpr bool	operator== (const T &v, const optional< T > &x)
template<class T >
constexpr bool	operator!= (const optional< T > &x, const T &v)
template<class T >
constexpr bool	operator!= (const T &v, const optional< T > &x)
template<class T >
constexpr bool	operator< (const optional< T > &x, const T &v)
template<class T >
constexpr bool	operator> (const T &v, const optional< T > &x)
template<class T >
constexpr bool	operator> (const optional< T > &x, const T &v)
template<class T >
constexpr bool	operator< (const T &v, const optional< T > &x)
template<class T >
constexpr bool	operator>= (const optional< T > &x, const T &v)
template<class T >
constexpr bool	operator<= (const T &v, const optional< T > &x)
template<class T >
constexpr bool	operator<= (const optional< T > &x, const T &v)
template<class T >
constexpr bool	operator>= (const T &v, const optional< T > &x)
template<class T >
constexpr bool	operator== (const optional< T &> &x, const T &v)
template<class T >
constexpr bool	operator== (const T &v, const optional< T &> &x)
template<class T >
constexpr bool	operator!= (const optional< T &> &x, const T &v)
template<class T >
constexpr bool	operator!= (const T &v, const optional< T &> &x)
template<class T >
constexpr bool	operator< (const optional< T &> &x, const T &v)
template<class T >
constexpr bool	operator> (const T &v, const optional< T &> &x)
template<class T >
constexpr bool	operator> (const optional< T &> &x, const T &v)
template<class T >
constexpr bool	operator< (const T &v, const optional< T &> &x)
template<class T >
constexpr bool	operator>= (const optional< T &> &x, const T &v)
template<class T >
constexpr bool	operator<= (const T &v, const optional< T &> &x)
template<class T >
constexpr bool	operator<= (const optional< T &> &x, const T &v)
template<class T >
constexpr bool	operator>= (const T &v, const optional< T &> &x)
template<class T >
constexpr bool	operator== (const optional< const T &> &x, const T &v)
template<class T >
constexpr bool	operator== (const T &v, const optional< const T &> &x)
template<class T >
constexpr bool	operator!= (const optional< const T &> &x, const T &v)
template<class T >
constexpr bool	operator!= (const T &v, const optional< const T &> &x)
template<class T >
constexpr bool	operator< (const optional< const T &> &x, const T &v)
template<class T >
constexpr bool	operator> (const T &v, const optional< const T &> &x)
template<class T >
constexpr bool	operator> (const optional< const T &> &x, const T &v)
template<class T >
constexpr bool	operator< (const T &v, const optional< const T &> &x)
template<class T >
constexpr bool	operator>= (const optional< const T &> &x, const T &v)
template<class T >
constexpr bool	operator<= (const T &v, const optional< const T &> &x)
template<class T >
constexpr bool	operator<= (const optional< const T &> &x, const T &v)
template<class T >
constexpr bool	operator>= (const T &v, const optional< const T &> &x)
template<class T >
void	swap (optional< T > &x, optional< T > &y) noexcept(noexcept(x.swap(y)))
template<class T >
constexpr optional< typename std::decay< T >::type >	make_optional (T &&v)
template<class X >
constexpr optional< X & >	make_optional (std::reference_wrapper< X > v)
template<class Tin , class Tout >
void	InclusivePrefixSum (const Tin *first, const Tin *last, Tout *out)

Variables
constexpr in_place_t	in_place {}
constexpr struct open3d::utility::trivial_init_t	trivial_init
constexpr nullopt_t	nullopt {nullopt_t::init()}

Typedef Documentation

Matrix4d_allocator

using open3d::utility::Matrix4d_allocator = typedef Eigen::aligned_allocator<Eigen::Matrix4d>

Matrix6d_allocator

using open3d::utility::Matrix6d_allocator = typedef Eigen::aligned_allocator<Eigen::Matrix6d>

OptionalBase

template<class T >

using open3d::utility::OptionalBase = typedef typename std::conditional< std::is_trivially_destructible<T>::value, constexpr_optional_base<typename std::remove_const< T>::type>, optional_base<typename std::remove_const<T>::type> >::type

Vector2d_allocator

using open3d::utility::Vector2d_allocator = typedef Eigen::aligned_allocator<Eigen::Vector2d>

Vector3uint8_allocator

using open3d::utility::Vector3uint8_allocator = typedef Eigen::aligned_allocator<Eigen::Vector3uint8>

Vector4d_allocator

using open3d::utility::Vector4d_allocator = typedef Eigen::aligned_allocator<Eigen::Vector4d>

Vector4i_allocator

using open3d::utility::Vector4i_allocator = typedef Eigen::aligned_allocator<Eigen::Vector4i>

Vector6d_allocator

using open3d::utility::Vector6d_allocator = typedef Eigen::aligned_allocator<Eigen::Vector6d>

Enumeration Type Documentation

VerbosityLevel

enum open3d::utility::VerbosityLevel

strong

Enumerator
Error	LogError throws now a runtime_error with the given error message. This should be used if there is no point in continuing the given algorithm at some point and the error is not returned in another way (e.g., via a bool/int as return value).
Warning	LogWarning is used if an error occured, but the error is also signaled via a return value (i.e., there is no need to throw an exception). This warning should further be used, if the algorithms encounters a state that does not break its continuation, but the output is likely not to be what the user expected.
Info	LogInfo is used to inform the user with expected output, e.g, pressed a key in the visualizer prints helping information.
Debug	LogDebug is used to print debug/additional information on the state of the algorithm.

Function Documentation

ceil() [1/2]

template<int N>

FN_SPECIFIERS MiniVec<float, N> open3d::utility::ceil

(

const MiniVec< float, N > &

a

)

ceil() [2/2]

template<int N>

FN_SPECIFIERS MiniVec<double, N> open3d::utility::ceil

(

const MiniVec< double, N > &

a

)

ColorToDouble() [1/2]

Eigen::Vector3d open3d::utility::ColorToDouble	(	uint8_t	r,
		uint8_t	g,
		uint8_t	b
	)

Color conversion from uint8_t 0-255 to double [0,1].

ColorToDouble() [2/2]

Eigen::Vector3d open3d::utility::ColorToDouble

(

const Eigen::Vector3uint8 &

rgb

)

ColorToUint8()

Eigen::Vector3uint8 open3d::utility::ColorToUint8

(

const Eigen::Vector3d &

color

)

Color conversion from double [0,1] to uint8_t 0-255; this does proper clipping and rounding

ComputeCovariance() [1/3]

template<typename IdxType >

Eigen::Matrix3d open3d::utility::ComputeCovariance	(	const std::vector< Eigen::Vector3d > &	points,
		const std::vector< IdxType > &	indices
	)

Function to compute the covariance matrix of a set of points.

ComputeCovariance() [2/3]

template Eigen::Matrix3d open3d::utility::ComputeCovariance	(	const std::vector< Eigen::Vector3d > &	points,
		const std::vector< size_t > &	indices
	)

ComputeCovariance() [3/3]

template Eigen::Matrix3d open3d::utility::ComputeCovariance	(	const std::vector< Eigen::Vector3d > &	points,
		const std::vector< int > &	indices
	)

ComputeJTJandJTr() [1/4]

template<typename MatType , typename VecType >

std::tuple< MatType, VecType, double > open3d::utility::ComputeJTJandJTr	(	std::function< void(int, VecType &, double &, double &)>	f,
		int	iteration_num,
		bool	verbose = true
	)

Function to compute JTJ and Jtr Input: function pointer f and total number of rows of Jacobian matrix Output: JTJ, JTr, sum of r^2 Note: f takes index of row, and outputs corresponding residual and row vector.

ComputeJTJandJTr() [2/4]

template<typename MatType , typename VecType >

std::tuple< MatType, VecType, double > open3d::utility::ComputeJTJandJTr

(

)

Function to compute JTJ and Jtr Input: function pointer f and total number of rows of Jacobian matrix Output: JTJ, JTr, sum of r^2 Note: f takes index of row, and outputs corresponding residual and row vector.

ComputeJTJandJTr() [3/4]

template std::tuple<Eigen::Matrix6d, Eigen::Vector6d, double> open3d::utility::ComputeJTJandJTr	(	std::function< void(int, Eigen::Vector6d &, double &, double &)>	f,
		int	iteration_num,
		bool	verbose
	)

ComputeJTJandJTr() [4/4]

template std::tuple<Eigen::Matrix6d, Eigen::Vector6d, double> open3d::utility::ComputeJTJandJTr	(	std::function< void(int, std::vector< Eigen::Vector6d, Vector6d_allocator > &, std::vector< double > &, std::vector< double > &)>	f,
		int	iteration_num,
		bool	verbose
	)

ComputeMeanAndCovariance() [1/3]

template<typename IdxType >

std::tuple< Eigen::Vector3d, Eigen::Matrix3d > open3d::utility::ComputeMeanAndCovariance	(	const std::vector< Eigen::Vector3d > &	points,
		const std::vector< IdxType > &	indices
	)

Function to compute the mean and covariance matrix of a set of points.

ComputeMeanAndCovariance() [2/3]

template std::tuple<Eigen::Vector3d, Eigen::Matrix3d> open3d::utility::ComputeMeanAndCovariance	(	const std::vector< Eigen::Vector3d > &	points,
		const std::vector< size_t > &	indices
	)

ComputeMeanAndCovariance() [3/3]

template std::tuple<Eigen::Vector3d, Eigen::Matrix3d> open3d::utility::ComputeMeanAndCovariance	(	const std::vector< Eigen::Vector3d > &	points,
		const std::vector< int > &	indices
	)

constexpr_forward() [1/2]

template<class T >

constexpr T&& open3d::utility::constexpr_forward ( typename std::remove_reference< T >::type &  t )

inlinenoexcept

constexpr_forward() [2/2]

template<class T >

constexpr T&& open3d::utility::constexpr_forward ( typename std::remove_reference< T >::type &&  t )

inlinenoexcept

constexpr_move()

template<class T >

constexpr std::remove_reference<T>::type&& open3d::utility::constexpr_move ( T &&  t )

inlinenoexcept

DivUp()

int open3d::utility::DivUp ( int  x, int  y  )

inline

Computes the quotient of x/y with rounding up.

floor() [1/2]

template<int N>

FN_SPECIFIERS MiniVec<float, N> open3d::utility::floor

(

const MiniVec< float, N > &

a

)

floor() [2/2]

template<int N>

FN_SPECIFIERS MiniVec<double, N> open3d::utility::floor

(

const MiniVec< double, N > &

a

)

GetCurrentTimeStamp()

std::string open3d::utility::GetCurrentTimeStamp

(

)

GetProgramOptionAsDouble()

double open3d::utility::GetProgramOptionAsDouble	(	int	argc,
		char **	argv,
		const std::string &	option,
		const double	default_value
	)

GetProgramOptionAsEigenVectorXd()

Eigen::VectorXd open3d::utility::GetProgramOptionAsEigenVectorXd	(	int	argc,
		char **	argv,
		const std::string &	option,
		const Eigen::VectorXd	default_value
	)

GetProgramOptionAsInt()

int open3d::utility::GetProgramOptionAsInt	(	int	argc,
		char **	argv,
		const std::string &	option,
		const int	default_value
	)

GetProgramOptionAsString()

std::string open3d::utility::GetProgramOptionAsString	(	int	argc,
		char **	argv,
		const std::string &	option,
		const std::string &	default_value
	)

GetVerbosityLevel()

VerbosityLevel open3d::utility::GetVerbosityLevel ( )

inline

Get global verbosity level of Open3D.

InclusivePrefixSum()

template<class Tin , class Tout >

void open3d::utility::InclusivePrefixSum	(	const Tin *	first,
		const Tin *	last,
		Tout *	out
	)

LeftStripString()

std::string & open3d::utility::LeftStripString	(	std::string &	str,
		const std::string &	chars
	)

LogDebug()

template<typename... Args>

void open3d::utility::LogDebug ( const char *  format, const Args &...  args  )

inline

LogError()

template<typename... Args>

void open3d::utility::LogError ( const char *  format, const Args &...  args  )

inline

LogInfo()

template<typename... Args>

void open3d::utility::LogInfo ( const char *  format, const Args &...  args  )

inline

LogWarning()

template<typename... Args>

void open3d::utility::LogWarning ( const char *  format, const Args &...  args  )

inline

make_optional() [1/2]

template<class T >

constexpr optional<typename std::decay<T>::type> open3d::utility::make_optional

(

T &&

v

)

make_optional() [2/2]

template<class X >

constexpr optional<X&> open3d::utility::make_optional

(

std::reference_wrapper< X >

v

)

operator!()

template<class T , int N>

FN_SPECIFIERS MiniVec<T, N> open3d::utility::operator!

(

const MiniVec< T, N > &

a

)

operator!=() [1/9]

template<class T >

constexpr bool open3d::utility::operator!=	(	const optional< T > &	x,
		const optional< T > &	y
	)

operator!=() [2/9]

template<class T >

constexpr bool open3d::utility::operator!= ( const optional< T > &  x, nullopt_t    )

noexcept

operator!=() [3/9]

template<class T >

constexpr bool open3d::utility::operator!= ( nullopt_t  , const optional< T > &  x  )

noexcept

operator!=() [4/9]

template<class T >

constexpr bool open3d::utility::operator!=	(	const optional< T > &	x,
		const T &	v
	)

operator!=() [5/9]

template<class T >

constexpr bool open3d::utility::operator!=	(	const T &	v,
		const optional< T > &	x
	)

operator!=() [6/9]

template<class T >

constexpr bool open3d::utility::operator!=	(	const optional< T &> &	x,
		const T &	v
	)

operator!=() [7/9]

template<class T >

constexpr bool open3d::utility::operator!=	(	const T &	v,
		const optional< T &> &	x
	)

operator!=() [8/9]

template<class T >

constexpr bool open3d::utility::operator!=	(	const optional< const T &> &	x,
		const T &	v
	)

operator!=() [9/9]

template<class T >

constexpr bool open3d::utility::operator!=	(	const T &	v,
		const optional< const T &> &	x
	)

operator-()

template<class T , int N>

FN_SPECIFIERS MiniVec<T, N> open3d::utility::operator-

(

const MiniVec< T, N > &

a

)

operator<() [1/9]

template<class T >

constexpr bool open3d::utility::operator<	(	const optional< T > &	x,
		const optional< T > &	y
	)

operator<() [2/9]

template<class T >

constexpr bool open3d::utility::operator< ( const optional< T > &  , nullopt_t    )

noexcept

operator<() [3/9]

template<class T >

constexpr bool open3d::utility::operator< ( nullopt_t  , const optional< T > &  x  )

noexcept

operator<() [4/9]

template<class T >

constexpr bool open3d::utility::operator<	(	const optional< T > &	x,
		const T &	v
	)

operator<() [5/9]

template<class T >

constexpr bool open3d::utility::operator<	(	const T &	v,
		const optional< T > &	x
	)

operator<() [6/9]

template<class T >

constexpr bool open3d::utility::operator<	(	const optional< T &> &	x,
		const T &	v
	)

operator<() [7/9]

template<class T >

constexpr bool open3d::utility::operator<	(	const T &	v,
		const optional< T &> &	x
	)

operator<() [8/9]

template<class T >

constexpr bool open3d::utility::operator<	(	const optional< const T &> &	x,
		const T &	v
	)

operator<() [9/9]

template<class T >

constexpr bool open3d::utility::operator<	(	const T &	v,
		const optional< const T &> &	x
	)

operator<=() [1/9]

template<class T >

constexpr bool open3d::utility::operator<=	(	const optional< T > &	x,
		const optional< T > &	y
	)

operator<=() [2/9]

template<class T >

constexpr bool open3d::utility::operator<= ( const optional< T > &  x, nullopt_t    )

noexcept

operator<=() [3/9]

template<class T >

constexpr bool open3d::utility::operator<= ( nullopt_t  , const optional< T > &    )

noexcept

operator<=() [4/9]

template<class T >

constexpr bool open3d::utility::operator<=	(	const T &	v,
		const optional< T > &	x
	)

operator<=() [5/9]

template<class T >

constexpr bool open3d::utility::operator<=	(	const optional< T > &	x,
		const T &	v
	)

operator<=() [6/9]

template<class T >

constexpr bool open3d::utility::operator<=	(	const T &	v,
		const optional< T &> &	x
	)

operator<=() [7/9]

template<class T >

constexpr bool open3d::utility::operator<=	(	const optional< T &> &	x,
		const T &	v
	)

operator<=() [8/9]

template<class T >

constexpr bool open3d::utility::operator<=	(	const T &	v,
		const optional< const T &> &	x
	)

operator<=() [9/9]

template<class T >

constexpr bool open3d::utility::operator<=	(	const optional< const T &> &	x,
		const T &	v
	)

operator==() [1/9]

template<class T >

constexpr bool open3d::utility::operator==	(	const optional< T > &	x,
		const optional< T > &	y
	)

operator==() [2/9]

template<class T >

constexpr bool open3d::utility::operator== ( const optional< T > &  x, nullopt_t    )

noexcept

operator==() [3/9]

template<class T >

constexpr bool open3d::utility::operator== ( nullopt_t  , const optional< T > &  x  )

noexcept

operator==() [4/9]

template<class T >

constexpr bool open3d::utility::operator==	(	const optional< T > &	x,
		const T &	v
	)

operator==() [5/9]

template<class T >

constexpr bool open3d::utility::operator==	(	const T &	v,
		const optional< T > &	x
	)

operator==() [6/9]

template<class T >

constexpr bool open3d::utility::operator==	(	const optional< T &> &	x,
		const T &	v
	)

operator==() [7/9]

template<class T >

constexpr bool open3d::utility::operator==	(	const T &	v,
		const optional< T &> &	x
	)

operator==() [8/9]

template<class T >

constexpr bool open3d::utility::operator==	(	const optional< const T &> &	x,
		const T &	v
	)

operator==() [9/9]

template<class T >

constexpr bool open3d::utility::operator==	(	const T &	v,
		const optional< const T &> &	x
	)

operator>() [1/9]

template<class T >

constexpr bool open3d::utility::operator>	(	const optional< T > &	x,
		const optional< T > &	y
	)

operator>() [2/9]

template<class T >

constexpr bool open3d::utility::operator> ( const optional< T > &  x, nullopt_t    )

noexcept

operator>() [3/9]

template<class T >

constexpr bool open3d::utility::operator> ( nullopt_t  , const optional< T > &    )

noexcept

operator>() [4/9]

template<class T >

constexpr bool open3d::utility::operator>	(	const T &	v,
		const optional< T > &	x
	)

operator>() [5/9]

template<class T >

constexpr bool open3d::utility::operator>	(	const optional< T > &	x,
		const T &	v
	)

operator>() [6/9]

template<class T >

constexpr bool open3d::utility::operator>	(	const T &	v,
		const optional< T &> &	x
	)

operator>() [7/9]

template<class T >

constexpr bool open3d::utility::operator>	(	const optional< T &> &	x,
		const T &	v
	)

operator>() [8/9]

template<class T >

constexpr bool open3d::utility::operator>	(	const T &	v,
		const optional< const T &> &	x
	)

operator>() [9/9]

template<class T >

constexpr bool open3d::utility::operator>	(	const optional< const T &> &	x,
		const T &	v
	)

operator>=() [1/9]

template<class T >

constexpr bool open3d::utility::operator>=	(	const optional< T > &	x,
		const optional< T > &	y
	)

operator>=() [2/9]

template<class T >

constexpr bool open3d::utility::operator>= ( const optional< T > &  , nullopt_t    )

noexcept

operator>=() [3/9]

template<class T >

constexpr bool open3d::utility::operator>= ( nullopt_t  , const optional< T > &  x  )

noexcept

operator>=() [4/9]

template<class T >

constexpr bool open3d::utility::operator>=	(	const optional< T > &	x,
		const T &	v
	)

operator>=() [5/9]

template<class T >

constexpr bool open3d::utility::operator>=	(	const T &	v,
		const optional< T > &	x
	)

operator>=() [6/9]

template<class T >

constexpr bool open3d::utility::operator>=	(	const optional< T &> &	x,
		const T &	v
	)

operator>=() [7/9]

template<class T >

constexpr bool open3d::utility::operator>=	(	const T &	v,
		const optional< T &> &	x
	)

operator>=() [8/9]

template<class T >

constexpr bool open3d::utility::operator>=	(	const optional< const T &> &	x,
		const T &	v
	)

operator>=() [9/9]

template<class T >

constexpr bool open3d::utility::operator>=	(	const T &	v,
		const optional< const T &> &	x
	)

ProgramOptionExists()

bool open3d::utility::ProgramOptionExists	(	int	argc,
		char **	argv,
		const std::string &	option
	)

ProgramOptionExistsAny()

bool open3d::utility::ProgramOptionExistsAny	(	int	argc,
		char **	argv,
		const std::vector< std::string > &	options
	)

RightStripString()

std::string & open3d::utility::RightStripString	(	std::string &	str,
		const std::string &	chars
	)

RotationMatrixX()

Eigen::Matrix3d open3d::utility::RotationMatrixX

(

double

radians

)

RotationMatrixY()

Eigen::Matrix3d open3d::utility::RotationMatrixY

(

double

radians

)

RotationMatrixZ()

Eigen::Matrix3d open3d::utility::RotationMatrixZ

(

double

radians

)

SetVerbosityLevel()

void open3d::utility::SetVerbosityLevel ( VerbosityLevel  level )

inline

Set global verbosity level of Open3D

Parameters

level

Messages with equal or less than verbosity_level verbosity will be printed.

Sleep()

void open3d::utility::Sleep

(

int

milliseconds

)

SolveJacobianSystemAndObtainExtrinsicMatrix()

std::tuple< bool, Eigen::Matrix4d > open3d::utility::SolveJacobianSystemAndObtainExtrinsicMatrix	(	const Eigen::Matrix6d &	JTJ,
		const Eigen::Vector6d &	JTr
	)

Function to solve Jacobian system Input: 6x6 Jacobian matrix and 6-dim residual vector. Output: tuple of is_success, 4x4 extrinsic matrices.

SolveJacobianSystemAndObtainExtrinsicMatrixArray()

std::tuple< bool, std::vector< Eigen::Matrix4d, Matrix4d_allocator > > open3d::utility::SolveJacobianSystemAndObtainExtrinsicMatrixArray	(	const Eigen::MatrixXd &	JTJ,
		const Eigen::VectorXd &	JTr
	)

Function to solve Jacobian system Input: 6nx6n Jacobian matrix and 6n-dim residual vector. Output: tuple of is_success, n 4x4 motion matrices.

SolveLinearSystemPSD()

std::tuple< bool, Eigen::VectorXd > open3d::utility::SolveLinearSystemPSD	(	const Eigen::MatrixXd &	A,
		const Eigen::VectorXd &	b,
		bool	prefer_sparse,
		bool	check_symmetric,
		bool	check_det,
		bool	check_psd
	)

Function to solve Ax=b.

SplitString()

void open3d::utility::SplitString	(	std::vector< std::string > &	tokens,
		const std::string &	str,
		const std::string &	delimiters = " ",
		bool	trim_empty_str = true
	)

Function to split a string, mimics boost::split http://stackoverflow.com/questions/236129/split-a-string-in-c

StripString()

std::string & open3d::utility::StripString	(	std::string &	str,
		const std::string &	chars = "\\\\\ "
	)

Strip empty charactors in front and after string. Similar to Python's str.strip()

swap()

template<class T >

void open3d::utility::swap ( optional< T > &  x, optional< T > &  y  )

noexcept

ToLower()

std::string open3d::utility::ToLower

(

const std::string &

str

)

Convert string to the lower case.

ToUpper()

std::string open3d::utility::ToUpper

(

const std::string &

str

)

Convert string to the upper case.

TransformMatrix4dToVector6d()

Eigen::Vector6d open3d::utility::TransformMatrix4dToVector6d

(

const Eigen::Matrix4d &

input

)

Function to transform 4D motion matrix to 6D motion vector this is consistent with the matlab function in the Aerospace Toolbox Reference: https://github.com/qianyizh/ElasticReconstruction/blob/master/Matlab_Toolbox/Core/mrEvaluateRegistration.m

TransformVector6dToMatrix4d()

Eigen::Matrix4d open3d::utility::TransformVector6dToMatrix4d

(

const Eigen::Vector6d &

input

)

Function to transform 6D motion vector to 4D motion matrix Reference: https://eigen.tuxfamily.org/dox/group__TutorialGeometry.html#TutorialGeoTransform

UniformRandFloatBinaryFriendly()

template<typename T >

T open3d::utility::UniformRandFloatBinaryFriendly

(

unsigned int

power = 5

)

Uniformly distributed binary-friendly floating point number in [0, 1).

Binary-friendly means that the random number can be represented by floating point with a few bits of mantissa. The binary-friendliness is useful for unit testing since it reduces the chances of numerical errors.

E.g.

• 0.9 is not representable by floating point accurately, the actual value stored in a float32 is 0.89999997615814208984375...
• 0.875 = 0.5 + 0.25 + 0.125, is binary-friendly.

Parameters

power

The possible random numbers are: n * 1 / (2 ^ power), where n = 0, 1, 2, ..., (2 ^ power - 1).

UniformRandInt()

int open3d::utility::UniformRandInt	(	const int	min,
		const int	max
	)

Thread-safe function returning a pseudo-random integer. The integer is drawn from a uniform distribution bounded by min and max (inclusive)

WordLength()

size_t open3d::utility::WordLength	(	const std::string &	doc,
		size_t	start_pos,
		const std::string &	valid_chars = "_"
	)

String util: find length of current word staring from a position By default, alpha numeric chars and chars in valid_chars are considered as valid charactors in a word

Variable Documentation

in_place

constexpr in_place_t open3d::utility::in_place {}

nullopt

constexpr nullopt_t open3d::utility::nullopt {nullopt_t::init()}

trivial_init

constexpr struct open3d::utility::trivial_init_t open3d::utility::trivial_init