Defines the class GetTileJob. More...

Namespaces
namespace	internal
namespace	library
namespace	TypedProcessing
namespace	ValuePersistence
namespace	ScopeGuardDetail
namespace	detail
namespace	taskSystem
namespace	Unicode

Classes
class	ClassicHost
	Classic ML host used internally to calculate getTile and processAllPages requests. More...
class	GetTileJobBase
	Base class for TileRequest based jobs. More...
class	GetTileJob
	Public interface for requesting a tile from a an ML PagedImage using the PageRequestProcessor. More...
class	MultiThreadedPageRequestProcessor
class	PageRequest
class	PageRequestCursor
class	PageRequestQueueInterface
	Virtual interface for queuing PageRequests that are ready for processing. More...
class	PageRequestProcessor
	Abstract base class for page request processors. More...
class	PageRequestProcessorBase
	Base class for single and multithreaded processor. More...
class	ProcessAllPagesJob
	Public interface for processing all pages of a temporary output image. More...
class	ProcessingTimeLine
	Stores a processing timeline for multiple threads. More...
class	SingleThreadedPageRequestProcessor
class	TileRequest
class	OutputConnector
class	InputConnector
	Class to manage an input connection of a Module module. More...
class	Engine
class	Field
class	FieldContainer
class	BoolField
class	IntField
class	EnumField
class	EnumValues
class	TypedEnumField
class	FloatField
class	ProgressField
class	DoubleField
class	StringField
class	NotifyField
class	OutputConnectorField
class	InputConnectorField
class	BaseField
class	TypedBaseField
class	SoNodeField
class	PointerField
class	Vector2Field
class	Vector3Field
class	Vector4Field
class	Vector5Field
class	Vector6Field
class	Vector10Field
class	ColorField
class	Matrix2Field
class	Matrix3Field
class	MatrixField
class	Matrix4Field
class	Matrix5Field
class	Matrix6Field
class	MLDataTypeField
class	ImageVectorField
class	SubImageBoxField
class	SubImageBoxdField
class	UniversalTypeField
class	RotationField
class	PlaneField
class	FieldSensor
class	Host
class	ImageProperties
class	InputSubImageProperties
class	ListField
class	IntListField
class	DoubleListField
class	Vector2ListField
class	Vector3ListField
class	Vector4ListField
class	MedicalImageProperties
class	MemoryImage
class	Module
class	ModuleDiagnosisStackScope
class	UserThreadData
	Base class for thread local data that is passed to CalculateOutputImageHandler::calculateOutputSubImage. More...
class	CalculateOutputImageHandler
class	ModuleTools
class	PagedImage
class	PageIDIterator
class	ProcessAllPagesHandler
class	OrderedSingleInputProcessAllPagesHandler
class	OrderedProcessAllPagesHandler
class	TScaleShiftData
class	MLTStdTypeInfos
	Template class to register the standard integer classes as voxel types in the ML. More...
class	StringConversion
	The class StringConversion provides static methods to convert ML objects to and from strings. More...
class	SubImage
class	TSubImageBox
class	SubImageBoxd
class	TreeNodeException
class	TreeNode
class	TSubImageCursor
	Predeclaration for cursor. More...
class	ConstTSubImageCursor
	Predeclaration for const cursor. More...
class	TSubImage
class	TSubImageCursorBase
	Base class for all TSubImage Cursors. More...
class	TSubImageWithCursor
class	VariableType
class	TypedProcessAllPagesHandler
class	TypedCalculateOutputImageHandler
struct	TypeTraits
struct	DataTypeSelector
class	TQuaternion
	Declaration of complex type traits. More...
class	Tvec2
	Declaration of float vector type traits. More...
class	Tvec3
	Forward declarations to resolve header file dependencies. More...
class	Tvec4
	Forward declarations to resolve header file dependencies. More...
class	Tvec5
	Forward declarations to resolve header file dependencies. More...
class	Tvec6
	A six dimensional vector class for floating point types. More...
class	Tvec7
	An seven dimensional vector class for floating point types. More...
class	Tvec8
	An eight dimensional vector class for floating point types. More...
class	Tvec9
	An nine dimensional vector class for floating point types. More...
class	Tvec10
	An ten dimensional vector class for floating point types. More...
class	Tvec16
	A 16 dimensional vector class for floating point types. More...
class	Tvec32
	A 32 dimensional vector class for floating point types. More...
class	Tvec64
	A 64 dimensional vector class for floating point types. More...
class	Tmat2
	Declaration of matrix type traits. More...
class	Tmat3
	A 3x3 matrix class of three row vectors. More...
class	Tmat4
	A 4x4 matrix class consisting of four row vectors. More...
class	Tmat5
	A 5x5 matrix class of five row vectors. More...
class	Tmat6
	A 6x6 matrix class of six row vectors. More...
class	TVectorNDBase
	Declaration of integer vector type traits. More...
class	FloatingPointVector
class	FloatingPointMatrix
class	AbstractPersistenceStream
class	AbstractPersistenceOutputStream
class	AbstractPersistenceInputStream
class	PersistenceStreamException
class	PersistenceStreamIOException
class	PersistenceStreamFormatException
class	PersistenceStreamInternalError
	Derived class. This exception usually denotes programming errors. More...
class	ApplicationProperties
struct	ArgumentList0
	Empty argument to allow running with zero arguments. More...
struct	ArgumentList1
	ArgumentList with one argument. More...
struct	ArgumentList2
	ArgumentList with two arguments. More...
struct	ArgumentList3
	ArgumentList with three arguments. More...
struct	ArgumentList4
	ArgumentList with four arguments. More...
struct	ArgumentList5
	ArgumentList with five arguments. More...
class	Barrier
class	ScopedBarrierWaiter
class	Base
class	CompilerInfo
class	ComputerModelInfo
class	ConstantStringValue
	Shared container for the string value and its hash. More...
class	ConstantString
struct	Is
	In combination with the `in` function, it returns `true` if a passed value is in the set of possible values. More...
class	ContainerProxy
	This template implements a proxy for containers that contain a collection of items normally accessed with a get-by-index method. More...
struct	tree_node
class	CPUInfo
class	DateTime
class	ErrorOutput
	Class to handle all ML debug prints, errors, warnings, and information. More...
class	ErrorOutputInfos
class	EventSource
class	BaseEvent
class	EventSourceDeletedEvent
class	ImagePropertyExtension
class	ImagePropertyExtensionContainer
class	Memory
class	MemoryInfo
class	Notify
	Class to handle all ML Notify prints, errors, and warnings. More...
class	RefCountedBase
class	Runtime
class	RuntimeDict
class	RuntimeType
class	StringSwitch
struct	Overload
class	TimeCounter
	Class to measure precise time intervals. More...
class	TraceBuffer
class	Trace
class	WaitCondition
class	WMIInterface
class	FloatingPointVectorDataContainerBase
class	TVector6DBase
class	TImageVector
class	TVector
class	Line
class	Plane
	Class defining a plane in 3D. More...
class	Rotation
	Class to handle Rotations (internally, the rotation is stored as a unit quaternion). More...
class	Vector2DataContainer
	Specialized base class for the FloatingPointVectorDataContainerBase. More...
class	Vector3DataContainer
	Specialized base class for the FloatingPointVectorDataContainerBase. More...

Typedefs
typedef void	TileRequestFinishedCB(void data, TileRequest request)
	Callback for a finished TileRequest.
typedef NotifyField	TriggerField
typedef void	CalculateOutputImagePropertiesCB(void userData, PagedImage outImage)
	Callback for the calculation of the output image properties for `outputImage`.
typedef TScaleShiftData< MLdouble >	ScaleShiftData
	Double version of TScaleShiftData for maximum reasonable precision.
typedef TSubImageBox< MLint >	SubImageBox
	Defines the standard SubImageBox type used in the ML. Its size varies with the size of the MLint type.
using	AtomicCounter = std::atomic_int32_t
typedef void	BaseEventCallback(void , BaseEvent )
typedef std::vector< ImagePropertyExtension * >	ImagePropertyExtensionVector
	Defines the STL container type of ImagePropertyExtension objects.
typedef boost::recursive_mutex	RecursiveMutex
typedef boost::recursive_mutex::scoped_lock	RecursiveLock
	Defines a lock for locking a recursive mutex.
typedef boost::mutex	Mutex
typedef boost::mutex::scoped_lock	Lock
	Defines a lock for locking a non-recursive mutex.
using	low_executor = detail::executor<execute_low>
using	default_executor = detail::executor<execute_default>
using	high_executor = detail::executor<execute_high>
template<template< class... > class Op, class... Args>
using	is_detected = typename internal::detector<internal::nonesuch, void, Op, Args...>::value_t
template<template< class... > class Op, class... Args>
using	detected_t = typename internal::detector<internal::nonesuch, void, Op, Args...>::type
typedef boost::thread	Thread
typedef MLuint16	MLGlobalTraceBufferType
	The type used in the MLGlobalTraceBuffer.
typedef TImageVector< MLint >	ImageVector
	Defines the standard ImageVector type that is used by the ML for indexing and coordinates.
typedef int	VectorDimIdxType
	Signed integer type used as count and index type to traverse the array of the TVector.
Specializations for float, double, and long double.
typedef Tmat2< MLfloat >	Matrix2f
	A 2x2 matrix of type float.
typedef Tmat2< MLdouble >	Matrix2d
	A 2x2 matrix of type double.
typedef Tmat2< MLldouble >	Matrix2ld
	A 2x2 matrix of type long double.
typedef Tmat2< MLdouble >	Matrix2
	The standard 2x2 matrix of type double.
typedef Tmat4< MLfloat >	Matrix4f
	A 4x4 matrix of type float.
typedef Tmat4< MLdouble >	Matrix4d
	A 4x4 matrix of type double.
typedef Tmat4< MLldouble >	Matrix4ld
	A 4x4 matrix of type long double.
typedef Tmat4< MLdouble >	Matrix4
	The standard 4x4 matrix of type double.
typedef Tmat5< MLfloat >	Matrix5f
	A 5x5 matrix of type float.
typedef Tmat5< MLdouble >	Matrix5d
	A 5x5 matrix of type double.
typedef Tmat5< MLldouble >	Matrix5ld
	A 5x5 matrix of type long double.
typedef Tmat5< MLdouble >	Matrix5
	The standard 5x5 matrix of type double.
typedef Tmat6< MLfloat >	Matrix6f
	A 6x6 matrix of type float.
typedef Tmat6< MLdouble >	Matrix6d
	A 6x6 matrix of type double.
typedef Tmat6< MLldouble >	Matrix6ld
	A 6x6 matrix of type long double.
typedef Tmat6< MLdouble >	Matrix6
	The standard 6x6 matrix of type double.
typedef TQuaternion< MLfloat >	Quaternionf
	A smaller Quaternion type as a specialization from TQuaternion.
typedef TQuaternion< MLdouble >	Quaterniond
	The default Quaternion type used in the ML as a specialization from TQuaternion.
typedef TQuaternion< MLldouble >	Quaternionld
	A large Quaternion type for further extensions of the ML as a specialization from TQuaternion.
typedef TQuaternion< MLdouble >	Quaternion
	Defines the default Quaternion type that is used by the ML; it uses double as component type.
typedef Tvec10< MLfloat >	Vector10f
	A vector with ten components of type float.
typedef Tvec10< MLdouble >	Vector10d
	A vector with ten components of type double.
typedef Tvec10< MLldouble >	Vector10ld
	A vector with ten components of type long double.
typedef Tvec10< MLdouble >	Vector10
	A vector with ten components of type double.
typedef Tvec16< MLfloat >	Vector16f
	A vector with 16 components of type float.
typedef Tvec16< MLdouble >	Vector16d
	A vector with 16 components of type double.
typedef Tvec16< MLldouble >	Vector16ld
	A vector with 16 components of type long double.
typedef Tvec16< MLdouble >	Vector16
	A vector with 16 components of type double.
typedef Tvec2< MLfloat >	Vector2f
	A vector with two components of type float.
typedef Tvec2< MLdouble >	Vector2d
	A vector with two components of type double.
typedef Tvec2< MLldouble >	Vector2ld
	A vector with two components of type long double.
typedef Tvec2< MLdouble >	Vector2
	A vector with two components of type double.
typedef Tvec3< MLfloat >	Vector3f
	A vector with three components of type float.
typedef Tvec3< MLdouble >	Vector3d
	A vector with three components of type double.
typedef Tvec3< MLldouble >	Vector3ld
	A vector with three components of type long double.
typedef Tvec3< MLdouble >	Vector3
	A vector with three components of type double.
typedef Tvec32< MLfloat >	Vector32f
	A vector with 32 components of type float.
typedef Tvec32< MLdouble >	Vector32d
	A vector with 32 components of type double.
typedef Tvec32< MLldouble >	Vector32ld
	A vector with 32 components of type long double.
typedef Tvec32< MLdouble >	Vector32
	A vector with 32 components of type double.
typedef Tvec4< MLfloat >	Vector4f
	A vector with four components of type float.
typedef Tvec4< MLdouble >	Vector4d
	A vector with four components of type double.
typedef Tvec4< MLldouble >	Vector4ld
	A vector with four components of type long double.
typedef Tvec4< MLdouble >	Vector4
	A vector with four components of type double.
typedef Tvec5< MLfloat >	Vector5f
	A vector with five components of type float.
typedef Tvec5< MLdouble >	Vector5d
	A vector with five components of type double.
typedef Tvec5< MLldouble >	Vector5ld
	A vector with five components of type long double.
typedef Tvec5< MLdouble >	Vector5
	A vector with five components of type double.
typedef Tvec6< MLfloat >	Vector6f
	A vector with six components of type float.
typedef Tvec6< MLdouble >	Vector6d
	A vector with six components of type double.
typedef Tvec6< MLldouble >	Vector6ld
	A vector with six components of type long double.
typedef Tvec6< MLdouble >	Vector6
	A vector with six components of type double.
typedef Tvec64< MLfloat >	Vector64f
	A vector with 64 components of type float.
typedef Tvec64< MLdouble >	Vector64d
	A vector with 64 components of type double.
typedef Tvec64< MLldouble >	Vector64ld
	A vector with 64 components of type long double.
typedef Tvec64< MLdouble >	Vector64
	A vector with 64 components of type double.
typedef Tvec7< MLfloat >	Vector7f
	A vector with seven components of type float.
typedef Tvec7< MLdouble >	Vector7d
	A vector with seven components of type double.
typedef Tvec7< MLldouble >	Vector7ld
	A vector with seven components of type long double.
typedef Tvec7< MLdouble >	Vector7
	A vector with seven components of type double.
typedef Tvec8< MLfloat >	Vector8f
	A vector with eight components of type float.
typedef Tvec8< MLdouble >	Vector8d
	A vector with eight components of type double.
typedef Tvec8< MLldouble >	Vector8ld
	A vector with eight components of type long double.
typedef Tvec8< MLdouble >	Vector8
	A vector with eight components of type double.
typedef Tvec9< MLfloat >	Vector9f
	A vector with nine components of type float.
typedef Tvec9< MLdouble >	Vector9d
	A vector with nine components of type double.
typedef Tvec9< MLldouble >	Vector9ld
	A vector with nine components of type long double.
typedef Tvec9< MLdouble >	Vector9
	A vector with nine components of type double.
Specializations for float, double and long double.
typedef Tmat3< MLfloat >	Matrix3f
	A 3x3 matrix of type float.
typedef Tmat3< MLdouble >	Matrix3d
	A 3x3 matrix of type double.
typedef Tmat3< MLldouble >	Matrix3ld
	A 3x3 matrix of type long double.
typedef Tmat3< MLdouble >	Matrix3
	The standard 3x3 matrix of type double.

Enumerations
enum	{ TNE_VoidImplementation , TNE_NotSupported , TNE_ChildNotFound , TNE_AddingBase , TNE_ReadingBase , TNE_ReadingUChar , TNE_ReadingChar , TNE_ReadingUShort , TNE_ReadingShort , TNE_ReadingUInt , TNE_ReadingInt , TNE_ReadingULong , TNE_ReadingLong , TNE_ReadingFloat , TNE_ReadingDouble , TNE_ReadingLDouble , TNE_ReadingString , TNE_ReadingVector2 , TNE_ReadingVector3 , TNE_ReadingVector4 , TNE_ReadingVector6 , TNE_ReadingImageVector , TNE_ReadingMatrix3 , TNE_ReadingMatrix4 , TNE_ReadingSubImageBox , TNE_ReadingSubImageBoxd , TNE_InvalidReadNext , TNE_InvalidParentNode , TNE_FileNotFound , TNE_ReadingFile , TNE_WritingFile , TNE_UnsupportedClassVersion , TNE_UserDefined , TNE_Unknown , TNE_ReadingMLint64 , TNE_ReadingMLuint64 , TNE_COUNT }
enum	{ ML_INTEGER_TYPE = 0x01 , ML_FLOAT_TYPE = 0x02 , ML_SIGNED_TYPE = 0x04 }
enum	{ MLMaxImageDimension = 6 }
	The default dimension of images in the ML. More...

Functions
MLEXPORT void	MLInitFields ()
	Initialize all standard fields of the ML.
MLEXPORT void	MLInitListFields ()
	Initialize all multi-fields of the ML.
template<typename... T>
TSubImageVariant< T... >	createTSubImageVariant (const SubImage *subImage)
template<typename... T>
TSubImageVariantPair< T... >	createTSubImageVariantPair (SubImage &output, const SubImage *input)
template<std::size_t N, typename... T>
TSubImageVariantArray< N, T... >	createTSubImageVariantArray (const SubImage *inputs)
template<std::size_t N, typename... T>
TSubImageVariantArrayPair< N, T... >	createTSubImageVariantArrayPair (SubImage &output, const SubImage *inputs)
ArgumentList0	MLGenerateArgumentList ()
	Creates argument list with zero arguments.
template<class Arg1>
ArgumentList1< Arg1 >	MLGenerateArgumentList (const Arg1 &arg1)
	Create argument list with one argument.
template<class Arg1, class Arg2>
ArgumentList2< Arg1, Arg2 >	MLGenerateArgumentList (const Arg1 &arg1, const Arg2 &arg2)
	Creates argument list with two arguments.
template<class Arg1, class Arg2, class Arg3>
ArgumentList3< Arg1, Arg2, Arg3 >	MLGenerateArgumentList (const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
	Creates argument list with three arguments.
template<class Arg1, class Arg2, class Arg3, class Arg4>
ArgumentList4< Arg1, Arg2, Arg3, Arg4 >	MLGenerateArgumentList (const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
	Creates argument list with four arguments.
template<class Arg1, class Arg2, class Arg3, class Arg4, class Arg5>
ArgumentList5< Arg1, Arg2, Arg3, Arg4, Arg5 >	MLGenerateArgumentList (const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
	Creates argument list with five arguments.
template<class Object, class Method>
void	MLCallMethodWithArguments (Object *object, Method method, const ArgumentList0 &)
	Calls a method on given object with zero arguments.
template<class Object, class Method, class Arg1>
void	MLCallMethodWithArguments (Object *object, Method method, const ArgumentList1< Arg1 > &args)
	Calls a method on given object with one argument.
template<class Object, class Method, class Arg1, class Arg2>
void	MLCallMethodWithArguments (Object *object, Method method, const ArgumentList2< Arg1, Arg2 > &args)
	Calls a method on given object with two arguments.
template<class Object, class Method, class Arg1, class Arg2, class Arg3>
void	MLCallMethodWithArguments (Object *object, Method method, const ArgumentList3< Arg1, Arg2, Arg3 > &args)
	Calls a method on given object with three arguments.
template<class Object, class Method, class Arg1, class Arg2, class Arg3, class Arg4>
void	MLCallMethodWithArguments (Object *object, Method method, const ArgumentList4< Arg1, Arg2, Arg3, Arg4 > &args)
	Calls a method on given object with four arguments.
template<class Object, class Method, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5>
void	MLCallMethodWithArguments (Object *object, Method method, const ArgumentList5< Arg1, Arg2, Arg3, Arg4, Arg5 > &args)
	Calls a method on given object with five arguments.
std::size_t	hash_value (ConstantString const &b)
template<class T>
constexpr Is< T >	is (T d)
template<typename Range1, typename Range2, typename BinaryPredicate>
constexpr Range2::const_iterator	is_rotated (const Range1 &range1, const Range2 &range2, BinaryPredicate p)
template<typename Range1, typename Range2>
constexpr Range2::const_iterator	is_rotated (const Range1 &range1, const Range2 &range2)
template<typename T>
void	flatten (const tree_node< T > &tree, std::vector< T > &flatten_elements)
template<typename T>
void	insert_set_sorted (tree_node< T > &tree, T newValue, T zero={})
ML_UTILS_EXPORT float	roundf (float x)
ML_UTILS_EXPORT double	round (double x)
ML_UTILS_EXPORT int	iroundf (float x)
ML_UTILS_EXPORT int	iround (double x)
ML_UTILS_EXPORT long	lroundf (float x)
ML_UTILS_EXPORT long	lround (double x)
template<typename T, std::size_t N>
constexpr T	convertTo (const char(&t)[N])
template<typename T>
constexpr bool	almostEqualRelativeAndAbs (T x, T y, T absoluteEpsilon, T relativeEpsilon=std::numeric_limits< T >::epsilon())
void ML_UTILS_EXPORT	printTemplateFatalError (const char *location, MLErrorCode reason, const std::string_view &handling)
void ML_UTILS_EXPORT	printTemplateError (const char *location, MLErrorCode reason, const std::string_view &handling)
void ML_UTILS_EXPORT	printTemplateWarning (const char *location, MLErrorCode reason, const std::string_view &handling)
void	intrusive_ptr_add_ref (const ml::RefCountedBase *p)
void	intrusive_ptr_release (const ml::RefCountedBase *p)
template<typename T>
bool	vector_contains (const std::vector< T > &vec, const T &value)
	Helper template that searches for `value` in given vector `vec` and returns whether it was found.
template<typename T>
bool	vector_remove (std::vector< T > &vec, const T &value)
	Helper template that removes the first occurrence of `value` in given vector `vec` and returns whether it was found.
template<typename T>
void	vector_remove_all (std::vector< T > &vec, const T &value)
	Helper template that removes all occurrences of `value` in given vector `vec`.
template<typename T>
bool	vector_replace_by_NULL (std::vector< T > &vec, const T &value)
	Helper template that replaces the first occurrence of `value` in given vector `vec` with NULL and returns whether it was found.
void ML_UTILS_EXPORT	execute_low (stlab::task< void()> f)
void ML_UTILS_EXPORT	execute_default (stlab::task< void()> f)
void ML_UTILS_EXPORT	execute_high (stlab::task< void()> f)
void ML_UTILS_EXPORT	pre_exit ()
template<class... Ts>
	Overload (Ts...) -> Overload< Ts... >
void ML_UTILS_EXPORT	logTypeComponentsFromStringError (const char *function)
template<typename DT>
DT	abs (DT val)
ML_UTILS_EXPORT std::wstring	convertUTF8ToWString (const char *text)
ML_UTILS_EXPORT std::wstring	convertUTF8ToWString (const std::string &text)
ML_UTILS_EXPORT std::string	convertToUTF8String (const wchar_t *text)
ML_UTILS_EXPORT std::string	convertToUTF8String (const std::wstring &text)
template<class OBJ_TYPE>
void	MLSwap (OBJ_TYPE &obj1, OBJ_TYPE &obj2)
template<class BASE_TYPE>
BASE_TYPE	MLInverseMatHelper (const BASE_TYPE &origMat, bool isInvertible, const typename BASE_TYPE::ComponentType, const char const ZeroDetErrString, const BASE_TYPE &Identity, const size_t Dim)
template<class DT, class DT2>
Tvec3< DT >	operator* (const Tmat3< DT > &a, const Tvec3< DT2 > &v)
template<class DT, class DT2>
Tvec3< DT >	operator* (const Tvec3< DT > &v, const Tmat3< DT2 > &a)
template<class DT, class DT2>
Tvec3< DT >	operator* (const Tmat4< DT > &a, const Tvec3< DT2 > &v)
template<class DT, class DT2>
Tvec3< DT >	operator* (const Tvec3< DT > &v, const Tmat4< DT2 > &a)
template<class DT, class DT2>
Tvec3< DT >	operator^ (const Tvec3< DT > &a, const Tvec3< DT2 > &b)
	Returns a vector orthogonal to `a` and `b`.
template<class DT>
Tvec4< DT >	operator* (const Tmat4< DT > &a, const Tvec4< DT > &v)
	Multiplies 4x4 matrix a with vector `v`.
template<class DT>
Tvec4< DT >	operator* (const Tvec4< DT > &v, const Tmat4< DT > &a)
	Multiplies vector `v` with 4x4 matrix `a`.
template<class DT>
Tvec5< DT >	operator* (const Tmat5< DT > &a, const Tvec5< DT > &v)
	Multiplies 5x5 matrix `a` with vector `v`.
template<class DT>
Tvec5< DT >	operator* (const Tvec5< DT > &v, const Tmat5< DT > &a)
	Multiplies vector `v` with 5x5 matrix `a`.
Casting of SubImage to TSubImage<T>
template<typename T>
TSubImage< T > &	tsubimage_cast (SubImage &subImg)
template<typename T>
const TSubImage< T > &	tsubimage_cast (const SubImage &subImg)
template<typename T>
TSubImage< T > *	tsubimage_cast (SubImage *subImg)
template<typename T>
const TSubImage< T > *	tsubimage_cast (const SubImage *subImg)
mlMin/mlMax Templates in ML namespace
template<typename T>
T	mlMin (T a, T b)
template<typename T>
T	mlMax (T a, T b)
template<typename T>
T	mlAbs (T a)
	Defines ML specific `abs` template since only type-dependent library functions exists.
Functions and operators for class Tmat2.
template<class DT>
Tmat2< DT >	operator* (const Tmat2< DT > &a, const Tmat2< DT > &b)
template<class DT>
bool	operator== (const Tmat2< DT > &a, const Tmat2< DT > &b)
	a == b ? Returns `true` if yes.
template<class DT>
bool	operator!= (const Tmat2< DT > &a, const Tmat2< DT > &b)
	a != b ? Returns `true` if yes.
Standalone functions and operators for class Tmat2.
template<class DT>
Tmat2< DT >	operator- (const Tmat2< DT > &a)
	Returns a matrix a with all values negated.
template<class DT>
Tmat2< DT >	operator+ (const Tmat2< DT > &a, const Tmat2< DT > &b)
	Returns the component-wise sum of matrix `a` and matrix `b`.
template<class DT>
Tmat2< DT >	operator- (const Tmat2< DT > &a, const Tmat2< DT > &b)
	Returns the component-wise difference of matrix `a` and matrix `b`.
template<class DT>
Tmat2< DT >	operator* (const Tmat2< DT > &a, DT d)
	Returns the component-wise multiplication of matrix `a` with scalar `d`.
template<class DT>
Tmat2< DT >	operator* (const DT d, const Tmat2< DT > &a)
	Returns the component-wise multiplication of scalar `d` with matrix `a`.
template<class DT>
Tmat2< DT >	operator/ (const Tmat2< DT > &a, const DT d)
template<class DT>
Tvec2< DT >	operator* (const Tmat2< DT > &a, const Tvec2< DT > &v)
template<class DT>
Tvec2< DT >	operator* (const Tvec2< DT > &v, const Tmat2< DT > &a)
Global operators and functions of class Tmat3.
template<class DT>
Tmat3< DT >	operator- (const Tmat3< DT > &a)
	Returns a matrix a with all values negated.
template<class DT>
Tmat3< DT >	operator+ (const Tmat3< DT > &a, const Tmat3< DT > &b)
	Returns the component-wise sum of matrix `a` and matrix `b`.
template<class DT>
Tmat3< DT >	operator- (const Tmat3< DT > &a, const Tmat3< DT > &b)
	Returns the component-wise difference of matrix `a` and matrix `b`.
template<class DT>
Tmat3< DT >	operator* (const Tmat3< DT > &a, const DT d)
	Returns the component-wise multiplication of matrix `a` with scalar `d`.
template<class DT>
Tmat3< DT >	operator* (const DT d, const Tmat3< DT > &a)
	Returns the component-wise multiplication of scalar `d` with matrix `a`.
template<class DT>
Tmat3< DT >	operator/ (const Tmat3< DT > &a, const DT d)
Special Functions
template<class DT>
Tmat3< DT >	operator* (const Tmat3< DT > &a, const Tmat3< DT > &b)
	Matrix 3 product.
template<class DT>
bool	operator== (const Tmat3< DT > &a, const Tmat3< DT > &b)
	a == b ? Return `true` if yes; otherwise, it returns `false`.
template<class DT>
bool	operator!= (const Tmat3< DT > &a, const Tmat3< DT > &b)
	a != b ? Return `true` if yes; otherwise, it returns `false`.
template<class DT>
Tmat3< DT >	identity2D ()
template<class DT>
Tmat3< DT >	translation2D (const Tvec2< DT > &v)
template<class DT>
Tmat3< DT >	rotation2D (const Tvec2< DT > &Center, const DT angleDeg)
template<class DT>
Tmat3< DT >	scaling2D (const Tvec2< DT > &scaleVector)
	Returns a 2D scale matrix as 3D homogeneous matrix.
template<class DT>
Tmat5< DT >	operator* (const Tmat5< DT > &a, const Tmat5< DT > &b)
	Matrix product.
template<class DT>
bool	operator== (const Tmat5< DT > &a, const Tmat5< DT > &b)
	a == b ? Returns `true` if yes; otherwise, it returns `false`.
template<class DT>
bool	operator!= (const Tmat5< DT > &a, const Tmat5< DT > &b)
	a != b ? Returns `true` if yes; otherwise, it returns `false`.
template<class DT>
Tmat6< DT >	operator* (const Tmat6< DT > &a, const Tmat6< DT > &b)
	Matrix product.
template<class DT>
bool	operator== (const Tmat6< DT > &a, const Tmat6< DT > &b)
	a == b ? Returns `true` if yes; otherwise, it returns `false`.
template<class DT>
bool	operator!= (const Tmat6< DT > &a, const Tmat6< DT > &b)
	a != b ? Returns `true` if yes; otherwise, it returns `false`.
template<class DT>
Tvec6< DT >	operator* (const Tmat6< DT > &a, const Tvec6< DT > &v)
	Multiplies 6x6 matrix `a` with vector `v`.
template<class DT>
Tvec6< DT >	operator* (const Tvec6< DT > &v, const Tmat6< DT > &a)
	Multiplies vector `v` with 6x6 matrix `a`.
Functions and operators for class Tmat4.
template<class DT>
Tmat4< DT >	operator* (const Tmat4< DT > &a, const Tmat4< DT > &b)
template<class DT>
bool	operator== (const Tmat4< DT > &a, const Tmat4< DT > &b)
	a == b ? Returns `true` if yes.
template<class DT>
bool	operator!= (const Tmat4< DT > &a, const Tmat4< DT > &b)
	a != b ? Returns `true` if yes.
Global functions and operators for class Tmat4.
template<class DT>
Tmat4< DT >	operator- (const Tmat4< DT > &a)
	Returns the matrix `a` with all values negated.
template<class DT>
Tmat4< DT >	operator+ (const Tmat4< DT > &a, const Tmat4< DT > &b)
	Returns the component-wise sum of matrix `a` and matrix `b`.
template<class DT>
Tmat4< DT >	operator- (const Tmat4< DT > &a, const Tmat4< DT > &b)
	Returns the component-wise difference of matrix `a` and matrix `b`.
template<class DT>
Tmat4< DT >	operator* (const Tmat4< DT > &a, const DT d)
	Returns the component-wise multiplication of matrix `a` with scalar `d`.
template<class DT>
Tmat4< DT >	operator* (const DT d, const Tmat4< DT > &a)
	Returns the component-wise multiplication of scalar `d` with matrix `a`.
template<class DT>
Tmat4< DT >	operator/ (const Tmat4< DT > &a, const DT d)
Tmat4<DT> member functions
template<class DT>
Tmat4< DT >	identity3D ()
template<class DT>
Tmat4< DT >	translation3D (const Tvec3< DT > &v)
template<class DT>
Tmat4< DT >	rotation3D (Tvec3< DT > Axis, const DT angleRad)
template<class DT>
Tmat4< DT >	scaling3D (const Tvec3< DT > &scaleVector)
	Scaling 3D.
template<class DT>
Tmat4< DT >	perspective3D (const DT d)
Standalone operators of class Tmat5.
template<class DT>
Tmat5< DT >	operator- (const Tmat5< DT > &a)
	Returns a matrix a with all values negated.
template<class DT>
Tmat5< DT >	operator+ (const Tmat5< DT > &a, const Tmat5< DT > &b)
	Returns the component-wise sum of matrix `a` and matrix `b`.
template<class DT>
Tmat5< DT >	operator- (const Tmat5< DT > &a, const Tmat5< DT > &b)
	Returns the component-wise difference of matrix `a` and matrix `b`.
template<class DT>
Tmat5< DT >	operator* (const Tmat5< DT > &a, const DT d)
	Returns the component-wise product of matrix `a` with scalar `d`.
template<class DT>
Tmat5< DT >	operator* (const DT d, const Tmat5< DT > &a)
	Returns the component-wise product of scalar `d` with matrix `a`.
template<class DT>
Tmat5< DT >	operator/ (const Tmat5< DT > &a, const DT d)
Standalone operators of class Tmat6.
template<class DT>
Tmat6< DT >	operator- (const Tmat6< DT > &a)
	Returns a matrix a with all values negated.
template<class DT>
Tmat6< DT >	operator+ (const Tmat6< DT > &a, const Tmat6< DT > &b)
	Returns the component-wise sum of matrix `a` and matrix `b`.
template<class DT>
Tmat6< DT >	operator- (const Tmat6< DT > &a, const Tmat6< DT > &b)
	Returns the component-wise difference of matrix `a` and matrix `b`.
template<class DT>
Tmat6< DT >	operator* (const Tmat6< DT > &a, const DT d)
	Returns the component-wise product of matrix `a` with scalar `d`.
template<class DT>
Tmat6< DT >	operator* (const DT d, const Tmat6< DT > &a)
	Returns the component-wise product of scalar `d` with matrix `a`.
template<class DT>
Tmat6< DT >	operator/ (const Tmat6< DT > &a, const DT d)

Variables
const MLint	_ML_STD_SLEN =64
	Length of strings for component descriptions and class names.
template<typename VTYP>
const VTYP	MLTStdTypeInfos< VTYP >::_typeDefault = VTYP(0)
template<typename VTYP>
MLTypeInfos *	MLTStdTypeInfos< VTYP >::_myInfos = nullptr
template<typename VTYP>
MLint32	MLTStdTypeInfos< VTYP >::_numInstances = 0
ML_UTILS_EXPORT ErrorOutput	MLErrorOutput
	This is a singleton used for all ML Error input and output;.
ML_UTILS_EXPORT Notify	MLNotify
	Singleton which contains all registered callback functions of the ML.
template<template< class... > class Op, class... Args>
constexpr bool	is_detected_v = is_detected<Op, Args...>::value
ML_UTILS_EXPORT TraceBuffer< MLGlobalTraceBufferType >	MLGlobalTraceBuffer
Values to be used in the setup of a TypedCalculateOutputImageHandler/TypedProcessAllPagesHandler
const int	MLVariableType0 = _ML_SWITCH_SELECT_OFFSET
	Defines to use the result type of variable type 0.
const int	MLVariableType1 = _ML_SWITCH_SELECT_OFFSET+1
	Defines to use the result type of variable type 1.
const int	MLVariableType2 = _ML_SWITCH_SELECT_OFFSET+2
	Defines to use the result type of variable type 2.
const int	MLVariableType3 = _ML_SWITCH_SELECT_OFFSET+3
	Defines to use the result type of variable type 3.
const int	MLGenericType = _ML_SWITCH_SELECT_OFFSET+10
	Defines special index to use a generic type.

Standalone functions for FloatingPointVector.
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer > &	operator+= (FloatingPointVector< T, size, DataContainer > &op1, const FloatingPointVector< T, size, DataContainer > &buffer)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer > &	operator-= (FloatingPointVector< T, size, DataContainer > &op1, const FloatingPointVector< T, size, DataContainer > &buffer)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer > &	operator*= (FloatingPointVector< T, size, DataContainer > &op1, MLdouble value)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer > &	operator*= (FloatingPointVector< T, size, DataContainer > &op1, const FloatingPointVector< T, size, DataContainer > &op2)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer > &	operator/= (FloatingPointVector< T, size, DataContainer > &op1, MLdouble value)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer > &	operator/= (FloatingPointVector< T, size, DataContainer > &op1, const FloatingPointVector< T, size, DataContainer > &op2)
template<class T, size_t size, class DataContainer>
bool	operator! (const FloatingPointVector< T, size, DataContainer > &a)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	operator+ (FloatingPointVector< T, size, DataContainer > lhs, const FloatingPointVector< T, size, DataContainer > &rhs)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	operator- (FloatingPointVector< T, size, DataContainer > lhs, const FloatingPointVector< T, size, DataContainer > &rhs)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	operator+ (const FloatingPointVector< T, size, DataContainer > &buffer)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	operator- (const FloatingPointVector< T, size, DataContainer > &buffer)
template<class T, size_t size, class DataContainer>
T	operator* (const FloatingPointVector< T, size, DataContainer > &a, const FloatingPointVector< T, size, DataContainer > &b)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	operator* (FloatingPointVector< T, size, DataContainer > lhs, MLdouble rhs)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	operator* (MLdouble lhs, FloatingPointVector< T, size, DataContainer > rhs)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	operator/ (FloatingPointVector< T, size, DataContainer > lhs, MLdouble rhs)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	compMin (FloatingPointVector< T, size, DataContainer > buffer1, const FloatingPointVector< T, size, DataContainer > &buffer2)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	compMax (FloatingPointVector< T, size, DataContainer > buffer1, const FloatingPointVector< T, size, DataContainer > &buffer2)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	compAbs (FloatingPointVector< T, size, DataContainer > vec)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	compSqr (FloatingPointVector< T, size, DataContainer > vec)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	compSqrt (FloatingPointVector< T, size, DataContainer > vec)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	compDiv (FloatingPointVector< T, size, DataContainer > vec, const FloatingPointVector< T, size, DataContainer > &d)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	clampMin (FloatingPointVector< T, size, DataContainer > vec, const FloatingPointVector< T, size, DataContainer > &m)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	clampMax (FloatingPointVector< T, size, DataContainer > vec, const FloatingPointVector< T, size, DataContainer > &m)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	clamp (FloatingPointVector< T, size, DataContainer > vec, const FloatingPointVector< T, size, DataContainer > &lower, const FloatingPointVector< T, size, DataContainer > &upper)
template<class T, size_t size, class DataContainer>
T	compMul (const FloatingPointVector< T, size, DataContainer > &vec)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer > &	operator+= (FloatingPointVector< T, size, DataContainer > &op1, const FloatingPointVector< T, size, DataContainer > &buffer)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer > &	operator-= (FloatingPointVector< T, size, DataContainer > &op1, const FloatingPointVector< T, size, DataContainer > &buffer)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer > &	operator*= (FloatingPointVector< T, size, DataContainer > &op1, MLdouble value)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer > &	operator*= (FloatingPointVector< T, size, DataContainer > &op1, const FloatingPointVector< T, size, DataContainer > &op2)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer > &	operator/= (FloatingPointVector< T, size, DataContainer > &op1, MLdouble value)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer > &	operator/= (FloatingPointVector< T, size, DataContainer > &op1, const FloatingPointVector< T, size, DataContainer > &op2)
template<class T, size_t size, class DataContainer>
bool	operator! (const FloatingPointVector< T, size, DataContainer > &a)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	operator+ (FloatingPointVector< T, size, DataContainer > lhs, const FloatingPointVector< T, size, DataContainer > &rhs)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	operator- (FloatingPointVector< T, size, DataContainer > lhs, const FloatingPointVector< T, size, DataContainer > &rhs)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	operator+ (const FloatingPointVector< T, size, DataContainer > &buffer)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	operator- (const FloatingPointVector< T, size, DataContainer > &buffer)
template<class T, size_t size, class DataContainer>
T	operator* (const FloatingPointVector< T, size, DataContainer > &a, const FloatingPointVector< T, size, DataContainer > &b)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	operator* (FloatingPointVector< T, size, DataContainer > lhs, MLdouble rhs)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	operator* (MLdouble lhs, FloatingPointVector< T, size, DataContainer > rhs)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	operator/ (FloatingPointVector< T, size, DataContainer > lhs, MLdouble rhs)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	compMin (FloatingPointVector< T, size, DataContainer > buffer1, const FloatingPointVector< T, size, DataContainer > &buffer2)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	compMax (FloatingPointVector< T, size, DataContainer > buffer1, const FloatingPointVector< T, size, DataContainer > &buffer2)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	compAbs (FloatingPointVector< T, size, DataContainer > vec)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	compSqr (FloatingPointVector< T, size, DataContainer > vec)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	compSqrt (FloatingPointVector< T, size, DataContainer > vec)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	compDiv (FloatingPointVector< T, size, DataContainer > vec, const FloatingPointVector< T, size, DataContainer > &d)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	clampMin (FloatingPointVector< T, size, DataContainer > vec, const FloatingPointVector< T, size, DataContainer > &m)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	clampMax (FloatingPointVector< T, size, DataContainer > vec, const FloatingPointVector< T, size, DataContainer > &m)
template<class T, size_t size, class DataContainer>
FloatingPointVector< T, size, DataContainer >	clamp (FloatingPointVector< T, size, DataContainer > vec, const FloatingPointVector< T, size, DataContainer > &lower, const FloatingPointVector< T, size, DataContainer > &upper)
template<class T, size_t size, class DataContainer>
T	compMul (const FloatingPointVector< T, size, DataContainer > &vec)

Detailed Description

Defines the class GetTileJob.

Template class for a 9D vector for floating point types, derived from FloatingPointVector.

Template class for a 8D vector for floating point types, derived from FloatingPointVector.

Template class for a 7D vector for floating point types, derived from FloatingPointVector.

Template class for a 64D vector for floating point types, derived from FloatingPointVector.

Template class for a 6D vector for floating point types, derived from FloatingPointVector.

Template class for a 5D vector for floating point types, derived from FloatingPointVector.

Template class for a 4D vector for floating point types, derived from FloatingPointVector.

Template class for a 32D vector for floating point types, derived from FloatingPointVector.

Template class for a 3D vector for floating point types, derived from FloatingPointVector.

Template class for a 2D vector for floating point types, derived from FloatingPointVector.

Template class for a 16D vector for floating point types, derived from FloatingPointVector.

Template class for a 10D vector for floating point types, derived from FloatingPointVector.

Defines a class to represent a Rotation.

Defines a class to handle the geometry primitive 'Plane'.

Template class for a 6x6 matrix of 6 rows of Tvec6 vectors.

Template class for a 5x5 matrix of five rows of Tvec5 vectors.

Template class for a 4x4 matrix of four rows of Tvec4 vectors.

Template class for a 3x3 matrix of three rows of Tvec3 vectors.

Template class for a 2x2 matrix of two rows of Tvec2 vectors.

Template class for a 3x3 matrix of 3 rows of Tvec3 vectors.

Main documentation file for mlLinearAlgebra library.

Defines the geometry primitive "Line".

Template class TVector for integer types.

Template base class for floating point matrices.

Define the namespace name like in the ML. Default is ml.

File containing the library documentation of project mlUtils.

Defines named constants for Unicode code points.

Class to measure precise time intervals in seconds.

Platform-independent class to manage a thread.

A switch()-like statement where the cases are string literals.

RefCountedBase class that adds reference counting to Base.

Class to notify registered instances about ML changes.

Singleton class that provides information about system memory.

Basic memory management class for the ML.

Implementation of basic cross-platform math routines.

Information container for error, debug, or tracing information.

Central error handling and redirection class for the ML.

Singleton class that provides information about CPU.

A light-weight shared constant string (not thread-safe!).

Gather compiler information.

Platform independent class to manage thread-safe atomic counting.

Defines an interface to access properties of the host application.

Define template functions for converting values to/from string.

This class provides static methods to convert ML objects to and from strings.

Defines the class TScaleShiftData.

Defines the class ProcessAllPagesHandler.

Defines the class PageIDIterator.

Define classes for multi-valued fields.

Define a template class for multi-valued fields.

Defines the class TileRequest.

Defines the class ProcessingTimeLine.

Defines the class ProcessAllPagesJob.

Defines the class.

Defines the class PageRequestCursor.

Defines the class PageRequest.

Main documentation file for ML users and developers. It contains source code documentation, release notes and known problems pages.

Implements the classic host processing for getTile/processAllPages Thread-safety: This class is not thread-safe and should only be used from the main thread.

This file contains definitions of input and output connectors for the mlModule class, which are necessary to connect ML modules.

Defined and implements an engine that is an ML module implementing only operations on fields.

Defines the base class Field from which many classes are derived, like StringField and IntField for unified access to image processing parameters of ML module subclasses.

Defines the class FieldSensor to realize the concept of field sensors that can observe fields. With field sensors, functions can be registered that shall be called when a corresponding field is modified.

Defines the class Host for the processing of image processing graphs (see class PagedImage and Module). Note that this file needs to be included explicitly, as it is part of the hidden C++ API of the ML. Do not use it, as it is part of the ML internals. If you need functionality, see the wrapped functionality in Module and PagedImage.

Thread-safety: This class is not thread-safe and should only be used from the main thread.

This file defines the classes ImageProperties. They describe properties of images and sometimes of subimages.

Defines the class InSubImageProps, a simple container for some properties that can be defined for an input subimage that is to be delivered to the corresponding call of the module's calculateOutputSubImage method.

This file defines the classes ImageProperties and MedicalImageProperties. They describe properties of images and sometimes of subimages.

Defines the class MemoryImage that manages memory mapped images in ML output connectors.

Some tools for Module programming. Note that this file needs to be included explicitly, as it is not part of mlModuleIncludes.h.

Contains the class PagedImage, representing a fragmented image that manages properties and data of an image located in pages. The image data can be partially available or not. This class has the following properties:

The image is composed of a number of numbered pages with an identical data type and extent. Pages can be available or not.
The properties of the image are inherited from the class MedicalImageProperties.
New properties of the pages are:
- page extents
- page number
- the location within the entire image.
- a reference to the memory chunk of type MLWeakMemoryBlockHandle
The PagedImage owns methods to create, remove, or copy pages, and to copy page contents to a subimage corresponding to them.
It also contains a MemoryImage, which can be used to maintain the entire image as a continuous memory area.

Template class to register the standard integer datatypes as voxel types in the ML. NOTE: Only one instance should be created of this class!

This file defines the class SubImage to administrate/manage/access images or subimages which reside in memory.

Define the template class TSubImageBox and the specialization SubImageBox.

Class to define a subimage region with Vector6 corners. It represents a 6D box like image region defined by two 6D corner points.

This abstract class defines an interface to allow the storing and restoring of complex objects.

This file defines the class TSubImage to administrate/manage/access typed images or subimages, which reside in memory.

These abstract classes define an interface to allow the storing and restoring of structured objects.

Template classes for storing up to five arguments in a ArgumentList and calling a method with a given argument list.

Platform independent class to manage a barrier that is used to make a group of threads wait for each other.

Defines the class DateTime for processing date and time values

The struct ErrorOutputInfos is passed to any call of a user registered function of type ErrorOutputCB to notify about detailed debug, error, or other runtime information. It passes the registered userData pointer for the callback function, a completely composed information string for convenience, and a structure of type ErrorOutputInfos to the function. The struct contains:

a type identifier (information, warning, error, fatal error, or debug),
a prefix string for the library that created the information,
a prefix string with arbitrary information printed before a function,
the function name
the error code
the reason/info string,
the string with information about the handling of the error,
the file name,
the line number, and
the time stamp when message was received by the error handler of the error/warning/information/debug position.

Define EventSource class that adds event listener handling to Base and a BaseEvent class needed for that

This file defines the class ImagePropertyExtension, used as a base class for extended image property objects that can be appended to the ImagePropertyExtensionContainer inside MedicalImageProperties.

This file defines the class ImagePropertyExtensionContainer. Objects/classes derived from the abstract class ImagePropertyExtension can be added to this container to define extensions of the MedicalimageProperties of an ML paged image.

Platform-independent class to manage a mutex for safe operations on code sections which must be used only by one thread at a time.

This is a class where any instance can register itself with a callback. The callback will be called if any state flag in the ML changes. This way, these instances can update themselves if the ML changes. Note that the notify callbacks may be called from within any environment. This way, critical sections (to avoid parallel execution) could be active or field notifications could be disabled. For example, updating fields within such a callback may fail or critical sections could block. However, the caller should try to avoid that in general.

This class contains the global runtime system of the ML. It manages a dictionary of runtime types, and it can create and remove runtime types. This class contains only static components and must be initialized with init() and destroyed with destroy() on ML initialization/destruction.

See also classes RuntimeType and RuntimeDict.

This file declares the class RuntimeDict that manages a set of instances of class RuntimeTypes. The class Runtime uses one global instance of this class for the runtime type system of the ML.

See also classes Runtime and RuntimeType.

This file declares the class RuntimeType that contains runtime-generated type and inheritance information of associated classes. To track this information, the macros defined in RuntimeSubClass.h have to be inserted in the declaration and implementation of the associated classes.

The StringSwitch class is a simple form of a switch() statement that determines whether the given string matches one of the given string literals. The template type parameter T is the type of the value that will be returned from the string-switch expression. For example, the following code switches on the name of a color in argv[i]: (The code was taken from the LLVM project and modified for MBS's environment.)

Color color = StringSwitch<Color>(argv[i])
  .Case("red", Red)
  .Case("orange", Orange)
  .Case("yellow", Yellow)
  .Case("green", Green)
  .Case("blue", Blue)
  .Case("indigo", Indigo)
  .Cases("violet", "purple", Violet)
  .StartsWith("white", White)
  .EndsWith("gray", Gray)
  .Default(UnknownColor);

Class to manage a buffer for a stack and a list of string pointers for tracing debug and release code. Another class Trace to be used in tracing macros is also implemented here. Note:

Both classes are implemented in one file to avoid tricky circular header dependencies which cannot be solved by moving code into .cpp files for performance reasons.

Macro to put all following code into the namespace ml to avoid collisions with symbols of other libraries. Use END_NAMESPACE_ML to close the namespace. Closes the namespace for all ML code after the usage of ML_UTILS_START_NAMESPACE.

Platform independent class to manage a wait condition that can be used with a mutex to do signalling between threads

Template class TImageVector for 6D integer types and the specialization ImageVector, which is typically used in the ML as indexing and coordinate type.

Template class for quaternion numerics.

Implementation of a Quaternion with common operations; for definition and examples see https://en.wikipedia.org/wiki/Quaternion as reference page. It is also the source of many comments.

Typedef Documentation

◆ BaseEventCallback

typedef void ml::BaseEventCallback(void *, BaseEvent *)

Definition at line 25 of file mlEventSource.h.

◆ CalculateOutputImagePropertiesCB

typedef void ml::CalculateOutputImagePropertiesCB(void *userData, PagedImage *outImage)

Callback for the calculation of the output image properties for outputImage.

Definition at line 27 of file mlModuleInterfaces.h.

◆ default_executor

using ml::default_executor = detail::executor<execute_default>

Definition at line 57 of file mlTaskSystem.h.

◆ detected_t

template<template< class... > class Op, class... Args>

using ml::detected_t = typename internal::detector<internal::nonesuch, void, Op, Args...>::type

Definition at line 80 of file mlTemplateHelpers.h.

◆ high_executor

using ml::high_executor = detail::executor<execute_high>

Definition at line 58 of file mlTaskSystem.h.

◆ ImagePropertyExtensionVector

typedef std::vector<ImagePropertyExtension*> ml::ImagePropertyExtensionVector

Defines the STL container type of ImagePropertyExtension objects.

Definition at line 99 of file mlImagePropertyExtension.h.

◆ ImageVector

typedef TImageVector<MLint> ml::ImageVector

Defines the standard ImageVector type that is used by the ML for indexing and coordinates.

Definition at line 285 of file mlImageVector.h.

◆ is_detected

template<template< class... > class Op, class... Args>

using ml::is_detected = typename internal::detector<internal::nonesuch, void, Op, Args...>::value_t

Definition at line 74 of file mlTemplateHelpers.h.

◆ Lock

typedef boost::mutex::scoped_lock ml::Lock

Defines a lock for locking a non-recursive mutex.

Definition at line 41 of file mlMutex.h.

◆ low_executor

using ml::low_executor = detail::executor<execute_low>

Definition at line 56 of file mlTaskSystem.h.

◆ Matrix2

typedef Tmat2<MLdouble> ml::Matrix2

The standard 2x2 matrix of type double.

Definition at line 518 of file mlMatrix2.h.

◆ Matrix2d

typedef Tmat2<MLdouble> ml::Matrix2d

A 2x2 matrix of type double.

Definition at line 514 of file mlMatrix2.h.

◆ Matrix2f

typedef Tmat2<MLfloat> ml::Matrix2f

A 2x2 matrix of type float.

Definition at line 512 of file mlMatrix2.h.

◆ Matrix2ld

typedef Tmat2<MLldouble> ml::Matrix2ld

A 2x2 matrix of type long double.

Definition at line 516 of file mlMatrix2.h.

◆ Matrix3

typedef Tmat3<MLdouble> ml::Matrix3

The standard 3x3 matrix of type double.

Definition at line 711 of file mlMatrix3.h.

◆ Matrix3d

typedef Tmat3<MLdouble> ml::Matrix3d

A 3x3 matrix of type double.

Definition at line 707 of file mlMatrix3.h.

◆ Matrix3f

typedef Tmat3<MLfloat> ml::Matrix3f

A 3x3 matrix of type float.

Definition at line 705 of file mlMatrix3.h.

◆ Matrix3ld

typedef Tmat3<MLldouble> ml::Matrix3ld

A 3x3 matrix of type long double.

Definition at line 709 of file mlMatrix3.h.

◆ Matrix4

typedef Tmat4<MLdouble> ml::Matrix4

The standard 4x4 matrix of type double.

Definition at line 713 of file mlMatrix4.h.

◆ Matrix4d

typedef Tmat4<MLdouble> ml::Matrix4d

A 4x4 matrix of type double.

Definition at line 709 of file mlMatrix4.h.

◆ Matrix4f

typedef Tmat4<MLfloat> ml::Matrix4f

A 4x4 matrix of type float.

Definition at line 707 of file mlMatrix4.h.

◆ Matrix4ld

typedef Tmat4<MLldouble> ml::Matrix4ld

A 4x4 matrix of type long double.

Definition at line 711 of file mlMatrix4.h.

◆ Matrix5

typedef Tmat5<MLdouble> ml::Matrix5

The standard 5x5 matrix of type double.

Definition at line 705 of file mlMatrix5.h.

◆ Matrix5d

typedef Tmat5<MLdouble> ml::Matrix5d

A 5x5 matrix of type double.

Definition at line 701 of file mlMatrix5.h.

◆ Matrix5f

typedef Tmat5<MLfloat> ml::Matrix5f

A 5x5 matrix of type float.

Definition at line 699 of file mlMatrix5.h.

◆ Matrix5ld

typedef Tmat5<MLldouble> ml::Matrix5ld

A 5x5 matrix of type long double.

Definition at line 703 of file mlMatrix5.h.

◆ Matrix6

typedef Tmat6<MLdouble> ml::Matrix6

The standard 6x6 matrix of type double.

Definition at line 636 of file mlMatrix6.h.

◆ Matrix6d

typedef Tmat6<MLdouble> ml::Matrix6d

A 6x6 matrix of type double.

Definition at line 632 of file mlMatrix6.h.

◆ Matrix6f

typedef Tmat6<MLfloat> ml::Matrix6f

A 6x6 matrix of type float.

Definition at line 630 of file mlMatrix6.h.

◆ Matrix6ld

typedef Tmat6<MLldouble> ml::Matrix6ld

A 6x6 matrix of type long double.

Definition at line 634 of file mlMatrix6.h.

◆ MLGlobalTraceBufferType

typedef MLuint16 ml::MLGlobalTraceBufferType

The type used in the MLGlobalTraceBuffer.

Definition at line 238 of file mlTrace.h.

◆ Quaternion

typedef TQuaternion<MLdouble> ml::Quaternion

Defines the default Quaternion type that is used by the ML; it uses double as component type.

Definition at line 924 of file mlQuaternion.h.

◆ Quaterniond

typedef TQuaternion<MLdouble> ml::Quaterniond

The default Quaternion type used in the ML as a specialization from TQuaternion.

Definition at line 918 of file mlQuaternion.h.

◆ Quaternionf

typedef TQuaternion<MLfloat> ml::Quaternionf

A smaller Quaternion type as a specialization from TQuaternion.

Definition at line 915 of file mlQuaternion.h.

◆ Quaternionld

typedef TQuaternion<MLldouble> ml::Quaternionld

A large Quaternion type for further extensions of the ML as a specialization from TQuaternion.

Definition at line 921 of file mlQuaternion.h.

◆ RecursiveLock

typedef boost::recursive_mutex::scoped_lock ml::RecursiveLock

Defines a lock for locking a recursive mutex.

Definition at line 34 of file mlMutex.h.

◆ ScaleShiftData

typedef TScaleShiftData<MLdouble> ml::ScaleShiftData

Double version of TScaleShiftData for maximum reasonable precision.

Definition at line 326 of file mlScaleShiftData.h.

◆ SubImageBox

typedef TSubImageBox<MLint> ml::SubImageBox

Defines the standard SubImageBox type used in the ML. Its size varies with the size of the MLint type.

Definition at line 255 of file mlSubImageBox.h.

◆ Thread

typedef boost::thread ml::Thread

Definition at line 26 of file mlThread.h.

◆ TileRequestFinishedCB

typedef void ml::TileRequestFinishedCB(void *data, TileRequest *request)

Callback for a finished TileRequest.

Definition at line 34 of file mlTileRequest.h.

◆ TriggerField

typedef NotifyField ml::TriggerField

TriggerField is an alias for the NotifyField, which is easier to find for Open Inventor users who are used to the 'SoSFTrigger' field.

Definition at line 626 of file mlFields.h.

◆ Vector10

typedef Tvec10<MLdouble> ml::Vector10

A vector with ten components of type double.

Definition at line 103 of file mlVector10.h.

◆ Vector10d

typedef Tvec10<MLdouble> ml::Vector10d

A vector with ten components of type double.

Definition at line 99 of file mlVector10.h.

◆ Vector10f

typedef Tvec10<MLfloat> ml::Vector10f

A vector with ten components of type float.

Definition at line 97 of file mlVector10.h.

◆ Vector10ld

typedef Tvec10<MLldouble> ml::Vector10ld

A vector with ten components of type long double.

Definition at line 101 of file mlVector10.h.

◆ Vector16

typedef Tvec16<MLdouble> ml::Vector16

A vector with 16 components of type double.

Definition at line 110 of file mlVector16.h.

◆ Vector16d

typedef Tvec16<MLdouble> ml::Vector16d

A vector with 16 components of type double.

Definition at line 106 of file mlVector16.h.

◆ Vector16f

typedef Tvec16<MLfloat> ml::Vector16f

A vector with 16 components of type float.

Definition at line 104 of file mlVector16.h.

◆ Vector16ld

typedef Tvec16<MLldouble> ml::Vector16ld

A vector with 16 components of type long double.

Definition at line 108 of file mlVector16.h.

◆ Vector2

typedef Tvec2<MLdouble> ml::Vector2

A vector with two components of type double.

Definition at line 159 of file mlVector2.h.

◆ Vector2d

typedef Tvec2<MLdouble> ml::Vector2d

A vector with two components of type double.

Definition at line 155 of file mlVector2.h.

◆ Vector2f

typedef Tvec2<MLfloat> ml::Vector2f

A vector with two components of type float.

Definition at line 153 of file mlVector2.h.

◆ Vector2ld

typedef Tvec2<MLldouble> ml::Vector2ld

A vector with two components of type long double.

Definition at line 157 of file mlVector2.h.

◆ Vector3

typedef Tvec3<MLdouble> ml::Vector3

A vector with three components of type double.

Definition at line 286 of file mlVector3.h.

◆ Vector32

typedef Tvec32<MLdouble> ml::Vector32

A vector with 32 components of type double.

Definition at line 134 of file mlVector32.h.

◆ Vector32d

typedef Tvec32<MLdouble> ml::Vector32d

A vector with 32 components of type double.

Definition at line 130 of file mlVector32.h.

◆ Vector32f

typedef Tvec32<MLfloat> ml::Vector32f

A vector with 32 components of type float.

Definition at line 128 of file mlVector32.h.

◆ Vector32ld

typedef Tvec32<MLldouble> ml::Vector32ld

A vector with 32 components of type long double.

Definition at line 132 of file mlVector32.h.

◆ Vector3d

typedef Tvec3<MLdouble> ml::Vector3d

A vector with three components of type double.

Definition at line 282 of file mlVector3.h.

◆ Vector3f

typedef Tvec3<MLfloat> ml::Vector3f

A vector with three components of type float.

Definition at line 280 of file mlVector3.h.

◆ Vector3ld

typedef Tvec3<MLldouble> ml::Vector3ld

A vector with three components of type long double.

Definition at line 284 of file mlVector3.h.

◆ Vector4

typedef Tvec4<MLdouble> ml::Vector4

A vector with four components of type double.

Definition at line 162 of file mlVector4.h.

◆ Vector4d

typedef Tvec4<MLdouble> ml::Vector4d

A vector with four components of type double.

Definition at line 158 of file mlVector4.h.

◆ Vector4f

typedef Tvec4<MLfloat> ml::Vector4f

A vector with four components of type float.

Definition at line 156 of file mlVector4.h.

◆ Vector4ld

typedef Tvec4<MLldouble> ml::Vector4ld

A vector with four components of type long double.

Definition at line 160 of file mlVector4.h.

◆ Vector5

typedef Tvec5<MLdouble> ml::Vector5

A vector with five components of type double.

Definition at line 207 of file mlVector5.h.

◆ Vector5d

typedef Tvec5<MLdouble> ml::Vector5d

A vector with five components of type double.

Definition at line 203 of file mlVector5.h.

◆ Vector5f

typedef Tvec5<MLfloat> ml::Vector5f

A vector with five components of type float.

Definition at line 201 of file mlVector5.h.

◆ Vector5ld

typedef Tvec5<MLldouble> ml::Vector5ld

A vector with five components of type long double.

Definition at line 205 of file mlVector5.h.

◆ Vector6

typedef Tvec6<MLdouble> ml::Vector6

A vector with six components of type double.

Definition at line 194 of file mlVector6.h.

◆ Vector64

typedef Tvec64<MLdouble> ml::Vector64

A vector with 64 components of type double.

Definition at line 159 of file mlVector64.h.

◆ Vector64d

typedef Tvec64<MLdouble> ml::Vector64d

A vector with 64 components of type double.

Definition at line 155 of file mlVector64.h.

◆ Vector64f

typedef Tvec64<MLfloat> ml::Vector64f

A vector with 64 components of type float.

Definition at line 153 of file mlVector64.h.

◆ Vector64ld

typedef Tvec64<MLldouble> ml::Vector64ld

A vector with 64 components of type long double.

Definition at line 157 of file mlVector64.h.

◆ Vector6d

typedef Tvec6<MLdouble> ml::Vector6d

A vector with six components of type double.

Definition at line 190 of file mlVector6.h.

◆ Vector6f

typedef Tvec6<MLfloat> ml::Vector6f

A vector with six components of type float.

Definition at line 188 of file mlVector6.h.

◆ Vector6ld

typedef Tvec6<MLldouble> ml::Vector6ld

A vector with six components of type long double.

Definition at line 192 of file mlVector6.h.

◆ Vector7

typedef Tvec7<MLdouble> ml::Vector7

A vector with seven components of type double.

Definition at line 98 of file mlVector7.h.

◆ Vector7d

typedef Tvec7<MLdouble> ml::Vector7d

A vector with seven components of type double.

Definition at line 94 of file mlVector7.h.

◆ Vector7f

typedef Tvec7<MLfloat> ml::Vector7f

A vector with seven components of type float.

Definition at line 92 of file mlVector7.h.

◆ Vector7ld

typedef Tvec7<MLldouble> ml::Vector7ld

A vector with seven components of type long double.

Definition at line 96 of file mlVector7.h.

◆ Vector8

typedef Tvec8<MLdouble> ml::Vector8

A vector with eight components of type double.

Definition at line 99 of file mlVector8.h.

◆ Vector8d

typedef Tvec8<MLdouble> ml::Vector8d

A vector with eight components of type double.

Definition at line 95 of file mlVector8.h.

◆ Vector8f

typedef Tvec8<MLfloat> ml::Vector8f

A vector with eight components of type float.

Definition at line 93 of file mlVector8.h.

◆ Vector8ld

typedef Tvec8<MLldouble> ml::Vector8ld

A vector with eight components of type long double.

Definition at line 97 of file mlVector8.h.

◆ Vector9

typedef Tvec9<MLdouble> ml::Vector9

A vector with nine components of type double.

Definition at line 102 of file mlVector9.h.

◆ Vector9d

typedef Tvec9<MLdouble> ml::Vector9d

A vector with nine components of type double.

Definition at line 98 of file mlVector9.h.

◆ Vector9f

typedef Tvec9<MLfloat> ml::Vector9f

A vector with nine components of type float.

Definition at line 96 of file mlVector9.h.

◆ Vector9ld

typedef Tvec9<MLldouble> ml::Vector9ld

A vector with nine components of type long double.

Definition at line 100 of file mlVector9.h.

◆ VectorDimIdxType

typedef int ml::VectorDimIdxType

Signed integer type used as count and index type to traverse the array of the TVector.

Definition at line 29 of file mlIntegerVector.h.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
ML_INTEGER_TYPE
ML_FLOAT_TYPE
ML_SIGNED_TYPE

Definition at line 84 of file mlTypeTraits.h.

◆ anonymous enum

anonymous enum

The default dimension of images in the ML.

Enumerator
MLMaxImageDimension

Definition at line 29 of file mlImageVector.h.

◆ anonymous enum

anonymous enum

TreeNode exceptions. They have been placed outside of the class to prevent the user from having to add TreeNodeException:: at the beginning of each code. Do not forget to edit the array TreeNodeException::_stdErrorMsg[] when modifying the enum!

Enumerator
TNE_VoidImplementation
TNE_NotSupported
TNE_ChildNotFound
TNE_AddingBase
TNE_ReadingBase
TNE_ReadingUChar
TNE_ReadingChar
TNE_ReadingUShort
TNE_ReadingShort
TNE_ReadingUInt
TNE_ReadingInt
TNE_ReadingULong
TNE_ReadingLong
TNE_ReadingFloat
TNE_ReadingDouble
TNE_ReadingLDouble
TNE_ReadingString
TNE_ReadingVector2
TNE_ReadingVector3
TNE_ReadingVector4
TNE_ReadingVector6
TNE_ReadingImageVector
TNE_ReadingMatrix3
TNE_ReadingMatrix4
TNE_ReadingSubImageBox
TNE_ReadingSubImageBoxd
TNE_InvalidReadNext
TNE_InvalidParentNode
TNE_FileNotFound
TNE_ReadingFile
TNE_WritingFile
TNE_UnsupportedClassVersion
TNE_UserDefined
TNE_Unknown
TNE_ReadingMLint64
TNE_ReadingMLuint64
TNE_COUNT

Definition at line 41 of file mlTreeNode.h.

Function Documentation

◆ abs()

template<typename DT>

DT ml::abs ( DT val )

inline

Definition at line 120 of file mlTypeDefTraits.h.

◆ almostEqualRelativeAndAbs()

template<typename T>

bool ml::almostEqualRelativeAndAbs	(	T	x,
		T	y,
		T	absoluteEpsilon,
		T	relativeEpsilon = std::numeric_limits<T>::epsilon() )

constexpr

Definition at line 43 of file mlNumericHelpers.h.

◆ clamp() [1/2]

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > clamp	(	FloatingPointVector< T, size, DataContainer >	vec,
		const FloatingPointVector< T, size, DataContainer > &	lower,
		const FloatingPointVector< T, size, DataContainer > &	upper )

Returns a new vector with all components from vec clamped to range [lower, upper]. Note that this does not hold if components in lower are greater than their corresponding ones in upper. See FloatingPointVector<T, size, DataContainer>::clamp().

Definition at line 523 of file mlFloatingPointVector.h.

◆ clampMax() [1/2]

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > clampMax	(	FloatingPointVector< T, size, DataContainer >	vec,
		const FloatingPointVector< T, size, DataContainer > &	m )

Returns a new vector with all components from vec clamped to maximum m. See FloatingPointVector<T, size, DataContainer>::clampMax().

Definition at line 508 of file mlFloatingPointVector.h.

◆ clampMin() [1/2]

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > clampMin	(	FloatingPointVector< T, size, DataContainer >	vec,
		const FloatingPointVector< T, size, DataContainer > &	m )

Returns a new vector with all components from vec clamped to minimum m. See FloatingPointVector<T, size, DataContainer>::clampMin().

Definition at line 495 of file mlFloatingPointVector.h.

◆ compAbs() [1/2]

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > compAbs ( FloatingPointVector< T, size, DataContainer > vec )

Returns a vector with all components from vec without negative sign.

Definition at line 447 of file mlFloatingPointVector.h.

◆ compDiv() [1/2]

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > compDiv	(	FloatingPointVector< T, size, DataContainer >	vec,
		const FloatingPointVector< T, size, DataContainer > &	d )

Component-wise division of vec / d. Division by zeros are not handled and must be avoided by caller.

Definition at line 482 of file mlFloatingPointVector.h.

◆ compMax() [1/2]

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > compMax	(	FloatingPointVector< T, size, DataContainer >	buffer1,
		const FloatingPointVector< T, size, DataContainer > &	buffer2 )

Component-wise maximum of buffer1 and buffer2.

Definition at line 435 of file mlFloatingPointVector.h.

Referenced by ml::SubImageBoxd::clamp(), and ml::SubImageBoxd::intersect().

◆ compMin() [1/2]

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > compMin	(	FloatingPointVector< T, size, DataContainer >	buffer1,
		const FloatingPointVector< T, size, DataContainer > &	buffer2 )

Component-wise minimum of buffer1 and buffer2.

Definition at line 423 of file mlFloatingPointVector.h.

Referenced by ml::SubImageBoxd::clamp(), and ml::SubImageBoxd::intersect().

◆ compMul() [1/2]

template<class T, size_t size, class DataContainer>

T compMul ( const FloatingPointVector< T, size, DataContainer > & vec )

Returns the product of all components.

Definition at line 537 of file mlFloatingPointVector.h.

◆ compSqr() [1/2]

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > compSqr ( FloatingPointVector< T, size, DataContainer > vec )

Returns a vector with all components from vec squared.

Definition at line 458 of file mlFloatingPointVector.h.

◆ compSqrt() [1/2]

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > compSqrt ( FloatingPointVector< T, size, DataContainer > vec )

Returns a vector with all components from vec square-rooted.

Definition at line 470 of file mlFloatingPointVector.h.

◆ convertTo()

template<typename T, std::size_t N>

T ml::convertTo ( const char(&) t[N] )

Example:

 void ExampleModule::calculateOutputSubImage(SubImage *outSubImage, int outIndex,
                                             SubImage *inputSubImage)
 {
   auto input = createTSubImageVariant<MLuint8, MLint8, MLuint16, MLint16, MLuint32, MLint32,
                                       MLuint64, MLint64, MLfloat, MLdouble>(inputSubImage);
   auto output = createTSubImageVariant<MLuint8, MLint8, MLuint16, MLint16, MLuint32, MLint32,
                                        MLuint64, MLint64, MLfloat, MLdouble>(outSubImage);
 
   auto visitor = [this, outIndex](auto &out, const auto &in)
     { calculateOutputSubImage(out, outIndex, in); };
 
   std::visit(visitor, output, input);
 }
 
 
 template <typename T, typename U>
 void ExampleModule::calculateOutputSubImage(TSubImage<T> &outputSubImage,
                                             int outputIndex,
                                             const TSubImage<U> &inputSubImage)
{
  // do the output image calculation here 
}

Parameters

image The input SubImage

Definition at line 242 of file mlTSubImageVariant.h.

◆ createTSubImageVariantArray()

template<std::size_t N, typename... T>

TSubImageVariantArray< N, T... > ml::createTSubImageVariantArray ( const SubImage * inputs )

Creates from input SubImages an array of variant of any of the provided types T containing the TSubImage<T>.

Example:

void ExampleModule::calculateOutputSubImage(SubImage *outSubImage,
                                            int outIndex,
                                            SubImage *inSubImage)
{
  auto inputs =
      createTSubImageVariantArray<NumberInputs, MLuint8, MLint8, MLuint16, MLint16, MLuint32,
                                  MLint32, MLuint64, MLint64, MLfloat, MLdouble>(inSubImage);
  auto output = createTSubImageVariant<MLuint8, MLint8, MLuint16, MLint16, MLuint32, MLint32,
                                       MLuint64, MLint64, MLfloat, MLdouble>(outSubImage);
 
  auto visitor = [this, outIndex](auto &out, const auto &in)
    { calculateOutputSubImage(out, outIndex, in); };
 
  std::visit(visitor, output, inputs);
}
 
template <typename T, typename U, std::size_t N>
void ExampleModule::calculateOutputSubImage(TSubImage<T> &outputSubImage,
                                            int outputIndex,
                                            const std::array<TSubImage<U>, N> &inputSubImage)
{
  // do the output image calculation here
}

Parameters

input A C-array of size N of valid input pointers

Definition at line 316 of file mlTSubImageVariant.h.

◆ createTSubImageVariantArrayPair()

template<std::size_t N, typename... T>

TSubImageVariantArrayPair< N, T... > ml::createTSubImageVariantArrayPair	(	SubImage &	output,
		const SubImage *	inputs )

Creates from the provided output and input SubImages a variant of a pair of TSubImage and array of TSubImages. Input and output types are always the same.

Example:

void ExampleModule::calculateOutputSubImage(SubImage *outputSubImage,
                                            int outIndex,
                                            SubImage *inputSubImages)
{
  auto variantArrayPair =
      createTSubImageVariantArrayPair<NumberInputs, MLuint8, MLint8, MLuint16, MLint16, MLuint32,
                                  MLint32, MLuint64, MLint64, MLfloat, MLdouble>(*outputSubImage,
                                                                                 inputSubImages);
 
  auto visitor = [this, outIndex](auto &ip)
    { calculateOutputSubImage(ip.output, outIndex, ip.inputs); };
 
  std::visit(visitor, variantArrayPair);
}
 
template <typename T, std::size_t N>
void ExampleModule::calculateOutputSubImage(TSubImage<T> &outputSubImage,
                                            int outIndex,
                                            const std::array<TSubImage<T>, N> &inputSubImages)
{
  // do the output image calculation here
}

Parameters

output	The output image
input	A C-array of size N of valid input pointers

Definition at line 355 of file mlTSubImageVariant.h.

References ml::SubImage::getDataType().

◆ createTSubImageVariantPair()

template<typename... T>

TSubImageVariantPair< T... > ml::createTSubImageVariantPair	(	SubImage &	output,
		const SubImage *	input )

Creates from the provided output and input SubImage a variant of any of the provided types T containing the TSubImage<T>. The input and output voxel types are always the same.

Example:

void ExampleModule::calculateOutputSubImage(SubImage* outputSubImage, int outIndex, SubImage* inputSubImage)
{
  auto imagePair =
      createTSubImageVariantPair<MLuint8, MLint8, MLuint16, MLint16, MLuint32, MLint32, MLuint64,
                                 MLint64, MLfloat, MLdouble>(*outputSubImage, inputSubImage);
 
  auto visitor = [this, outIndex](auto& ip) { calculateOutputSubImage(ip.output, outIndex, ip.input); };
 
  std::visit(visitor, imagePair);
}
 
template <typename T>
void ExampleModule::calculateOutputSubImage(TSubImage<T>& outputSubImage, int, TSubImage<T>& inputSubImage0)
{
  // do the output image calculation here
}  

Parameters

output	The output SubImage
input	A valid pointer to a single input image

Definition at line 276 of file mlTSubImageVariant.h.

◆ execute_default()

void ML_UTILS_EXPORT ml::execute_default ( stlab::task< void()> f )

References execute_default(), and ML_UTILS_EXPORT.

Referenced by execute_default().

◆ execute_high()

void ML_UTILS_EXPORT ml::execute_high ( stlab::task< void()> f )

References execute_high(), and ML_UTILS_EXPORT.

Referenced by execute_high().

◆ execute_low()

void ML_UTILS_EXPORT ml::execute_low ( stlab::task< void()> f )

References execute_low(), and ML_UTILS_EXPORT.

Referenced by execute_low().

◆ flatten()

template<typename T>

void ml::flatten	(	const tree_node< T > &	tree,
		std::vector< T > &	flatten_elements )

Definition at line 33 of file mlContainers.h.

References ml::tree_node< T >::children, flatten(), and ml::tree_node< T >::value.

Referenced by flatten().

◆ hash_value()

std::size_t ml::hash_value ( ConstantString const & b )

inline

Definition at line 179 of file mlConstantString.h.

References ml::ConstantString::getHash(), and hash_value().

Referenced by hash_value().

◆ identity2D()

template<class DT>

Tmat3< DT > ml::identity2D ( )

Returns a 3x3 homogeneous identity2D matrix; synonym for Tmat3<DT>::getIdentity().

Definition at line 502 of file mlMatrix3.h.

References ml::Tmat3< DT >::getIdentity(), and identity2D().

Referenced by identity2D().

◆ identity3D()

template<class DT>

Tmat4< DT > ml::identity3D ( )

Returns a 4x4 homogeneous identity3D matrix; synonym for Tmat4<DT>::getIdentity().

Definition at line 597 of file mlMatrix4.h.

References ml::Tmat4< DT >::getIdentity(), and identity3D().

Referenced by identity3D().

◆ insert_set_sorted()

template<typename T>

void ml::insert_set_sorted	(	tree_node< T > &	tree,
		T	newValue,
		T	zero = {} )

Definition at line 51 of file mlContainers.h.

References insert_set_sorted().

Referenced by insert_set_sorted().

◆ intrusive_ptr_add_ref()

void ml::intrusive_ptr_add_ref ( const ml::RefCountedBase * p )

inline

Definition at line 67 of file mlRefCountedBase.h.

References intrusive_ptr_add_ref().

Referenced by intrusive_ptr_add_ref().

◆ intrusive_ptr_release()

void ml::intrusive_ptr_release ( const ml::RefCountedBase * p )

inline

Definition at line 72 of file mlRefCountedBase.h.

References intrusive_ptr_release().

Referenced by intrusive_ptr_release().

◆ iround()

ML_UTILS_EXPORT int ml::iround ( double x )

References iround(), and ML_UTILS_EXPORT.

Referenced by iround().

◆ iroundf()

ML_UTILS_EXPORT int ml::iroundf ( float x )

References iroundf(), and ML_UTILS_EXPORT.

Referenced by iroundf().

◆ is()

template<class T>

Is< T > ml::is ( T d )

constexpr

Definition at line 41 of file mlContainerHelpers.h.

References is().

Referenced by is(), ml::FloatingPointVector< T, size, DataContainer >::readIn(), and ml::FloatingPointVector< DT, 10 >::readIn().

◆ is_rotated() [1/2]

template<typename Range1, typename Range2>

Range2::const_iterator ml::is_rotated	(	const Range1 &	range1,
		const Range2 &	range2 )

constexpr

Definition at line 231 of file mlContainerHelpers.h.

References is_rotated().

◆ is_rotated() [2/2]

template<typename Range1, typename Range2, typename BinaryPredicate>

Range2::const_iterator ml::is_rotated	(	const Range1 &	range1,
		const Range2 &	range2,
		BinaryPredicate	p )

constexpr

Definition at line 191 of file mlContainerHelpers.h.

References is_rotated().

Referenced by is_rotated(), and is_rotated().

◆ logTypeComponentsFromStringError()

void ML_UTILS_EXPORT ml::logTypeComponentsFromStringError ( const char * function )

References logTypeComponentsFromStringError(), and ML_UTILS_EXPORT.

Referenced by logTypeComponentsFromStringError(), and ml::MLTStdTypeInfos< VTYP >::MLTYPE_setStringValue().

◆ lround()

ML_UTILS_EXPORT long ml::lround ( double x )

References lround(), and ML_UTILS_EXPORT.

Referenced by lround().

◆ lroundf()

ML_UTILS_EXPORT long ml::lroundf ( float x )

References lroundf(), and ML_UTILS_EXPORT.

Referenced by lroundf().

◆ mlAbs()

template<typename T>

T ml::mlAbs ( T a )

Defines ML specific abs template since only type-dependent library functions exists.

Definition at line 84 of file mlUtilsSystem.h.

References mlAbs().

Referenced by mlAbs().

◆ MLCallMethodWithArguments() [1/6]

template<class Object, class Method>

void ml::MLCallMethodWithArguments	(	Object *	object,
		Method	method,
		const ArgumentList0 &	)

Calls a method on given object with zero arguments.

Definition at line 108 of file mlArgumentList.h.

References MLCallMethodWithArguments().

Referenced by MLCallMethodWithArguments(), MLCallMethodWithArguments(), MLCallMethodWithArguments(), MLCallMethodWithArguments(), MLCallMethodWithArguments(), and MLCallMethodWithArguments().

◆ MLCallMethodWithArguments() [2/6]

template<class Object, class Method, class Arg1>

void ml::MLCallMethodWithArguments	(	Object *	object,
		Method	method,
		const ArgumentList1< Arg1 > &	args )

Calls a method on given object with one argument.

Definition at line 113 of file mlArgumentList.h.

References ml::ArgumentList1< Arg1 >::_arg1, and MLCallMethodWithArguments().

◆ MLCallMethodWithArguments() [3/6]

template<class Object, class Method, class Arg1, class Arg2>

void ml::MLCallMethodWithArguments	(	Object *	object,
		Method	method,
		const ArgumentList2< Arg1, Arg2 > &	args )

Calls a method on given object with two arguments.

Definition at line 118 of file mlArgumentList.h.

References ml::ArgumentList2< Arg1, Arg2 >::_arg1, ml::ArgumentList2< Arg1, Arg2 >::_arg2, and MLCallMethodWithArguments().

◆ MLCallMethodWithArguments() [4/6]

template<class Object, class Method, class Arg1, class Arg2, class Arg3>

void ml::MLCallMethodWithArguments	(	Object *	object,
		Method	method,
		const ArgumentList3< Arg1, Arg2, Arg3 > &	args )

Calls a method on given object with three arguments.

Definition at line 124 of file mlArgumentList.h.

References ml::ArgumentList3< Arg1, Arg2, Arg3 >::_arg1, ml::ArgumentList3< Arg1, Arg2, Arg3 >::_arg2, ml::ArgumentList3< Arg1, Arg2, Arg3 >::_arg3, and MLCallMethodWithArguments().

◆ MLCallMethodWithArguments() [5/6]

template<class Object, class Method, class Arg1, class Arg2, class Arg3, class Arg4>

void ml::MLCallMethodWithArguments	(	Object *	object,
		Method	method,
		const ArgumentList4< Arg1, Arg2, Arg3, Arg4 > &	args )

Calls a method on given object with four arguments.

Definition at line 129 of file mlArgumentList.h.

References ml::ArgumentList4< Arg1, Arg2, Arg3, Arg4 >::_arg1, ml::ArgumentList4< Arg1, Arg2, Arg3, Arg4 >::_arg2, ml::ArgumentList4< Arg1, Arg2, Arg3, Arg4 >::_arg3, ml::ArgumentList4< Arg1, Arg2, Arg3, Arg4 >::_arg4, and MLCallMethodWithArguments().

◆ MLCallMethodWithArguments() [6/6]

template<class Object, class Method, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5>

void ml::MLCallMethodWithArguments	(	Object *	object,
		Method	method,
		const ArgumentList5< Arg1, Arg2, Arg3, Arg4, Arg5 > &	args )

Calls a method on given object with five arguments.

Definition at line 134 of file mlArgumentList.h.

References ml::ArgumentList5< Arg1, Arg2, Arg3, Arg4, Arg5 >::_arg1, ml::ArgumentList5< Arg1, Arg2, Arg3, Arg4, Arg5 >::_arg2, ml::ArgumentList5< Arg1, Arg2, Arg3, Arg4, Arg5 >::_arg3, ml::ArgumentList5< Arg1, Arg2, Arg3, Arg4, Arg5 >::_arg4, ml::ArgumentList5< Arg1, Arg2, Arg3, Arg4, Arg5 >::_arg5, and MLCallMethodWithArguments().

◆ MLGenerateArgumentList() [1/6]

ArgumentList0 ml::MLGenerateArgumentList ( )

inline

Creates argument list with zero arguments.

Definition at line 80 of file mlArgumentList.h.

References MLGenerateArgumentList().

Referenced by MLGenerateArgumentList(), MLGenerateArgumentList(), MLGenerateArgumentList(), MLGenerateArgumentList(), MLGenerateArgumentList(), and MLGenerateArgumentList().

◆ MLGenerateArgumentList() [2/6]

template<class Arg1>

ArgumentList1< Arg1 > ml::MLGenerateArgumentList ( const Arg1 & arg1 )

inline

Create argument list with one argument.

Definition at line 84 of file mlArgumentList.h.

References MLGenerateArgumentList().

◆ MLGenerateArgumentList() [3/6]

template<class Arg1, class Arg2>

ArgumentList2< Arg1, Arg2 > ml::MLGenerateArgumentList	(	const Arg1 &	arg1,
		const Arg2 &	arg2 )

inline

Creates argument list with two arguments.

Definition at line 89 of file mlArgumentList.h.

References MLGenerateArgumentList().

◆ MLGenerateArgumentList() [4/6]

template<class Arg1, class Arg2, class Arg3>

ArgumentList3< Arg1, Arg2, Arg3 > ml::MLGenerateArgumentList	(	const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3 )

inline

Creates argument list with three arguments.

Definition at line 93 of file mlArgumentList.h.

References MLGenerateArgumentList().

◆ MLGenerateArgumentList() [5/6]

template<class Arg1, class Arg2, class Arg3, class Arg4>

ArgumentList4< Arg1, Arg2, Arg3, Arg4 > ml::MLGenerateArgumentList	(	const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4 )

inline

Creates argument list with four arguments.

Definition at line 98 of file mlArgumentList.h.

References MLGenerateArgumentList().

◆ MLGenerateArgumentList() [6/6]

template<class Arg1, class Arg2, class Arg3, class Arg4, class Arg5>

ArgumentList5< Arg1, Arg2, Arg3, Arg4, Arg5 > ml::MLGenerateArgumentList	(	const Arg1 &	arg1,
		const Arg2 &	arg2,
		const Arg3 &	arg3,
		const Arg4 &	arg4,
		const Arg5 &	arg5 )

inline

Creates argument list with five arguments.

Definition at line 102 of file mlArgumentList.h.

References MLGenerateArgumentList().

◆ MLInitFields()

MLEXPORT void ml::MLInitFields ( )

Initialize all standard fields of the ML.

References MLEXPORT, and MLInitFields().

Referenced by MLInitFields().

◆ MLInitListFields()

MLEXPORT void ml::MLInitListFields ( )

Initialize all multi-fields of the ML.

References MLEXPORT, and MLInitListFields().

Referenced by MLInitListFields().

◆ MLInverseMatHelper()

template<class BASE_TYPE>

BASE_TYPE ml::MLInverseMatHelper	(	const BASE_TYPE &	origMat,
		bool *	isInvertible,
		const typename BASE_TYPE::ComponentType	,
		const char *const	ZeroDetErrString,
		const BASE_TYPE &	Identity,
		const size_t	Dim )

Computes an N dimensional inverse from given default parameters. The used algorithm is the Gauss-Jordan elimination with partial pivoting.

Parameters

origMat	The matrix to be inverted.
isInvertible	If a non-NULL boolean pointer is passed to isInvertible, then `true` is returned in *isInvertible in the case of a successful inversion or `false` if the inversion is not possible (function returns the identity then). If a NULL pointer is passed as isInvertible, the matrix must be invertible; otherwise, errors will occur.
ZeroEpsilon	Unused. Former versions used this as an epsilon value to compare to decide whether the determinant is zero. Now, an MLValueIs0WOM check is used.
ZeroDetErrString	Error to be posted if isInvertible is NULL and inverse cannot be calculated.
Identity	Identity to be returned in case of errors.
Dim	The dimension of the matrix.

Definition at line 60 of file mlLinearAlgebraTools.h.

References ML_BAD_PARAMETER, MLAbs(), MLInverseMatHelper(), MLSwap(), MLValueIs0WOM(), and printTemplateError().

Referenced by ml::Tmat3< DT >::inverse(), ml::Tmat4< DT >::inverse(), ml::Tmat5< DT >::inverse(), ml::Tmat6< DT >::inverse(), and MLInverseMatHelper().

◆ mlMax()

template<typename T>

T ml::mlMax	(	T	a,
		T	b )

Defines ML specific max template since max template is platform-dependent. See also ML_MIN and ML_MAX macros in mlTypeDefs.h.

Definition at line 75 of file mlUtilsSystem.h.

References mlMax().

Referenced by mlMax().

◆ mlMin()

template<typename T>

T ml::mlMin	(	T	a,
		T	b )

Defines ML specific min template since min template is platform-dependent. See also ML_MIN and ML_MAX macros in mlTypeDefs.h.

Definition at line 71 of file mlUtilsSystem.h.

References mlMin().

Referenced by mlMin().

◆ MLSwap()

template<class OBJ_TYPE>

void ml::MLSwap	(	OBJ_TYPE &	obj1,
		OBJ_TYPE &	obj2 )

Swaps two objects obj1 and obj2. It requires valid assignment operators on OBJ_TYP.

Definition at line 33 of file mlLinearAlgebraTools.h.

References MLSwap().

Referenced by MLInverseMatHelper(), and MLSwap().

◆ operator!() [1/2]

template<class T, size_t size, class DataContainer>

bool operator! ( const FloatingPointVector< T, size, DataContainer > & a )

Returns whether all components are 0.

Definition at line 326 of file mlFloatingPointVector.h.

◆ operator!=() [1/5]

template<class DT>

bool ml::operator!=	(	const Tmat2< DT > &	a,
		const Tmat2< DT > &	b )

inline

a != b ? Returns true if yes.

Definition at line 433 of file mlMatrix2.h.

References operator!=().

Referenced by operator!=(), operator!=(), operator!=(), operator!=(), and operator!=().

◆ operator!=() [2/5]

template<class DT>

bool ml::operator!=	(	const Tmat3< DT > &	a,
		const Tmat3< DT > &	b )

inline

a != b ? Return true if yes; otherwise, it returns false.

Definition at line 486 of file mlMatrix3.h.

References operator!=().

◆ operator!=() [3/5]

template<class DT>

bool ml::operator!=	(	const Tmat4< DT > &	a,
		const Tmat4< DT > &	b )

inline

a != b ? Returns true if yes.

Definition at line 376 of file mlMatrix4.h.

References operator!=().

◆ operator!=() [4/5]

template<class DT>

bool ml::operator!=	(	const Tmat5< DT > &	a,
		const Tmat5< DT > &	b )

inline

a != b ? Returns true if yes; otherwise, it returns false.

Definition at line 686 of file mlMatrix5.h.

References operator!=().

◆ operator!=() [5/5]

template<class DT>

bool ml::operator!=	(	const Tmat6< DT > &	a,
		const Tmat6< DT > &	b )

a != b ? Returns true if yes; otherwise, it returns false.

Definition at line 596 of file mlMatrix6.h.

References operator!=().

◆ operator*() [1/33]

template<class DT>

Tmat2< DT > ml::operator*	(	const DT	d,
		const Tmat2< DT > &	a )

inline

Returns the component-wise multiplication of scalar d with matrix a.

Definition at line 474 of file mlMatrix2.h.

References operator*().

◆ operator*() [2/33]

template<class DT>

Tmat3< DT > ml::operator*	(	const DT	d,
		const Tmat3< DT > &	a )

inline

Returns the component-wise multiplication of scalar d with matrix a.

Definition at line 302 of file mlMatrix3.h.

References operator*().

◆ operator*() [3/33]

template<class DT>

Tmat4< DT > ml::operator*	(	const DT	d,
		const Tmat4< DT > &	a )

inline

Returns the component-wise multiplication of scalar d with matrix a.

Definition at line 417 of file mlMatrix4.h.

References operator*().

◆ operator*() [4/33]

template<class DT>

Tmat5< DT > ml::operator*	(	const DT	d,
		const Tmat5< DT > &	a )

inline

Returns the component-wise product of scalar d with matrix a.

Definition at line 338 of file mlMatrix5.h.

References operator*().

◆ operator*() [5/33]

template<class DT>

Tmat6< DT > ml::operator*	(	const DT	d,
		const Tmat6< DT > &	a )

inline

Returns the component-wise product of scalar d with matrix a.

Definition at line 335 of file mlMatrix6.h.

References operator*().

◆ operator*() [6/33]

template<class T, size_t size, class DataContainer>

T operator*	(	const FloatingPointVector< T, size, DataContainer > &	a,
		const FloatingPointVector< T, size, DataContainer > &	b )

Dot product, returns a.dot(b).

Definition at line 383 of file mlFloatingPointVector.h.

Referenced by operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), operator*(), and operator*().

◆ operator*() [7/33]

template<class DT>

Tmat2< DT > ml::operator*	(	const Tmat2< DT > &	a,
		const Tmat2< DT > &	b )

inline

Definition at line 414 of file mlMatrix2.h.

References _ML_MAT2_RC, and operator*().

◆ operator*() [8/33]

template<class DT>

Tvec2< DT > ml::operator*	(	const Tmat2< DT > &	a,
		const Tvec2< DT > &	v )

inline

Normal multiplication of 2x2 matrix a with 2D vector v with a Tvec2 as result.

Definition at line 492 of file mlMatrix2.h.

References operator*().

◆ operator*() [9/33]

template<class DT>

Tmat2< DT > ml::operator*	(	const Tmat2< DT > &	a,
		DT	d )

inline

Returns the component-wise multiplication of matrix a with scalar d.

Definition at line 467 of file mlMatrix2.h.

References operator*().

◆ operator*() [10/33]

template<class DT>

Tmat3< DT > ml::operator*	(	const Tmat3< DT > &	a,
		const DT	d )

inline

Returns the component-wise multiplication of matrix a with scalar d.

Definition at line 295 of file mlMatrix3.h.

References operator*().

◆ operator*() [11/33]

template<class DT>

Tmat3< DT > ml::operator*	(	const Tmat3< DT > &	a,
		const Tmat3< DT > &	b )

inline

Matrix 3 product.

Definition at line 462 of file mlMatrix3.h.

References _ML_MAT3_RC, and operator*().

◆ operator*() [12/33]

template<class DT, class DT2>

Tvec3< DT > ml::operator*	(	const Tmat3< DT > &	a,
		const Tvec3< DT2 > &	v )

inline

Normal multiplication of 3x3 matrix a with 3D vector v with a Tvec3 as result.

Definition at line 216 of file mlVector3.h.

References operator*().

◆ operator*() [13/33]

template<class DT>

Tmat4< DT > ml::operator*	(	const Tmat4< DT > &	a,
		const DT	d )

inline

Returns the component-wise multiplication of matrix a with scalar d.

Definition at line 410 of file mlMatrix4.h.

References operator*().

◆ operator*() [14/33]

template<class DT>

Tmat4< DT > ml::operator*	(	const Tmat4< DT > &	a,
		const Tmat4< DT > &	b )

inline

a * b. Standard matrix multiplication.

Note: Hint on concatentation of matrices: b.transformPoint(a.transformPoint(v)) is equivalent to (b*a).transformPoint(v)

Definition at line 352 of file mlMatrix4.h.

References _ML_MAT4_RC, and operator*().

◆ operator*() [15/33]

template<class DT, class DT2>

Tvec3< DT > ml::operator*	(	const Tmat4< DT > &	a,
		const Tvec3< DT2 > &	v )

inline

Interprets v as a 4D homogeneous point, multiplies the 4x4 matrix M with it, and returns a Tvec3 after normalizing the result by dividing by the fourth component. It is up to the caller to guarantee that matrix a multiplied with a homogeneous 4D point results in a homogeneous point to avoid divisions by zero on normalizing the result.

Definition at line 242 of file mlVector3.h.

References ml::Tvec3< DT >::affinePoint(), and operator*().

◆ operator*() [16/33]

template<class DT>

Tvec4< DT > ml::operator*	(	const Tmat4< DT > &	a,
		const Tvec4< DT > &	v )

inline

Multiplies 4x4 matrix a with vector v.

Definition at line 135 of file mlVector4.h.

References _ML_VEC4_RC, and operator*().

◆ operator*() [17/33]

template<class DT>

Tmat5< DT > ml::operator*	(	const Tmat5< DT > &	a,
		const DT	d )

inline

Returns the component-wise product of matrix a with scalar d.

Definition at line 331 of file mlMatrix5.h.

References operator*().

◆ operator*() [18/33]

template<class DT>

Tmat5< DT > ml::operator*	(	const Tmat5< DT > &	a,
		const Tmat5< DT > &	b )

Matrix product.

Definition at line 655 of file mlMatrix5.h.

References _ML_MAT5_RC, and operator*().

◆ operator*() [19/33]

template<class DT>

Tvec5< DT > ml::operator*	(	const Tmat5< DT > &	a,
		const Tvec5< DT > &	v )

inline

Multiplies 5x5 matrix a with vector v.

Definition at line 180 of file mlVector5.h.

References _ML_VEC5_RC, and operator*().

◆ operator*() [20/33]

template<class DT>

Tmat6< DT > ml::operator*	(	const Tmat6< DT > &	a,
		const DT	d )

inline

Returns the component-wise product of matrix a with scalar d.

Definition at line 328 of file mlMatrix6.h.

References operator*().

◆ operator*() [21/33]

template<class DT>

Tmat6< DT > ml::operator*	(	const Tmat6< DT > &	a,
		const Tmat6< DT > &	b )

Matrix product.

Definition at line 567 of file mlMatrix6.h.

References _ML_MAT6_RC, and operator*().

◆ operator*() [22/33]

template<class DT>

Tvec6< DT > ml::operator*	(	const Tmat6< DT > &	a,
		const Tvec6< DT > &	v )

inline

Multiplies 6x6 matrix a with vector v.

Definition at line 607 of file mlMatrix6.h.

References _ML_MAT6_RC, and operator*().

◆ operator*() [23/33]

template<class DT>

Tvec2< DT > ml::operator*	(	const Tvec2< DT > &	v,
		const Tmat2< DT > &	a )

inline

Normal multiplication of 2D vector v with 2x2 matrix with a Tvec2 as result.

Definition at line 500 of file mlMatrix2.h.

References operator*(), and ml::Tmat2< DT >::transpose().

◆ operator*() [24/33]

template<class DT, class DT2>

Tvec3< DT > ml::operator*	(	const Tvec3< DT > &	v,
		const Tmat3< DT2 > &	a )

inline

Normal multiplication of 3D vector v with 3x3 matrix with a Tvec3 as result.

Definition at line 228 of file mlVector3.h.

References operator*(), and ml::Tmat3< DT >::transpose().

◆ operator*() [25/33]

template<class DT, class DT2>

Tvec3< DT > ml::operator*	(	const Tvec3< DT > &	v,
		const Tmat4< DT2 > &	a )

inline

Interprets v as a 4D homogeneous point, multiplies it with the 4x4 matrix M, and returns a Tvec3 after normalizing the result by dividing by the fourth component. It is up to the caller to guarantee that matrix a multiplied with a homogeneous 4D point results in a homogeneous point to avoid divisions by zero on normalizing the result.

Definition at line 257 of file mlVector3.h.

References operator*(), and ml::Tmat4< DT >::transpose().

◆ operator*() [26/33]

template<class DT>

Tvec4< DT > ml::operator*	(	const Tvec4< DT > &	v,
		const Tmat4< DT > &	a )

inline

Multiplies vector v with 4x4 matrix a.

Definition at line 145 of file mlVector4.h.

References operator*(), and ml::Tmat4< DT >::transpose().

◆ operator*() [27/33]

template<class DT>

Tvec5< DT > ml::operator*	(	const Tvec5< DT > &	v,
		const Tmat5< DT > &	a )

inline

Multiplies vector v with 5x5 matrix a.

Definition at line 190 of file mlVector5.h.

References operator*(), and ml::Tmat5< DT >::transpose().

◆ operator*() [28/33]

template<class DT>

Tvec6< DT > ml::operator*	(	const Tvec6< DT > &	v,
		const Tmat6< DT > &	a )

inline

Multiplies vector v with 6x6 matrix a.

Definition at line 617 of file mlMatrix6.h.

References operator*(), and ml::Tmat6< DT >::transpose().

◆ operator*() [29/33]

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > operator*	(	FloatingPointVector< T, size, DataContainer >	lhs,
		MLdouble	rhs )

Component-wise multiplication of lhs with rhs.

Definition at line 393 of file mlFloatingPointVector.h.

◆ operator*() [30/33]

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > operator*	(	MLdouble	lhs,
		FloatingPointVector< T, size, DataContainer >	rhs )

Component-wise multiplication of rhs with lhs.

Definition at line 403 of file mlFloatingPointVector.h.

◆ operator*=() [1/4]

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > & operator*=	(	FloatingPointVector< T, size, DataContainer > &	op1,
		const FloatingPointVector< T, size, DataContainer > &	op2 )

Arithmetic assignment: Component-wise multiplication *this with a vector of the same size.

Definition at line 285 of file mlFloatingPointVector.h.

◆ operator*=() [2/4]

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > & operator*=	(	FloatingPointVector< T, size, DataContainer > &	op1,
		MLdouble	value )

Arithmetic assignment: Component-wise multiplication *this with specialized MLdouble scalar value.

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > operator+	(	FloatingPointVector< T, size, DataContainer >	lhs,
		const FloatingPointVector< T, size, DataContainer > &	rhs )

Return value is the component-wise addition of lhs and rhs.

Definition at line 338 of file mlFloatingPointVector.h.

Referenced by operator+(), operator+(), operator+(), operator+(), and operator+().

◆ operator+=() [1/2]

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > & operator+=	(	FloatingPointVector< T, size, DataContainer > &	op1,
		const FloatingPointVector< T, size, DataContainer > &	buffer )

Arithmetic assignment: Component-wise addition.

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > operator-	(	FloatingPointVector< T, size, DataContainer >	lhs,
		const FloatingPointVector< T, size, DataContainer > &	rhs )

Return value is the component-wise subtraction of rhs from lhs.

Definition at line 349 of file mlFloatingPointVector.h.

Referenced by operator-(), operator-(), operator-(), operator-(), operator-(), operator-(), operator-(), operator-(), operator-(), and operator-().

◆ operator-=() [1/2]

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > & operator-=	(	FloatingPointVector< T, size, DataContainer > &	op1,
		const FloatingPointVector< T, size, DataContainer > &	buffer )

Arithmetic assignment: Component-wise subtraction of buffer from *this.

Definition at line 263 of file mlFloatingPointVector.h.

◆ operator/() [1/7]

template<class DT>

Tmat2< DT > ml::operator/	(	const Tmat2< DT > &	a,
		const DT	d )

inline

Returns the component-wise division of matrix a by scalar d. Division by zero is not handled and must be avoided by caller.

Definition at line 482 of file mlMatrix2.h.

References operator/().

◆ operator/() [2/7]

template<class DT>

Tmat3< DT > ml::operator/	(	const Tmat3< DT > &	a,
		const DT	d )

inline

Returns the component-wise division of matrix a by scalar d. Division by zero is not handled and must be avoided by caller.

Definition at line 310 of file mlMatrix3.h.

References operator/().

◆ operator/() [3/7]

template<class DT>

Tmat4< DT > ml::operator/	(	const Tmat4< DT > &	a,
		const DT	d )

inline

Returns the component-wise division of matrix a by scalar d. Division by zero is not handled and must be avoided by caller.

Definition at line 425 of file mlMatrix4.h.

References operator/().

◆ operator/() [4/7]

template<class DT>

Tmat5< DT > ml::operator/	(	const Tmat5< DT > &	a,
		const DT	d )

inline

Returns the component-wise division of matrix a by scalar d. Division by zero is not handled and must be avoided by caller.

Definition at line 346 of file mlMatrix5.h.

References ML_CHECK_FLOAT_THROW, and operator/().

◆ operator/() [5/7]

template<class DT>

Tmat6< DT > ml::operator/	(	const Tmat6< DT > &	a,
		const DT	d )

inline

Returns the component-wise division of matrix a by scalar d. Division by zero is not handled and must be avoided by caller.

Definition at line 343 of file mlMatrix6.h.

References ML_CHECK_FLOAT_THROW, and operator/().

◆ operator/() [6/7]

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > operator/	(	FloatingPointVector< T, size, DataContainer >	lhs,
		MLdouble	rhs )

Component-wise division of lhs by specialized rhs of type MLdouble.

Definition at line 413 of file mlFloatingPointVector.h.

Referenced by operator/(), operator/(), operator/(), operator/(), and operator/().

◆ operator/=() [1/4]

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > & operator/=	(	FloatingPointVector< T, size, DataContainer > &	op1,
		const FloatingPointVector< T, size, DataContainer > &	op2 )

Arithmetic assignment: Component-wise division of *this by the values of a vector of the same size. Division by zero is not handled and must be avoided by user.

Definition at line 312 of file mlFloatingPointVector.h.

◆ operator/=() [2/4]

template<class T, size_t size, class DataContainer>

FloatingPointVector< T, size, DataContainer > & operator/=	(	FloatingPointVector< T, size, DataContainer > &	op1,
		MLdouble	value )

Arithmetic assignment: Component-wise division of *this by scalar value. Division by zero is not handled and must be avoided by user.

Definition at line 297 of file mlFloatingPointVector.h.

◆ operator==() [1/5]

template<class DT>

bool ml::operator==	(	const Tmat2< DT > &	a,
		const Tmat2< DT > &	b )

inline

a == b ? Returns true if yes.

Definition at line 425 of file mlMatrix2.h.

References operator==().

Referenced by operator==(), operator==(), operator==(), operator==(), and operator==().

◆ operator==() [2/5]

template<class DT>

bool ml::operator==	(	const Tmat3< DT > &	a,
		const Tmat3< DT > &	b )

inline

a == b ? Return true if yes; otherwise, it returns false.

Definition at line 475 of file mlMatrix3.h.

References operator==().

◆ operator==() [3/5]

template<class DT>

bool ml::operator==	(	const Tmat4< DT > &	a,
		const Tmat4< DT > &	b )

inline

a == b ? Returns true if yes.

Definition at line 366 of file mlMatrix4.h.

References operator==().

◆ operator==() [4/5]

template<class DT>

bool ml::operator==	(	const Tmat5< DT > &	a,
		const Tmat5< DT > &	b )

inline

a == b ? Returns true if yes; otherwise, it returns false.

Definition at line 673 of file mlMatrix5.h.

References operator==().

◆ operator==() [5/5]

template<class DT>

bool ml::operator==	(	const Tmat6< DT > &	a,
		const Tmat6< DT > &	b )

a == b ? Returns true if yes; otherwise, it returns false.

Definition at line 582 of file mlMatrix6.h.

References operator==().

◆ operator^()

template<class DT, class DT2>

Tvec3< DT > ml::operator^	(	const Tvec3< DT > &	a,
		const Tvec3< DT2 > &	b )

inline

Returns a vector orthogonal to a and b.

Definition at line 268 of file mlVector3.h.

References operator^().

Referenced by operator^().

◆ Overload()

template<class... Ts>

ml::Overload ( Ts... ) ->Overload< Ts... >

◆ perspective3D()

template<class DT>

Tmat4< DT > ml::perspective3D ( const DT d )

inline

Creates a 4x4 homogeneous perspective projection matrix with perspective shortening value given by d that must differ from zero to avoid errors.

Definition at line 661 of file mlMatrix4.h.

References ML_CHECK_FLOAT_THROW, and perspective3D().

Referenced by perspective3D().

◆ pre_exit()

void ML_UTILS_EXPORT ml::pre_exit ( )

References ML_UTILS_EXPORT, and pre_exit().

Referenced by pre_exit().

◆ printTemplateError()

void ML_UTILS_EXPORT ml::printTemplateError	(	const char *	location,
		MLErrorCode	reason,
		const std::string_view &	handling )

References ML_UTILS_EXPORT, and printTemplateError().

Referenced by ml::TQuaternion< MLfloat >::arg(), ml::TQuaternion< MLfloat >::div(), ml::TQuaternion< MLfloat >::getAsMat4(), ml::Tmat2< DT >::inverse(), ml::TQuaternion< MLfloat >::inverse(), ml::FloatingPointMatrix< VectorT, size >::linearIndexed(), ml::FloatingPointMatrix< VectorT, size >::linearIndexedConst(), MLInverseMatHelper(), ml::TQuaternion< MLfloat >::normalize(), ml::FloatingPointMatrix< VectorT, size >::operator[](), ml::FloatingPointMatrix< VectorT, size >::operator[](), printTemplateError(), ml::TQuaternion< MLfloat >::sqrt(), and ml::Tvec3< MLfloat >::Tvec3().

◆ printTemplateFatalError()

void ML_UTILS_EXPORT ml::printTemplateFatalError	(	const char *	location,
		MLErrorCode	reason,
		const std::string_view &	handling )

References ML_UTILS_EXPORT, and printTemplateFatalError().

Referenced by printTemplateFatalError().

◆ printTemplateWarning()

void ML_UTILS_EXPORT ml::printTemplateWarning	(	const char *	location,
		MLErrorCode	reason,
		const std::string_view &	handling )

References ML_UTILS_EXPORT, and printTemplateWarning().

Referenced by printTemplateWarning().

◆ rotation2D()

template<class DT>

Tmat3< DT > ml::rotation2D	(	const Tvec2< DT > &	Center,
		const DT	angleDeg )

Returns a 2D rotation matrix as 3D homogeneous matrix where center specifies the center of rotation.

Definition at line 524 of file mlMatrix3.h.

References rotation2D().

Referenced by rotation2D().

◆ rotation3D()

template<class DT>

Tmat4< DT > ml::rotation3D	(	Tvec3< DT >	Axis,
		const DT	angleRad )

Returns a 4x4 homogeneous 3D rotation matrix describing a rotation with angle angleRad around axis Axis.

Definition at line 621 of file mlMatrix4.h.

References ml::FloatingPointVector< T, size, DataContainer >::normalize(), and rotation3D().

Referenced by rotation3D().

◆ round()

ML_UTILS_EXPORT double ml::round ( double x )

References ML_UTILS_EXPORT, and round().

Referenced by round().

◆ roundf()

ML_UTILS_EXPORT float ml::roundf ( float x )

References ML_UTILS_EXPORT, and roundf().

Referenced by roundf().

◆ scaling2D()

template<class DT>

Tmat3< DT > ml::scaling2D ( const Tvec2< DT > & scaleVector )

inline

Returns a 2D scale matrix as 3D homogeneous matrix.

Definition at line 539 of file mlMatrix3.h.

References scaling2D().

Referenced by scaling2D().

◆ scaling3D()

template<class DT>

Tmat4< DT > ml::scaling3D ( const Tvec3< DT > & scaleVector )

inline

Scaling 3D.

Definition at line 647 of file mlMatrix4.h.

References scaling3D().

Referenced by scaling3D().

◆ translation2D()

template<class DT>

Tmat3< DT > ml::translation2D ( const Tvec2< DT > & v )

inline

Returns a 2D translation matrix as 3D homogeneous matrix where the translation is located in the right column.

Definition at line 512 of file mlMatrix3.h.

References translation2D().

Referenced by translation2D().

◆ translation3D()

template<class DT>

Tmat4< DT > ml::translation3D ( const Tvec3< DT > & v )

inline

Returns a 4x4 homogeneous translation matrix with default identity matrix contents and the upper three components in right column given by 3D vector v.

Definition at line 608 of file mlMatrix4.h.

References translation3D().

Referenced by translation3D().

◆ tsubimage_cast() [1/4]

template<typename T>

const TSubImage< T > & ml::tsubimage_cast ( const SubImage & subImg )

Definition at line 1147 of file mlTSubImage.h.

References ml::SubImage::getData(), ml::SubImage::getDataType(), ml::TypeTraits< T >::matches(), ML_BAD_DATA_TYPE, ML_PRINT_FATAL_ERROR, and tsubimage_cast().

◆ tsubimage_cast() [2/4]

template<typename T>

const TSubImage< T > * ml::tsubimage_cast ( const SubImage * subImg )

Definition at line 1171 of file mlTSubImage.h.

References ml::SubImage::getData(), ml::SubImage::getDataType(), ml::TypeTraits< T >::matches(), ML_BAD_DATA_TYPE, ML_PRINT_FATAL_ERROR, and tsubimage_cast().

◆ tsubimage_cast() [3/4]

template<typename T>

TSubImage< T > & ml::tsubimage_cast ( SubImage & subImg )

The tsubimage_cast allows to cast a SubImage (pointer or reference) to a typed TSubImage<T> (pointer or reference). If the cast is not possible because the data type of the SubImage does not match the T of tsubimage_cast<T>, a fatal ML error occurs.

Usage:

TSubImage<MLfloat>& tsubimg = tsubimage_cast<MLfloat>(subimg);

ml::tsubimage_cast

TSubImage< T > & tsubimage_cast(SubImage &subImg)

Definition mlTSubImage.h:1135

Definition at line 1135 of file mlTSubImage.h.

References ml::SubImage::getData(), ml::SubImage::getDataType(), ml::TypeTraits< T >::matches(), ML_BAD_DATA_TYPE, ML_PRINT_FATAL_ERROR, and tsubimage_cast().

Referenced by tsubimage_cast(), tsubimage_cast(), tsubimage_cast(), and tsubimage_cast().

◆ tsubimage_cast() [4/4]

template<typename T>

TSubImage< T > * ml::tsubimage_cast ( SubImage * subImg )

Definition at line 1159 of file mlTSubImage.h.

References ml::SubImage::getData(), ml::SubImage::getDataType(), ml::TypeTraits< T >::matches(), ML_BAD_DATA_TYPE, ML_PRINT_FATAL_ERROR, and tsubimage_cast().

◆ vector_contains()

template<typename T>

bool ml::vector_contains	(	const std::vector< T > &	vec,
		const T &	value )

inline

Helper template that searches for value in given vector vec and returns whether it was found.

Definition at line 27 of file mlStdAlgorithms.h.

References vector_contains().

Referenced by vector_contains().

◆ vector_remove()

template<typename T>

bool ml::vector_remove	(	std::vector< T > &	vec,
		const T &	value )

inline

Helper template that removes the first occurrence of value in given vector vec and returns whether it was found.

Definition at line 33 of file mlStdAlgorithms.h.

References vector_remove().

Referenced by vector_remove().

◆ vector_remove_all()

template<typename T>

void ml::vector_remove_all	(	std::vector< T > &	vec,
		const T &	value )

inline

Helper template that removes all occurrences of value in given vector vec.

Definition at line 45 of file mlStdAlgorithms.h.

References vector_remove_all().

Referenced by vector_remove_all().

◆ vector_replace_by_NULL()

template<typename T>

bool ml::vector_replace_by_NULL	(	std::vector< T > &	vec,
		const T &	value )

inline

Helper template that replaces the first occurrence of value in given vector vec with NULL and returns whether it was found.

Definition at line 58 of file mlStdAlgorithms.h.

References vector_replace_by_NULL().

Referenced by vector_replace_by_NULL().

Variable Documentation

◆ _ML_STD_SLEN

const MLint ml::_ML_STD_SLEN =64

Length of strings for component descriptions and class names.

Definition at line 33 of file mlStdTypeInfos.h.

◆ is_detected_v

template<template< class... > class Op, class... Args>

bool ml::is_detected_v = is_detected<Op, Args...>::value

constexpr

Definition at line 77 of file mlTemplateHelpers.h.

◆ MLErrorOutput

ML_UTILS_EXPORT ErrorOutput ml::MLErrorOutput

extern

This is a singleton used for all ML Error input and output;.

◆ MLGenericType

const int ml::MLGenericType = _ML_SWITCH_SELECT_OFFSET+10

Defines special index to use a generic type.

Definition at line 61 of file mlTypedHandlers.h.

◆ MLGlobalTraceBuffer

ML_UTILS_EXPORT TraceBuffer<MLGlobalTraceBufferType> ml::MLGlobalTraceBuffer

extern

This is a global singleton of the TraceBuffer class. It is used by all ML_TRACE_IN macros in the ML and by ErrorOutput class for dumping in error cases.

◆ MLNotify

ML_UTILS_EXPORT Notify ml::MLNotify

extern

Singleton which contains all registered callback functions of the ML.

◆ MLTStdTypeInfos< VTYP >::_myInfos

template<typename VTYP>

MLTypeInfos* ml::MLTStdTypeInfos< VTYP >::_myInfos = nullptr

Definition at line 497 of file mlStdTypeInfos.h.

◆ MLTStdTypeInfos< VTYP >::_numInstances

template<typename VTYP>

MLint32 ml::MLTStdTypeInfos< VTYP >::_numInstances = 0

Definition at line 498 of file mlStdTypeInfos.h.

◆ MLTStdTypeInfos< VTYP >::_typeDefault

template<typename VTYP>

const VTYP ml::MLTStdTypeInfos< VTYP >::_typeDefault = VTYP(0)

Definition at line 496 of file mlStdTypeInfos.h.

◆ MLVariableType0

const int ml::MLVariableType0 = _ML_SWITCH_SELECT_OFFSET

Defines to use the result type of variable type 0.

Definition at line 53 of file mlTypedHandlers.h.

◆ MLVariableType1

const int ml::MLVariableType1 = _ML_SWITCH_SELECT_OFFSET+1

Defines to use the result type of variable type 1.

Definition at line 55 of file mlTypedHandlers.h.

◆ MLVariableType2

const int ml::MLVariableType2 = _ML_SWITCH_SELECT_OFFSET+2

Defines to use the result type of variable type 2.

Definition at line 57 of file mlTypedHandlers.h.

◆ MLVariableType3

const int ml::MLVariableType3 = _ML_SWITCH_SELECT_OFFSET+3

Defines to use the result type of variable type 3.

Definition at line 59 of file mlTypedHandlers.h.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Standalone functions for FloatingPointVector.

Detailed Description

Typedef Documentation

◆ BaseEventCallback

◆ CalculateOutputImagePropertiesCB

◆ default_executor

◆ detected_t

◆ high_executor

◆ ImagePropertyExtensionVector

◆ ImageVector

◆ is_detected

◆ Lock

◆ low_executor

◆ Matrix2

◆ Matrix2d

◆ Matrix2f

◆ Matrix2ld

◆ Matrix3

◆ Matrix3d

◆ Matrix3f

◆ Matrix3ld

◆ Matrix4

◆ Matrix4d

◆ Matrix4f

◆ Matrix4ld

◆ Matrix5

◆ Matrix5d

◆ Matrix5f

◆ Matrix5ld

◆ Matrix6

◆ Matrix6d

◆ Matrix6f

◆ Matrix6ld

◆ MLGlobalTraceBufferType

◆ Quaternion

◆ Quaterniond

◆ Quaternionf

◆ Quaternionld

◆ RecursiveLock

◆ ScaleShiftData

◆ SubImageBox

◆ Thread

◆ TileRequestFinishedCB

◆ TriggerField

◆ Vector10

◆ Vector10d

◆ Vector10f

◆ Vector10ld

◆ Vector16

◆ Vector16d

◆ Vector16f

◆ Vector16ld

◆ Vector2

◆ Vector2d

◆ Vector2f

◆ Vector2ld

◆ Vector3

◆ Vector32

◆ Vector32d

◆ Vector32f

◆ Vector32ld

◆ Vector3d

◆ Vector3f

◆ Vector3ld

◆ Vector4

◆ Vector4d

◆ Vector4f

◆ Vector4ld

◆ Vector5

◆ Vector5d

◆ Vector5f

◆ Vector5ld

◆ Vector6

◆ Vector64