ufo Namespace Reference

All vision-related classes and functions. More...

Namespaces
namespace	color
namespace	compute
namespace	pred

Classes
struct	AABB
	Axis-Aligned Bounding Box (AABB) in Dim-dimensional space. More...
class	AngularIntegrator
struct	argument_helper_2
struct	argument_helper_2< 0, Arg, Rest... >
struct	as_tuple
struct	as_tuple< std::tuple< U... > >
class	BaseBuffer
class	BitSet
class	Buffer
struct	Capsule
	Capsule in Dim-dimensional space. More...
struct	CloudProperties
	Flags describing which optional per-point channels are present in a cloud file. More...
struct	CloudUFOOptions
struct	color_traits
	Primary template - intentionally undefined. More...
struct	color_traits< Gray< T, Flags > >
struct	color_traits< Lab< T, Flags > >
struct	color_traits< Lch< T, Flags > >
struct	color_traits< Lrgb< T, Flags > >
struct	color_traits< Rgb< T, Flags > >
struct	ColorBlock
struct	ColorMapT
struct	Confidence
	Represents a confidence score as a single float value. More...
struct	contains_color
	True if any type in Ts… is a color type. More...
struct	contains_constructible_type
struct	contains_convertible_type
struct	contains_type
struct	contains_type< T, SoA< Ts... > >
struct	CostBlock
struct	CostElement
class	CostMap
class	CountMap
struct	Cylinder
	Cylinder in Dim-dimensional space. More...
struct	dependent_false
struct	DistanceBlock
struct	DistanceInfo
class	DistanceMap
struct	Ellipsoid
	Ellipsoid in Dim-dimensional space. More...
struct	ExponentialSensorError
class	FileHandler
	RAII wrapper around a C std::FILE* handle. More...
struct	first_color
	Yields the first color type found in Ts…. More...
struct	first_color< T, Ts... >
struct	FixedSensorError
struct	Frustum
	Frustum in Dim-dimensional space. More...
struct	Gray
	Grayscale color. More...
struct	Gray< T, ColorFlags::Alpha >
	Grayscale color with alpha, without weight. More...
struct	Gray< T, ColorFlags::Alpha|ColorFlags::Weight >
	Grayscale color with both alpha and weight. More...
struct	Gray< T, ColorFlags::None >
	Grayscale color with neither alpha nor weight. More...
struct	Gray< T, ColorFlags::Weight >
	Grayscale color with weight, without alpha. More...
struct	has_alpha
	True if T includes an alpha channel. More...
struct	has_weight
	True if T includes a weight field. More...
class	Image
	Image class for storing and manipulating 2D pixel data. More...
struct	ImageProperties
	Metadata describing the pixel layout of an image file. More...
struct	IMU
	Represents an Inertial Measurement Unit (IMU) sensor reading. More...
struct	index
struct	index< T, F, R... >
struct	index< T, T, R... >
struct	index_type
struct	init_alpha
	Default-initialised alpha value for T. More...
class	Integrator
struct	Intensity
	Represents LiDAR/sensor return intensity as a single float value. More...
class	IntensityMap
struct	is_color
	Detects whether T is a color type. More...
struct	is_color< Gray< T, F > >
struct	is_color< Lab< T, F > >
struct	is_color< Lch< T, F > >
struct	is_color< Lrgb< T, F > >
struct	is_color< Rgb< T, F > >
struct	is_labels_map
struct	is_pair
struct	is_semantic_set_map
struct	is_specialization_of
struct	is_specialization_of< T, T< Us... > >
struct	is_string
struct	is_tuple
struct	is_unique
struct	is_unique< T, Rest... >
struct	Lab
	Oklab perceptual color. More...
struct	Lab< T, ColorFlags::Alpha >
	Oklab perceptual color with alpha, without weight. More...
struct	Lab< T, ColorFlags::Alpha|ColorFlags::Weight >
	Oklab perceptual color with both alpha and weight. More...
struct	Lab< T, ColorFlags::None >
	Oklab perceptual color with neither alpha nor weight. More...
struct	Lab< T, ColorFlags::Weight >
	Oklab perceptual color with weight, without alpha. More...
struct	Label
	Represents a semantic class label as a single unsigned integer value. More...
class	LabelMap
struct	LabelsBlock
struct	LabelsElement
class	LabelSet
class	LabelsMap
struct	Lch
	OkLch color. More...
struct	Lch< T, ColorFlags::Alpha >
	OkLch color with alpha, without weight. More...
struct	Lch< T, ColorFlags::Alpha|ColorFlags::Weight >
	OkLch color with both alpha and weight. More...
struct	Lch< T, ColorFlags::None >
	OkLch color with neither alpha nor weight. More...
struct	Lch< T, ColorFlags::Weight >
	OkLch color with weight, without alpha. More...
struct	Line
struct	LinearSensorError
struct	LineSegment
	Line segment in Dim-dimensional space. More...
struct	Lrgb
	Linear-light RGB color. More...
struct	Lrgb< T, ColorFlags::Alpha >
	Linear-light RGB color with alpha, without weight. More...
struct	Lrgb< T, ColorFlags::Alpha|ColorFlags::Weight >
	Linear-light RGB color with both alpha and weight. More...
struct	Lrgb< T, ColorFlags::None >
	Linear-light RGB color with neither alpha nor weight. More...
struct	Lrgb< T, ColorFlags::Weight >
	Linear-light RGB color with weight, without alpha. More...
class	Map
struct	map_block< CostMap, Dim, BF >
struct	map_block< LabelsMap, Dim, BF >
struct	MapHeader
struct	MapTypeInfo
struct	Mat
	A fixed-size matrix with Rows rows and Cols columns. More...
struct	Miss
struct	Morton
class	NavMap
struct	Normal
	Represents an N-dimensional unit surface normal vector as a fixed-size array. More...
struct	OBB
	Oriented Bounding Box in 2D space. More...
struct	OBB< 2, T >
struct	OBB< 3, T >
struct	OBB< 4, T >
struct	Occupancy
struct	Occupancy< float >
struct	Occupancy< OccupancyState >
struct	Occupancy< std::uint8_t >
struct	OccupancyBlock
struct	OccupancyColorVoidRegionBlock
struct	OccupancyColorVoidRegionMapT
struct	OccupancyMapT
struct	OrthogonalCamera
	Orthogonal camera model for ray-generation and projection. More...
struct	OrthogonalIntrinsics
	Stores the intrinsic parameters of an orthogonal camera. More...
struct	PerspectiveCamera
	Perspective camera model for ray-generation and projection. More...
struct	PerspectiveIntrinsics
	Stores the intrinsic parameters of a perspective camera. More...
struct	Plane
	Plane in space. More...
struct	PlanEdge
struct	PlanNode
struct	PolynomialSensorError
struct	proxy_arrow_result
struct	Quat
	Unit quaternion representing an orientation or rotation in 3-D space. More...
struct	Range
	Represents a closed interval [lower, upper] of a scalar type. More...
class	RangeMap
class	RangeSet
struct	Ray
	Ray in Dim-dimensional space. More...
class	ReadBuffer
struct	Reflection
class	ReflectionMap
struct	remove_cvref
class	Renderable
class	RenderableMap
class	RenderablePath
class	RenderableTrianglelist
struct	Rgb
	Gamma-encoded sRGB color. More...
struct	Rgb< T, ColorFlags::Alpha >
	Gamma-encoded sRGB color with alpha, without weight. More...
struct	Rgb< T, ColorFlags::Alpha|ColorFlags::Weight >
	Gamma-encoded sRGB color with both alpha and weight. More...
struct	Rgb< T, ColorFlags::None >
	Gamma-encoded sRGB color with neither alpha nor weight. More...
struct	Rgb< T, ColorFlags::Weight >
	Gamma-encoded sRGB color with weight, without alpha. More...
struct	Semantic
	Represents a semantic annotation as a pair of class label and confidence score. More...
class	SemanticPropagation
class	SemanticSet
class	SemanticSet< 1 >
struct	SemanticSetBlock
class	SemanticSetMap
struct	SerializedBlock
class	SmallVector
class	SoA
struct	Sphere
	Sphere in Dim-dimensional space. More...
class	Spinlock
	A simple spinlock implementation using std::atomic_flag. More...
class	Surfel
	Represents an incremental surface element (surfel) that tracks the sufficient statistics of a 3D point set for online surface estimation. More...
class	SurfelMap
class	TimeMap
class	Timer
class	Timing
struct	TraceResult
struct	Transform
	Rigid-body transform: a rotation matrix plus a translation vector. More...
class	Tree
	Utilizing curiously recurring template pattern (CRTP) More...
struct	TreeBlock
class	TreeCode
class	TreeContainer
class	TreeContainterBucketIterator
class	TreeContainterIterator
struct	TreeCoord
class	TreeData
struct	TreeIndex
struct	TreeInnerBlock
class	TreeIterator
class	TreeKey
struct	TreeLeafBlock
class	TreeMap
struct	TreeMapBlock
struct	TreeMapInnerBlock
class	TreeMapIterator
struct	TreeMapLeafBlock
class	TreeMapNearestIterator
class	TreeMapQueryIterator
class	TreeMapQueryNearestIterator
class	TreeNearestIterator
struct	TreeNode
class	TreeQueryIterator
class	TreeQueryNearestIterator
class	TreeSet
struct	TreeSetBlock
class	TreeSetIterator
class	TreeSetNearestIterator
class	TreeSetQueryIterator
class	TreeSetQueryNearestIterator
struct	Triangle
	Triangle in Dim-dimensional space. More...
struct	Vec
	A fixed-size arithmetic vector of up to 4 dimensions. More...
class	Viz
struct	VoidRegionBlock
struct	VoidRegionMap
struct	Weight
	Represents a generic scalar weight as a single float value. More...
class	WriteBuffer

Concepts
concept	ExecutionPolicy
concept	Matrix
	Concept satisfied by any specialization of Mat<Rows, Cols, U>.
concept	SquareMatrix
	Concept satisfied by square matrix types (Rows == Cols).
concept	InvertibleMatrix
	Concept satisfied by invertible matrices (square with floating-point elements).
concept	Color
	Identifies any UFO color instantiation (Gray, Lab, Lch, Lrgb, Rgb).
concept	FloatingPointColor
	Colors with a floating-point channel type.
concept	IntegralColor
	Colors with an integral channel type.
concept	ColorWithAlpha
	Colors that include an alpha channel.
concept	ColorWithWeight
	Colors that include a weight channel.
concept	ColorWithAlphaAndWeight
	Colors with both alpha and weight channels.
concept	BasicColor
	Colors without optional channels (no alpha, no weight).
concept	GrayColor
	Grayscale colors (Gray<T, Flags>).
concept	RgbColor
	Gamma-encoded sRgb colors (Rgb<T, Flags>).
concept	LinearRgbColor
	Linear-light Rgb colors (Lrgb<T, Flags>).
concept	LabColor
	Oklab perceptual colors (Lab<T, Flags>).
concept	LchColor
	OkLch cylindrical colors (Lch<T, Flags>).
concept	RgbFamilyColor
	Rgb-family colors (gamma-encoded or linear: Rgb or Lrgb).
concept	PerceptualColor
	Perceptual color models (Lab or Lch).
concept	DisplayColor
	Color models suitable for display (Rgb, Lrgb, or Gray).
concept	HueBasedColor
	Color models with a hue component (Lch).
concept	LightnessBasedColor
	Color models with a lightness component (Lab or Lch).
concept	AccumulableColor
	Colors that support weighted accumulation (floating-point with weight).
concept	ImageColor
	Colors suitable for image processing (integral, or floating-point display colors).
concept	HDRColor
	Colors suitable for high dynamic range operations (floating-point display colors).
concept	TransparentColor
	Colors with transparency support.
concept	CompactColor
	Colors optimized for compact storage (integral, at most 16 bits per channel).
concept	SameValueType
	Two colors with the same underlying channel type.
concept	SameColorModel
	Two colors with the same color model.
concept	SameColorFlags
	Two colors with the same flags.
concept	EquivalentColors
	Two colors that are equivalent (same model, channel type, and flags).
concept	ConvertibleColor
	Colors with compatible channel types for conversion.
concept	BlendableColors
	Colors that can be blended together (same model and mutually convertible types).
concept	ColorWithValueType
	Colors with a specific channel type.
concept	Color8Bit
	Colors with an 8-bit channel type.
concept	Color16Bit
	Colors with a 16-bit channel type.
concept	ColorFloat
	Colors with a 32-bit float channel type.
concept	ColorDouble
	Colors with a 64-bit double channel type.
concept	GammaCorrectable
	Colors that support gamma correction (Rgb family).
concept	ColorSpaceConvertible
	Colors that support color space conversion between display color models.
concept	PerceptuallyUniform
	Colors that operate in a perceptually uniform space.
concept	IsColor
	Convenience alias: any UFO color instantiation.

Typedefs
template<std::floating_point T>
using	AABB1 = AABB< 1, T >
using	AABB1d = AABB< 1, double >
using	AABB1f = AABB< 1, float >
template<std::floating_point T>
using	AABB2 = AABB< 2, T >
using	AABB2d = AABB< 2, double >
using	AABB2f = AABB< 2, float >
template<std::floating_point T>
using	AABB3 = AABB< 3, T >
using	AABB3d = AABB< 3, double >
using	AABB3f = AABB< 3, float >
template<std::floating_point T>
using	AABB4 = AABB< 4, T >
using	AABB4d = AABB< 4, double >
using	AABB4f = AABB< 4, float >
template<std::size_t ArgNum, typename... T>
using	argument = decltype(argument_helper< ArgNum >(std::declval< F >()))
template<std::size_t ArgNum, typename... Args>
using	argument_helper_2_t = typename argument_helper_2< ArgNum, Args... >::type
template<class T >
using	as_tuple_t = typename as_tuple< T >::type
using	BinaryCode = TreeCode< 1 >
using	BinaryCoord = TreeCoord< 1, float >
using	BinaryKey = TreeKey< 1 >
using	BinaryNode = TreeNode< 1 >
template<class T >
using	BinaryTreeMap = TreeMap< 1, T >
using	BinaryTreeSet = TreeSet< 1 >
template<std::floating_point T>
using	Capsule1 = Capsule< 1, T >
using	Capsule1d = Capsule< 1, double >
using	Capsule1f = Capsule< 1, float >
template<std::floating_point T>
using	Capsule2 = Capsule< 2, T >
using	Capsule2d = Capsule< 2, double >
using	Capsule2f = Capsule< 2, float >
template<std::floating_point T>
using	Capsule3 = Capsule< 3, T >
using	Capsule3d = Capsule< 3, double >
using	Capsule3f = Capsule< 3, float >
template<std::floating_point T>
using	Capsule4 = Capsule< 4, T >
using	Capsule4d = Capsule< 4, double >
using	Capsule4f = Capsule< 4, float >
template<class... Ts>
using	Cloud = SoA< Ts... >
using	ColorMap = ColorMapT< FineLabW >
template<class T = float>
using	Coord1 = TreeCoord< 1, T >
using	Coord1d = TreeCoord< 1, double >
using	Coord1f = TreeCoord< 1, float >
template<class T = float>
using	Coord2 = TreeCoord< 2, T >
using	Coord2d = TreeCoord< 2, double >
using	Coord2f = TreeCoord< 2, float >
template<class T = float>
using	Coord3 = TreeCoord< 3, T >
using	Coord3d = TreeCoord< 3, double >
using	Coord3f = TreeCoord< 3, float >
template<class T = float>
using	Coord4 = TreeCoord< 4, T >
using	Coord4d = TreeCoord< 4, double >
using	Coord4f = TreeCoord< 4, float >
template<std::floating_point T>
using	Cylinder1 = Cylinder< 1, T >
using	Cylinder1d = Cylinder< 1, double >
using	Cylinder1f = Cylinder< 1, float >
template<std::floating_point T>
using	Cylinder2 = Cylinder< 2, T >
using	Cylinder2d = Cylinder< 2, double >
using	Cylinder2f = Cylinder< 2, float >
template<std::floating_point T>
using	Cylinder3 = Cylinder< 3, T >
using	Cylinder3d = Cylinder< 3, double >
using	Cylinder3f = Cylinder< 3, float >
template<std::floating_point T>
using	Cylinder4 = Cylinder< 4, T >
using	Cylinder4d = Cylinder< 4, double >
using	Cylinder4f = Cylinder< 4, float >
template<class Derived , class Tree >
using	DistanceMapFast = DistanceMap< Derived, Tree, true >
template<class Derived , class Tree >
using	DistanceMapSmall = DistanceMap< Derived, Tree, false >
template<std::floating_point T>
using	Ellipsoid1 = Ellipsoid< 1, T >
using	Ellipsoid1d = Ellipsoid< 1, double >
using	Ellipsoid1f = Ellipsoid< 1, float >
template<std::floating_point T>
using	Ellipsoid2 = Ellipsoid< 2, T >
using	Ellipsoid2d = Ellipsoid< 2, double >
using	Ellipsoid2f = Ellipsoid< 2, float >
template<std::floating_point T>
using	Ellipsoid3 = Ellipsoid< 3, T >
using	Ellipsoid3d = Ellipsoid< 3, double >
using	Ellipsoid3f = Ellipsoid< 3, float >
template<std::floating_point T>
using	Ellipsoid4 = Ellipsoid< 4, T >
using	Ellipsoid4d = Ellipsoid< 4, double >
using	Ellipsoid4f = Ellipsoid< 4, float >
template<std::floating_point T>
using	Frustum1 = Frustum< 1, T >
using	Frustum1d = Frustum< 1, double >
using	Frustum1f = Frustum< 1, float >
template<std::floating_point T>
using	Frustum2 = Frustum< 2, T >
using	Frustum2d = Frustum< 2, double >
using	Frustum2f = Frustum< 2, float >
template<std::floating_point T>
using	Frustum3 = Frustum< 3, T >
using	Frustum3d = Frustum< 3, double >
using	Frustum3f = Frustum< 3, float >
template<std::floating_point T>
using	Frustum4 = Frustum< 4, T >
using	Frustum4d = Frustum< 4, double >
using	Frustum4f = Frustum< 4, float >
template<std::size_t Dim, std::floating_point T>
using	FrustumX = Frustum< Dim, T >
using	HexCode = TreeCode< 4 >
using	HexCoord = TreeCoord< 4, float >
using	HexKey = TreeKey< 4 >
using	HexNode = TreeNode< 4 >
template<class T >
using	HextreeMap = TreeMap< 4, T >
using	HextreeSet = TreeSet< 4 >
template<std::size_t I, class... Ts>
using	index_type_t = typename index_type< I, Ts... >::type
template<std::floating_point T>
using	Line1 = Line< 1, T >
using	Line1d = Line< 1, double >
using	Line1f = Line< 1, float >
template<std::floating_point T>
using	Line2 = Line< 2, T >
using	Line2d = Line< 2, double >
using	Line2f = Line< 2, float >
template<std::floating_point T>
using	Line3 = Line< 3, T >
using	Line3d = Line< 3, double >
using	Line3f = Line< 3, float >
template<std::floating_point T>
using	Line4 = Line< 4, T >
using	Line4d = Line< 4, double >
using	Line4f = Line< 4, float >
template<std::floating_point T>
using	LineSegment1 = LineSegment< 1, T >
using	LineSegment1d = LineSegment< 1, double >
using	LineSegment1f = LineSegment< 1, float >
template<std::floating_point T>
using	LineSegment2 = LineSegment< 2, T >
using	LineSegment2d = LineSegment< 2, double >
using	LineSegment2f = LineSegment< 2, float >
template<std::floating_point T>
using	LineSegment3 = LineSegment< 3, T >
using	LineSegment3d = LineSegment< 3, double >
using	LineSegment3f = LineSegment< 3, float >
template<std::floating_point T>
using	LineSegment4 = LineSegment< 4, T >
using	LineSegment4d = LineSegment< 4, double >
using	LineSegment4f = LineSegment< 4, float >
template<class... Maps>
using	Map1D = Map< 1, Maps... >
template<class... Maps>
using	Map2D = Map< 2, Maps... >
template<class... Maps>
using	Map3D = Map< 3, Maps... >
template<class... Maps>
using	Map4D = Map< 4, Maps... >
template<class T = float>
using	Mat2 = Mat< 2, 2, T >
using	Mat2d = Mat2< double >
using	Mat2f = Mat2< float >
using	Mat2x2d = Mat2d
using	Mat2x2f = Mat2f
template<class T = float>
using	Mat3 = Mat< 3, 3, T >
using	Mat3d = Mat3< double >
using	Mat3f = Mat3< float >
using	Mat3x3d = Mat3d
using	Mat3x3f = Mat3f
template<class T = float>
using	Mat4 = Mat< 4, 4, T >
using	Mat4d = Mat4< double >
using	Mat4f = Mat4< float >
using	Mat4x4d = Mat4d
using	Mat4x4f = Mat4f
using	Misses = std::vector< Miss >
template<class T >
using	OBB1 = OBB< 1, T >
using	OBB1d = OBB< 1, double >
using	OBB1f = OBB< 1, float >
template<class T >
using	OBB2 = OBB< 2, T >
using	OBB2d = OBB< 2, double >
using	OBB2f = OBB< 2, float >
template<class T >
using	OBB3 = OBB< 3, T >
using	OBB3d = OBB< 3, double >
using	OBB3f = OBB< 3, float >
template<class T >
using	OBB4 = OBB< 4, T >
using	OBB4d = OBB< 4, double >
using	OBB4f = OBB< 4, float >
using	OccupancyColorVoidRegionMap = OccupancyColorVoidRegionMapT< false >
using	OccupancyColorVoidRegionMapSmall = OccupancyColorVoidRegionMapT< true >
using	OccupancyMap = OccupancyMapT< float >
using	OccupancyMapSmall = OccupancyMapT< std::int8_t >
using	OccupancyMapTiny = OccupancyMapT< OccupancyState >
using	OctCode = TreeCode< 3 >
using	OctCoord = TreeCoord< 3, float >
using	OctKey = TreeKey< 3 >
using	OctNode = TreeNode< 3 >
template<class T >
using	OctreeMap = TreeMap< 3, T >
using	OctreeSet = TreeSet< 3 >
using	Plane3d = Plane< 3, double >
using	Plane3f = Plane< 3, float >
template<std::size_t Dim, class T , class... Rest>
using	PointCloud = Cloud< Vec< Dim, T >, Rest... >
	A structure-of-arrays point cloud whose first channel is Dim-dimensional positions of scalar type T.
using	PointCloud2d = PointCloud< 2, double >
	2D double-precision point cloud (positions only).
using	PointCloud2f = PointCloud< 2, float >
	2D single-precision point cloud (positions only).
using	PointCloud3d = PointCloud< 3, double >
	3D double-precision point cloud (positions only).
using	PointCloud3f = PointCloud< 3, float >
	3D single-precision point cloud (positions only).
using	PointCloud4d = PointCloud< 4, double >
	4D double-precision point cloud (positions only).
using	PointCloud4f = PointCloud< 4, float >
	4D single-precision point cloud (positions only).
using	QuadCode = TreeCode< 2 >
using	QuadCoord = TreeCoord< 2, float >
using	QuadKey = TreeKey< 2 >
using	QuadNode = TreeNode< 2 >
template<class T >
using	QuadtreeMap = TreeMap< 2, T >
using	QuadtreeSet = TreeSet< 2 >
using	Quatd = Quat< double >
using	Quatf = Quat< float >
template<std::floating_point T>
using	Ray1 = Ray< 1, T >
using	Ray1d = Ray< 1, double >
using	Ray1f = Ray< 1, float >
template<std::floating_point T>
using	Ray2 = Ray< 2, T >
using	Ray2d = Ray< 2, double >
using	Ray2f = Ray< 2, float >
template<std::floating_point T>
using	Ray3 = Ray< 3, T >
using	Ray3d = Ray< 3, double >
using	Ray3f = Ray< 3, float >
template<std::floating_point T>
using	Ray4 = Ray< 4, T >
using	Ray4d = Ray< 4, double >
using	Ray4f = Ray< 4, float >
template<class T >
using	remove_cvref_t = typename remove_cvref< T >::type
template<std::size_t BF>
using	SerializedBlocks = std::vector< SerializedBlock< BF > >
template<std::floating_point T>
using	Sphere1 = Sphere< 1, T >
using	Sphere1d = Sphere< 1, double >
using	Sphere1f = Sphere< 1, float >
template<std::floating_point T>
using	Sphere2 = Sphere< 2, T >
using	Sphere2d = Sphere< 2, double >
using	Sphere2f = Sphere< 2, float >
template<std::floating_point T>
using	Sphere3 = Sphere< 3, T >
using	Sphere3d = Sphere< 3, double >
using	Sphere3f = Sphere< 3, float >
template<std::floating_point T>
using	Sphere4 = Sphere< 4, T >
using	Sphere4d = Sphere< 4, double >
using	Sphere4f = Sphere< 4, float >
using	TraceResult2 = TraceResult< 2 >
using	TraceResult3 = TraceResult< 3 >
using	TraceResult4 = TraceResult< 4 >
template<std::floating_point T = float>
using	Transform2 = Transform< 2, T >
using	Transform2d = Transform2< double >
using	Transform2f = Transform2< float >
template<std::floating_point T = float>
using	Transform3 = Transform< 3, T >
using	Transform3d = Transform3< double >
using	Transform3f = Transform3< float >
template<std::floating_point T>
using	Triangle1 = Triangle< 1, T >
using	Triangle1d = Triangle< 1, double >
using	Triangle1f = Triangle< 1, float >
template<std::floating_point T>
using	Triangle2 = Triangle< 2, T >
using	Triangle2d = Triangle< 2, double >
using	Triangle2f = Triangle< 2, float >
template<std::floating_point T>
using	Triangle3 = Triangle< 3, T >
using	Triangle3d = Triangle< 3, double >
using	Triangle3f = Triangle< 3, float >
template<std::floating_point T>
using	Triangle4 = Triangle< 4, T >
using	Triangle4d = Triangle< 4, double >
using	Triangle4f = Triangle< 4, float >
using	Vec1b = Vec< 1, bool >
using	Vec1d = Vec< 1, double >
using	Vec1f = Vec< 1, float >
using	Vec1i = Vec< 1, int >
using	Vec1u = Vec< 1, unsigned >
using	Vec2b = Vec< 2, bool >
using	Vec2d = Vec< 2, double >
using	Vec2f = Vec< 2, float >
using	Vec2i = Vec< 2, int >
using	Vec2u = Vec< 2, unsigned >
using	Vec3b = Vec< 3, bool >
using	Vec3d = Vec< 3, double >
using	Vec3f = Vec< 3, float >
using	Vec3i = Vec< 3, int >
using	Vec3u = Vec< 3, unsigned >
using	Vec4b = Vec< 4, bool >
using	Vec4d = Vec< 4, double >
using	Vec4f = Vec< 4, float >
using	Vec4i = Vec< 4, int >
using	Vec4u = Vec< 4, unsigned >
using	Normal2f = Normal< 2 >
	2D single-precision surface normal.
using	Normal3f = Normal< 3 >
	3D single-precision surface normal.
using	Normal4f = Normal< 4 >
	4D single-precision surface normal.
using	Normal2d = Normal< 2, double >
	2D double-precision surface normal.
using	Normal3d = Normal< 3, double >
	3D double-precision surface normal.
using	Normal4d = Normal< 4, double >
	4D double-precision surface normal.

Enumerations
enum class	CostPropagationCriteria { MIN , MAX , MEAN , NONE }
enum class	CountSamplingMethod {   NONE , BOOLEAN , MIN , MAX ,   MEAN }
enum class	DistanceInterpolate { NONE , ALL , LAST }
enum class	DownSamplingMethod { NONE , FIRST , CENTER }
enum class	FileType {   UNKNOWN , UFO , XYZ , XYZI ,   XYZN , XYZRGB , PTS , PLY ,   PCD , OBJ , JPEG , PNG ,   QTP }
	Enumerates all file formats supported by the UFO I/O subsystem. More...
enum class	IODir { Beg , End , Cur }
enum class	LabelsPropagationCriteria {   ALL , SUMMARY , MIN , MAX ,   NONE }
enum class	MapType : std::uint64_t {   NONE = std::uint64_t(0) , TREE = NONE , ALL = ~std::uint64_t(0) , OCCUPANCY = std::uint64_t(1) << 0 ,   COLOR = std::uint64_t(1) << 1 , TIME = std::uint64_t(1) << 2 , COUNT = std::uint64_t(1) << 3 , REFLECTION = std::uint64_t(1) << 4 ,   INTENSITY = std::uint64_t(1) << 5 , SURFEL = std::uint64_t(1) << 6 , VOID_REGION = std::uint64_t(1) << 7 , DISTANCE = std::uint64_t(1) << 8 ,   LABEL = std::uint64_t(1) << 9 , SEMANTIC = std::uint64_t(1) << 10 , LABEL_SET = std::uint64_t(1) << 11 , SEMANTIC_SET = std::uint64_t(1) << 12 ,   COST = std::uint64_t(1) << 13 }
enum class	MapUtility : std::uint64_t { NONE = std::uint64_t(0) , WITH_CENTER = std::uint64_t(1) << 0 }
enum class	NearestSearchAlgorithm { DEPTH_FIRST , A_STAR }
enum class	OccupancyPropagationCriteria {   MIN , MAX , MEAN , ONLY_INDICATORS ,   NONE }
enum class	OccupancyState : std::int8_t { UNKNOWN = 0 , FREE = -1 , OCCUPIED = 1 }
enum class	ScalarType : std::uint8_t {   INT8 = 0 , UINT8 = 1 , INT16 = 2 , UINT16 = 3 ,   INT32 = 4 , UINT32 = 5 , INT64 = 6 , UINT64 = 7 ,   FLOAT32 = 8 , FLOAT64 = 9 , UNKNOWN = 10 }
	Tag identifying the primitive scalar type of a data channel. More...

Functions
template<std::size_t Dim, std::floating_point T>
	AABB (Vec< Dim, T >, T) -> AABB< Dim, T >
template<std::size_t Dim, std::floating_point T>
	AABB (Vec< Dim, T >, Vec< Dim, T >) -> AABB< Dim, T >
template<std::size_t Dim, class T >
constexpr Vec< Dim, T >	abs (Vec< Dim, T > v) noexcept
	Returns the component-wise absolute value of a vector.
template<std::size_t Dim>
constexpr bool	all (Vec< Dim, bool > const &v) noexcept
	Returns true if all components of a bool vector are true.
template<ufo::execution::ExecutionPolicy P, std::input_iterator InputIt, class UnaryPred >
bool	all_of (P &&policy, InputIt first, InputIt last, UnaryPred p)
	Checks if all elements in [first, last) satisfy p using the given execution policy.
template<ufo::execution::ExecutionPolicy P, std::ranges::input_range Range, class UnaryPred >
bool	all_of (P &&policy, Range &&r, UnaryPred p)
	Checks if all elements in range r satisfy p using the given execution policy.
template<std::floating_point T>
T	angle (Quat< T > const &q) noexcept
	Extracts the rotation angle (in radians) from a unit quaternion.
template<std::floating_point T>
constexpr Quat< T >	angleAxis (T angle, Vec< 3, T > const &a) noexcept
	Constructs a unit quaternion from an angle-axis representation.
template<std::size_t Dim>
constexpr bool	any (Vec< Dim, bool > const &v) noexcept
	Returns true if at least one component of a bool vector is true.
template<ufo::execution::ExecutionPolicy P, std::input_iterator InputIt, class UnaryPred >
bool	any_of (P &&policy, InputIt first, InputIt last, UnaryPred p)
	Checks if any element in [first, last) satisfies p using the given execution policy.
template<ufo::execution::ExecutionPolicy P, std::ranges::input_range Range, class UnaryPred >
bool	any_of (P &&policy, Range &&r, UnaryPred p)
	Checks if any element in range r satisfies p using the given execution policy.
template<std::floating_point T>
Vec< 3, T >	axis (Quat< T > const &q) noexcept
	Extracts the unit rotation axis from a unit quaternion.
template<class... Ts>
constexpr auto	begin (SoA< Ts... > &c)
template<class... Ts>
constexpr auto	begin (SoA< Ts... > const &c)
template<std::size_t Dim, std::floating_point T>
	Capsule (Vec< Dim, T >, Vec< Dim, T >, T) -> Capsule< Dim, T >
template<class T , std::size_t Dim, class U >
constexpr Vec< Dim, T >	cast (Vec< Dim, U > const &v) noexcept
	Casts each element of a vector to a new type.
template<std::size_t Dim, std::floating_point T>
constexpr Vec< Dim, T >	ceil (Vec< Dim, T > v) noexcept
	Returns the component-wise ceiling of a floating-point vector.
template<std::size_t Dim, class T >
constexpr Vec< Dim, T >	clamp (Vec< Dim, T > v, Vec< Dim, T > const &lo, Vec< Dim, T > const &hi) noexcept
	Clamps each component of a vector to the range [lo[i], hi[i]].
CloudProperties	cloudProperties (std::filesystem::path const &file)
CloudProperties	cloudPropertiesOBJ (std::filesystem::path const &file)
CloudProperties	cloudPropertiesPCD (std::filesystem::path const &file)
CloudProperties	cloudPropertiesPLY (std::filesystem::path const &file)
CloudProperties	cloudPropertiesPTS (std::filesystem::path const &file)
CloudProperties	cloudPropertiesUFO (std::filesystem::path const &file)
CloudProperties	cloudPropertiesXYZ (std::filesystem::path const &file)
CloudProperties	cloudPropertiesXYZI (std::filesystem::path const &file)
CloudProperties	cloudPropertiesXYZN (std::filesystem::path const &file)
CloudProperties	cloudPropertiesXYZRGB (std::filesystem::path const &file)
std::vector< OctCode >	computeRay (OctKey origin, OctKey goal, float max_distance=std::numeric_limits< float >::max(), std::size_t early_stop=0, float early_stop_distance=0.0f)
void	computeRay (std::unordered_map< OctCode, IntegrationGrid< OctCode > > &misses, std::unordered_map< OctCode, IntegrationGrid< OctCode > > const &hits, Vec3f origin, Vec3f goal, OctCode c_origin, Vec3f voxel_border, float grid_size, float max_distance, unsigned inflate_unknown, bool ray_passthrough_hits)
void	computeRay (std::unordered_map< OctCode, IntegrationGrid< OctCode > > &misses, Vec3f origin, Vec3f goal, OctCode c_origin, Vec3f voxel_border, float grid_size, float max_distance, unsigned inflate_unknown)
template<class Map >
void	computeRaySimple (Map const &map, std::unordered_map< OctCode, Grid > &grids, Vec3f origin, Vec3f goal, depth_t depth, float step_size, float max_distance=std::numeric_limits< float >::max(), float early_stop_distance=0.0f)
std::vector< OctCode >	computeRaySimple (OctKey origin, OctKey goal, float step_size_factor=1.0f, float max_distance=std::numeric_limits< float >::max(), std::size_t early_stop=0, float early_stop_distance=0.0f)
std::vector< QuadCode >	computeRaySimple (QuadKey origin, QuadKey goal, float step_size_factor=1.0f, float max_distance=std::numeric_limits< float >::max(), std::size_t early_step=0, float early_stop_distance=0.0f)
std::vector< Vec2f >	computeRaySimple (Vec2f origin, Vec2f goal, float step_size, float max_distance=std::numeric_limits< float >::max(), std::size_t early_stop=0, float early_stop_distance=0.0f)
std::vector< Vec3f >	computeRaySimple (Vec3f origin, Vec3f goal, float step_size, float max_distance=std::numeric_limits< float >::max(), std::size_t early_stop=0, float early_stop_distance=0.0f)
template<std::floating_point T>
constexpr Quat< T >	conjugate (Quat< T > const &q) noexcept
	Returns the quaternion conjugate (w, -x, -y, -z).
template<class A , class B >
constexpr bool	contains (A const &a, B const &b)
	Checks if a shape contains another shape.
bool	contains (std::string const &s, std::string const &sub)
	Checks if a string contains a substring.
template<class To , std::size_t Dim, class U >
constexpr To	convert (Vec< Dim, U > const &v) noexcept
	Converts a vector to a different Vec type, truncating or zero-padding dimensions.
template<class Geometry >
constexpr auto	corners (Geometry const &g)
	Returns the corners of the minimum spanning axis-aligned bounding box of a geometry.
template<ufo::execution::ExecutionPolicy P, std::input_iterator InputIt, class UnaryPred >
std::size_t	count_if (P &&policy, InputIt first, InputIt last, UnaryPred p)
	Counts elements in [first, last) satisfying p using the given execution policy.
template<ufo::execution::ExecutionPolicy P, std::ranges::input_range Range, class UnaryPred >
std::size_t	count_if (P &&policy, Range &&r, UnaryPred p)
	Counts elements in range r satisfying p using the given execution policy.
template<std::size_t N, class T >
constexpr std::array< T, N >	createArray (T const &value)
	Creates a std::array of size N, filled with the given value.
template<std::floating_point T>
constexpr Quat< T >	cross (Quat< T > const &q1, Quat< T > const &q2) noexcept
	Computes the Hamilton cross product of two quaternions.
template<class T >
constexpr Vec< 3, T >	cross (Vec< 3, T > const &a, Vec< 3, T > const &b) noexcept
	Computes the cross product of two 3D vectors.
template<std::size_t Dim, std::floating_point T>
	Cylinder (Vec< Dim, T >, Vec< Dim, T >, T) -> Cylinder< Dim, T >
template<SquareMatrix M>
constexpr auto	determinant (M const &m) noexcept
	Computes the determinant of a square matrix.
template<class A , class B >
constexpr bool	disjoint (A const &a, B const &b)
	Checks if two shapes are disjoint.
template<class A , class B >
constexpr auto	distance (A const &a, B const &b)
	Computes the minimum distance between two shapes.
template<std::size_t Dim, class T > requires std::floating_point<T>
constexpr T	distance (Vec< Dim, T > const &a, Vec< Dim, T > const &b) noexcept
	Computes the Euclidean distance between two points.
template<class A , class B >
constexpr auto	distanceSquared (A const &a, B const &b)
	Computes the minimum squared distance between two shapes.
template<std::size_t Dim, class T >
constexpr T	distanceSquared (Vec< Dim, T > const &a, Vec< Dim, T > const &b) noexcept
	Computes the squared Euclidean distance between two points.
template<std::floating_point T>
constexpr T	dot (Quat< T > const &a, Quat< T > const &b) noexcept
	Computes the four-component dot product a.w*b.w + a.x*b.x + a.y*b.y + a.z*b.z.
template<std::size_t Dim, class T >
constexpr T	dot (Vec< Dim, T > const &a, Vec< Dim, T > const &b) noexcept
	Computes the dot (inner) product of two vectors.
template<std::floating_point T>
constexpr Vec< 3, T >	eigenValues (Mat< 3, 3, T > const &m) noexcept
	Computes the eigenvalues of a real symmetric 3×3 matrix, sorted ascending.
template<std::floating_point T>
constexpr std::array< Vec< 3, T >, 3 >	eigenVectors (Mat< 3, 3, T > const &m) noexcept
	Computes the eigenvectors of a real symmetric 3×3 matrix.
template<std::floating_point T>
constexpr std::array< Vec< 3, T >, 3 >	eigenVectors (Mat< 3, 3, T > const &m, Vec< 3, T > const &eigen_values) noexcept
	Computes the eigenvectors of a real symmetric 3×3 matrix.
template<std::size_t Dim, std::floating_point T>
	Ellipsoid (Vec< Dim, T >, Vec< Dim, T >) -> Ellipsoid< Dim, T >
template<class... Ts>
constexpr auto	end (SoA< Ts... > &c)
template<class... Ts>
constexpr auto	end (SoA< Ts... > const &c)
bool	endsWith (std::string const &s, std::string const &suffix)
	Checks if a string ends with a given suffix.
template<std::size_t Dim, class T >
constexpr Vec< Dim, bool >	equal (Vec< Dim, T > const &v1, Vec< Dim, T > const &v2) noexcept
	Returns a bool vector indicating component-wise equality.
template<class... Ts, class U >
constexpr SoA< Ts... >::size_type	erase (SoA< Ts... > &c, U const &value)
template<typename Key , typename T , class Pred >
RangeMap< Key, T >::size_type	erase_if (RangeMap< Key, T > &range_map, Pred pred)
template<typename Key , class Pred >
RangeSet< Key >::size_type	erase_if (RangeSet< Key > &range_set, Pred pred)
template<class... Ts, class Pred >
constexpr SoA< Ts... >::size_type	erase_if (SoA< Ts... > &c, Pred pred)
template<std::floating_point T>
Vec< 3, T >	eulerAngles (Quat< T > const &q) noexcept
	Returns the Euler angles (pitch, yaw, roll) in radians.
FileType	fileType (std::filesystem::path const &file)
	Infers the FileType from the extension of file (case-insensitive).
template<std::size_t Dim, class T , class... Rest>
PointCloud< Dim, T, Rest... >	filterDistance (PointCloud< Dim, T, Rest... > pc, Vec< Dim, T > const &origin, T const &min_distance, T const &max_distance, bool filter_nan=true)
	Returns a copy of pc with all points outside the given distance range removed.
template<std::size_t Dim, class T , class... Rest>
void	filterDistanceInPlace (PointCloud< Dim, T, Rest... > &pc, Vec< Dim, T > const &origin, T const &min_distance, T const &max_distance, bool filter_nan=true)
	Removes in-place all points from pc that fall outside the given distance range.
template<ufo::execution::ExecutionPolicy P, std::random_access_iterator RandomIt, class UnaryPred >
RandomIt	find_if (P &&policy, RandomIt first, RandomIt last, UnaryPred p)
	Finds the first element in [first, last) satisfying p using the given execution policy.
template<ufo::execution::ExecutionPolicy P, std::ranges::random_access_range Range, class UnaryPred >
auto	find_if (P &&policy, Range &&r, UnaryPred p)
	Finds the first element in range r satisfying p using the given execution policy.
template<std::size_t Dim, std::floating_point T>
constexpr Vec< Dim, T >	floor (Vec< Dim, T > v) noexcept
	Returns the component-wise floor of a floating-point vector.
template<std::integral Index, class UnaryFunc , class Proj = std::identity>
constexpr UnaryFunc	for_each (Index first, Index last, UnaryFunc f, Proj proj={})
	Applies f to each integer index in [first, last) sequentially.
template<std::input_iterator InputIt, class UnaryFunc , class Proj = std::identity>
constexpr UnaryFunc	for_each (InputIt first, InputIt last, UnaryFunc f, Proj proj={})
	Applies f to each element in [first, last) sequentially.
template<std::ranges::input_range Range, class UnaryFunc , class Proj = std::identity> requires (!ufo::execution::ExecutionPolicy<std::remove_cvref_t<Range>>)
constexpr std::ranges::for_each_result< std::ranges::iterator_t< Range >, UnaryFunc >	for_each (Range &&r, UnaryFunc f, Proj proj={})
	Applies f to each element in the range r sequentially.
template<ufo::execution::ExecutionPolicy T, std::integral Index, class UnaryFunc , class Proj = std::identity>
void	for_each (T &&policy, Index first, Index last, UnaryFunc f, Proj proj={})
	Applies f to each integer index in [first, last) using the given execution policy.
template<ufo::execution::ExecutionPolicy T, std::random_access_iterator RandomIt, class UnaryFunc , class Proj = std::identity>
void	for_each (T &&policy, RandomIt first, RandomIt last, UnaryFunc f, Proj proj={})
	Applies f to each element in [first, last) using the given execution policy.
template<ufo::execution::ExecutionPolicy T, std::ranges::random_access_range Range, class UnaryFunc , class Proj = std::identity>
void	for_each (T &&policy, Range &&r, UnaryFunc f, Proj proj={})
	Applies f to each element in the range r using the given execution policy.
template<std::size_t I, std::size_t Rows, std::size_t Cols, class T > requires (I < Rows)
constexpr Vec< Cols, T > &&	get (Mat< Rows, Cols, T > &&m) noexcept
	Structured-binding accessor — rvalue reference to row I.
template<std::size_t I, std::size_t Rows, std::size_t Cols, class T > requires (I < Rows)
constexpr Vec< Cols, T > &	get (Mat< Rows, Cols, T > &m) noexcept
	Structured-binding accessor — lvalue reference to row I.
template<std::size_t I, std::size_t Rows, std::size_t Cols, class T > requires (I < Rows)
constexpr Vec< Cols, T > const &	get (Mat< Rows, Cols, T > const &m) noexcept
	Structured-binding accessor — const lvalue reference to row I.
template<std::size_t I, std::size_t Dim, class T > requires (I < Dim)
constexpr T &&	get (Vec< Dim, T > &&v) noexcept
	Returns an rvalue reference to the I-th element for structured bindings.
template<std::size_t I, std::size_t Dim, class T > requires (I < Dim)
constexpr T &	get (Vec< Dim, T > &v) noexcept
	Returns a reference to the I-th element for structured bindings.
template<std::size_t I, std::size_t Dim, class T > requires (I < Dim)
constexpr T const &	get (Vec< Dim, T > const &v) noexcept
	Returns a const reference to the I-th element for structured bindings.
template<std::size_t Dim, class T >
constexpr Vec< Dim, bool >	greater (Vec< Dim, T > const &v1, Vec< Dim, T > const &v2) noexcept
	Returns a bool vector indicating component-wise greater-than.
template<std::size_t Dim, class T >
constexpr Vec< Dim, bool >	greaterEqual (Vec< Dim, T > const &v1, Vec< Dim, T > const &v2) noexcept
	Returns a bool vector indicating component-wise greater-than-or-equal.
template<std::size_t N, class T = float>
constexpr Mat< N, N, T >	identity () noexcept
	Returns an N × N identity matrix.
ImageProperties	imageProperties (std::filesystem::path const &file)
ImageProperties	imagePropertiesJPEG (std::filesystem::path const &file)
ImageProperties	imagePropertiesPNG (std::filesystem::path const &file)
	Reads the metadata of a PNG file without decoding pixel data.
ImageProperties	imagePropertiesQTP (std::filesystem::path const &file)
template<std::floating_point T>
Mat< 4, 4, T >	infinitePerspective (T fovy, T aspect, T near)
	Builds a right-handed perspective projection matrix with an infinite far plane.
template<class A , class B >
constexpr bool	inside (A const &a, B const &b)
	Checks if a shape is inside another shape.
template<std::size_t Dim, std::floating_point T>
constexpr Vec< Dim, T >	intersectionPoint (Line< Dim, T > const &a, Line< Dim, T > const &b)
	Computes the intersection point of two lines.
template<class A , class B >
constexpr bool	intersects (A const &a, B const &b)
	Checks if two shapes intersect.
template<InvertibleMatrix M>
constexpr M	inverse (M const &m) noexcept
	Computes the inverse of a square floating-point matrix.
template<std::floating_point T>
constexpr Quat< T >	inverse (Quat< T > const &q) noexcept
	Returns the multiplicative inverse conjugate(q) / normSquared(q).
template<std::size_t Dim, std::floating_point T>
constexpr Transform< Dim, T >	inverse (Transform< Dim, T > const &t)
	Returns the inverse of a rigid-body transform.
template<std::size_t Dim, std::floating_point T>
constexpr bool	isfinite (Vec< Dim, T > const &v) noexcept
	Returns true if all components of a floating-point vector are finite.
template<std::floating_point T>
Vec< 4, bool >	isinf (Quat< T > const &q) noexcept
	Returns a bool vector indicating which components are infinite.
template<std::floating_point T>
Vec< 4, bool >	isnan (Quat< T > const &q) noexcept
	Returns a bool vector indicating which components are NaN.
template<std::size_t Dim, std::floating_point T>
constexpr bool	isnan (Vec< Dim, T > const &v) noexcept
	Returns true if any component of a floating-point vector is NaN.
template<std::size_t Dim, std::floating_point T>
constexpr bool	isnormal (Vec< Dim, T > const &v) noexcept
	Returns true if all components of a floating-point vector are normal.
template<std::size_t Dim, class T >
constexpr bool	isNormalized (Vec< Dim, T > const &v) noexcept
	Checks whether a vector has unit length.
std::string	join (std::vector< std::string > const &strings, char delimiter)
	Joins a vector of strings into a single string with a delimiter.
template<std::size_t Dim, std::floating_point T>
constexpr Vec< Dim, T >	ldexp (Vec< Dim, T > v, int exp) noexcept
	Multiplies each component of a floating-point vector by 2^exp.
template<std::size_t Dim, std::floating_point T>
constexpr T	length (Vec< Dim, T > const &v) noexcept
	Computes the Euclidean length (magnitude) of a vector.
template<std::floating_point T>
constexpr Quat< T >	lerp (Quat< T > const &x, Quat< T > const &y, T a) noexcept
	Normalised linear interpolation (NLERP) between two quaternions.
template<std::size_t Dim, std::floating_point T>
constexpr Vec< Dim, T >	lerp (Vec< Dim, T > a, Vec< Dim, T > const &b, T t) noexcept
	Linearly interpolates between two vectors component-wise.
template<std::size_t Dim, class T >
constexpr Vec< Dim, bool >	less (Vec< Dim, T > const &v1, Vec< Dim, T > const &v2) noexcept
	Returns a bool vector indicating component-wise less-than.
template<std::size_t Dim, class T >
constexpr Vec< Dim, bool >	lessEqual (Vec< Dim, T > const &v1, Vec< Dim, T > const &v2) noexcept
	Returns a bool vector indicating component-wise less-than-or-equal.
template<std::size_t Dim, std::floating_point T>
	LineSegment (Vec< Dim, T >, Vec< Dim, T >) -> LineSegment< Dim, T >
template<std::floating_point T>
Mat< 4, 4, T >	lookAt (Vec< 3, T > const &eye, Vec< 3, T > const &target, Vec< 3, T > const &up)
	Builds a view matrix (OpenCV convention).
void	ltrim (std::string &s)
	Removes leading whitespace from the string (in-place).
std::string	ltrimCopy (std::string s)
	Returns a copy of the string with leading whitespace removed.
std::vector< std::string >	mapTypes (MapType mt)
template<class Geometry >
constexpr Vec< Geometry::dimension(), typename Geometry::value_type >	max (Geometry const &g)
	Returns the maximum coordinate of the minimum spanning axis-aligned bounding box of a geometry.
template<std::size_t Dim, class T >
constexpr T	max (Vec< Dim, T > const &v) noexcept
	Returns the largest element in a vector.
template<std::size_t Dim, class T >
constexpr Vec< Dim, T >	max (Vec< Dim, T > v1, Vec< Dim, T > const &v2) noexcept
	Returns the component-wise maximum of two vectors.
template<std::size_t Dim, class T >
constexpr std::size_t	maxIndex (Vec< Dim, T > const &v) noexcept
	Returns the index of the largest element in a vector.
template<class... Args> requires (0 < sizeof...(Args)) && (detail::is_soa_v<remove_cvref_t<Args>> || ...) && (requires { detail::wrap_data(std::declval<Args>()); } && ...)
constexpr auto	merge (Args &&... args)
template<class Geometry >
constexpr Vec< Geometry::dimension(), typename Geometry::value_type >	min (Geometry const &g)
	Returns the minimum coordinate of the minimum spanning axis-aligned bounding box of a geometry.
template<std::size_t Dim, class T >
constexpr T	min (Vec< Dim, T > const &v) noexcept
	Returns the smallest element in a vector.
template<std::size_t Dim, class T >
constexpr Vec< Dim, T >	min (Vec< Dim, T > v1, Vec< Dim, T > const &v2) noexcept
	Returns the component-wise minimum of two vectors.
template<std::size_t Dim, class T >
constexpr std::size_t	minIndex (Vec< Dim, T > const &v) noexcept
	Returns the index of the smallest element in a vector.
template<std::floating_point T>
Quat< T >	mix (Quat< T > const &x, Quat< T > const &y, T a)
	Spherical or linear interpolation between two quaternions.
template<std::size_t Dim, class T >
constexpr Vec< Dim, T >	mix (Vec< Dim, T > const &x, Vec< Dim, T > const &y, Vec< Dim, bool > const &a) noexcept
	Selects between two vectors component-wise using a bool mask.
template<std::size_t Dim, class T , class U >
constexpr Vec< Dim, T >	mix (Vec< Dim, T > const &x, Vec< Dim, T > const &y, Vec< Dim, U > const &a) noexcept
	Mixes two vectors using per-component scalar weights.
template<std::size_t Dim>
constexpr bool	none (Vec< Dim, bool > const &v) noexcept
	Returns true if no component of a bool vector is true.
template<std::floating_point T>
constexpr T	norm (Quat< T > const &q) noexcept
	Returns the Euclidean norm sqrt(w² + x² + y² + z²).
template<std::floating_point T>
constexpr Quat< T >	normalize (Quat< T > const &q) noexcept
	Returns a unit quaternion in the same direction as q.
template<std::size_t Dim, std::floating_point T>
constexpr Vec< Dim, T >	normalize (Vec< Dim, T > const &v) noexcept
	Returns a unit-length vector in the same direction as v.
template<std::floating_point T>
constexpr T	normSquared (Quat< T > const &q) noexcept
	Returns the squared norm (dot product with itself).
template<std::size_t Dim, class T >
constexpr Vec< Dim, bool >	notEqual (Vec< Dim, T > const &v1, Vec< Dim, T > const &v2) noexcept
	Returns a bool vector indicating component-wise inequality.
template<std::size_t R, std::size_t C, class T = float>
constexpr Mat< R, C, T >	ones () noexcept
	Returns an R × C matrix with all elements set to one.
template<std::size_t Dim>
bool	operator!= (DistanceInfo< Dim > const &lhs, DistanceInfo< Dim > const &rhs)
constexpr bool	operator!= (OccupancyState lhs, OccupancyState rhs)
template<typename Key , typename T >
bool	operator!= (RangeMap< Key, T > const &lhs, RangeMap< Key, T > const &rhs)
template<typename Key >
bool	operator!= (RangeSet< Key > const &lhs, RangeSet< Key > const &rhs)
template<class Derived , std::size_t Dim, class... Blocks>
bool	operator!= (Tree< Derived, Dim, Blocks... > const &lhs, Tree< Derived, Dim, Blocks... > const &rhs)
template<std::size_t Dim, class T >
constexpr bool	operator!= (TreeCoord< Dim, T > const &lhs, TreeCoord< Dim, T > const &rhs)
template<std::size_t Dim>
constexpr bool	operator!= (TreeKey< Dim > const &lhs, TreeKey< Dim > const &rhs) noexcept
template<std::size_t Dim, class T >
bool	operator!= (TreeMap< Dim, T > const &lhs, TreeMap< Dim, T > const &rhs)
template<std::size_t Dim>
constexpr bool	operator!= (TreeNode< Dim > const &lhs, TreeNode< Dim > const &rhs) noexcept
template<std::size_t Dim>
bool	operator!= (TreeSet< Dim > const &lhs, TreeSet< Dim > const &rhs)
template<std::size_t Dim, std::integral T>
constexpr Vec< Dim, T >	operator% (T lhs, Vec< Dim, T > rhs) noexcept
	Computes the remainder of scalar lhs divided by every component of rhs (integral types only).
template<std::size_t Dim, std::integral T>
constexpr Vec< Dim, T >	operator% (Vec< Dim, T > lhs, T rhs) noexcept
	Computes the remainder of every component of lhs divided by scalar rhs (integral types only).
template<std::size_t Dim, std::integral T>
constexpr Vec< Dim, T >	operator% (Vec< Dim, T > lhs, Vec< Dim, T > const &rhs) noexcept
	Component-wise modulo of two integral vectors.
template<std::size_t N>
constexpr BitSet< N >	operator& (BitSet< N > lhs, BitSet< N > rhs) noexcept
constexpr MapType	operator& (MapType a, MapType b) noexcept
constexpr MapUtility	operator& (MapUtility a, MapUtility b) noexcept
template<std::size_t Dim, std::integral T>
constexpr Vec< Dim, T >	operator& (T lhs, Vec< Dim, T > rhs) noexcept
	Bitwise ANDs scalar lhs with every component of rhs (integral types only).
template<std::size_t Dim, std::integral T>
constexpr Vec< Dim, T >	operator& (Vec< Dim, T > lhs, T rhs) noexcept
	Bitwise ANDs every component of lhs with scalar rhs (integral types only).
template<std::size_t Dim, std::integral T>
constexpr Vec< Dim, T >	operator& (Vec< Dim, T > lhs, Vec< Dim, T > const &rhs) noexcept
	Component-wise bitwise AND of two integral vectors.
template<std::size_t Dim>
constexpr Vec< Dim, bool >	operator&& (Vec< Dim, bool > lhs, Vec< Dim, bool > const &rhs) noexcept
	Component-wise logical AND of two bool vectors.
template<std::size_t Rows, std::size_t Cols, class T >
constexpr Vec< Rows, T >	operator* (Mat< Rows, Cols, T > const &m, Vec< Cols, T > const &v) noexcept
	Multiplies a matrix by a column vector (M * v).
template<std::size_t Rows, std::size_t Cols, class T >
constexpr Mat< Rows, Cols, T >	operator* (Mat< Rows, Cols, T > lhs, T rhs) noexcept
	Multiplies every element of lhs by scalar rhs.
template<std::size_t Rows, std::size_t Shared, std::size_t Cols, class T >
constexpr Mat< Rows, Cols, T >	operator* (Mat< Rows, Shared, T > const &a, Mat< Shared, Cols, T > const &b) noexcept
	Matrix × matrix product.
template<std::floating_point T>
constexpr Vec< 3, T >	operator* (Quat< T > const &q, Vec< 3, T > const &v) noexcept
	Rotates a 3-D column vector by the quaternion (q * v).
template<std::floating_point T>
constexpr Vec< 4, T >	operator* (Quat< T > const &q, Vec< 4, T > const &v) noexcept
	Rotates the XYZ part of a homogeneous Vec<4> by q, preserving the W component.
template<std::floating_point T>
constexpr Quat< T >	operator* (Quat< T > lhs, Quat< T > const &rhs) noexcept
	Hamilton (quaternion) product.
template<std::floating_point T>
constexpr Quat< T >	operator* (Quat< T > lhs, T s) noexcept
	Scales all components of q by scalar s.
template<std::size_t Rows, std::size_t Cols, class T >
constexpr Mat< Rows, Cols, T >	operator* (T lhs, Mat< Rows, Cols, T > rhs) noexcept
	Multiplies scalar lhs by every element of rhs.
template<std::size_t Dim, class T >
constexpr Vec< Dim, T >	operator* (T lhs, Vec< Dim, T > rhs) noexcept
	Multiplies scalar lhs by every component of rhs.
template<std::floating_point T>
constexpr Quat< T >	operator* (T s, Quat< T > rhs) noexcept
	Scales all components of q by scalar s.
template<std::floating_point T>
constexpr Quat< T >	operator* (Transform< 3, T > const &t, Quat< T > const &q)
	(3D only) Applies the rotation component of a transform to a quaternion.
template<std::size_t Dim, std::floating_point T>
constexpr Vec< Dim, T >	operator* (Transform< Dim, T > const &t, Vec< Dim, T > const &v)
	Applies a transform to a vector: result = R * v + t.
template<std::size_t Dim, std::floating_point T>
constexpr Transform< Dim, T >	operator* (Transform< Dim, T > t1, Transform< Dim, T > const &t2)
	Composes two transforms: (t1 * t2)(v) = t1(t2(v)).
template<std::floating_point T>
constexpr Vec< 3, T >	operator* (Vec< 3, T > const &v, Quat< T > const &q) noexcept
	Rotates a 3-D column vector by the inverse quaternion (v * q).
template<std::floating_point T>
constexpr Vec< 4, T >	operator* (Vec< 4, T > const &v, Quat< T > const &q) noexcept
	Rotates the XYZ part of v by the inverse of q, preserving the W component.
template<std::size_t Dim, class T >
constexpr Vec< Dim, T >	operator* (Vec< Dim, T > lhs, T rhs) noexcept
	Multiplies every component of lhs by scalar rhs.
template<std::size_t Dim, class T >
constexpr Vec< Dim, T >	operator* (Vec< Dim, T > lhs, Vec< Dim, T > const &rhs) noexcept
	Component-wise multiplication of two vectors.
template<std::size_t Rows, std::size_t Cols, class T >
constexpr Vec< Cols, T >	operator* (Vec< Rows, T > const &v, Mat< Rows, Cols, T > const &m) noexcept
	Multiplies a row vector by a matrix (v * M).
template<std::size_t Rows, std::size_t Cols, class T >
constexpr Mat< Rows, Cols, T >	operator+ (Mat< Rows, Cols, T > lhs, Mat< Rows, Cols, T > const &rhs) noexcept
	Element-wise addition of two matrices.
template<std::size_t Rows, std::size_t Cols, class T >
constexpr Mat< Rows, Cols, T >	operator+ (Mat< Rows, Cols, T > lhs, T rhs) noexcept
	Adds scalar rhs to every element of lhs.
template<std::floating_point T>
constexpr Quat< T >	operator+ (Quat< T > const &q) noexcept
	Unary plus — returns a copy of q unchanged.
template<std::floating_point T>
constexpr Quat< T >	operator+ (Quat< T > lhs, Quat< T > const &rhs) noexcept
	Component-wise addition of two quaternions.
template<std::size_t Dim>
constexpr TreeKey< Dim >	operator+ (std::uint32_t v, TreeKey< Dim > key) noexcept
template<std::size_t Rows, std::size_t Cols, class T >
constexpr Mat< Rows, Cols, T >	operator+ (T lhs, Mat< Rows, Cols, T > rhs) noexcept
	Adds scalar lhs to every element of rhs.
template<std::size_t Dim, class T >
constexpr Vec< Dim, T >	operator+ (T lhs, Vec< Dim, T > rhs) noexcept
	Adds scalar lhs to every component of rhs.
Timer	operator+ (Timer lhs, Timer rhs)
template<std::size_t Dim>
constexpr TreeKey< Dim >	operator+ (TreeKey< Dim > key, std::uint32_t v) noexcept
template<std::size_t Dim>
constexpr TreeKey< Dim >	operator+ (TreeKey< Dim > key, Vec< Dim, std::uint32_t > const &v) noexcept
template<std::size_t Dim>
constexpr TreeKey< Dim >	operator+ (Vec< Dim, std::uint32_t > const &v, TreeKey< Dim > key) noexcept
template<std::size_t Dim, class T >
constexpr Vec< Dim, T >	operator+ (Vec< Dim, T > lhs, T rhs) noexcept
	Adds scalar rhs to every component of lhs.
template<std::size_t Dim, class T >
constexpr Vec< Dim, T >	operator+ (Vec< Dim, T > lhs, Vec< Dim, T > const &rhs) noexcept
	Component-wise addition of two vectors.
template<std::size_t Rows, std::size_t Cols, class T >
constexpr Mat< Rows, Cols, T >	operator- (Mat< Rows, Cols, T > lhs, Mat< Rows, Cols, T > const &rhs) noexcept
	Element-wise subtraction of two matrices.
template<std::size_t Rows, std::size_t Cols, class T >
constexpr Mat< Rows, Cols, T >	operator- (Mat< Rows, Cols, T > lhs, T rhs) noexcept
	Subtracts scalar rhs from every element of lhs.
template<std::floating_point T>
constexpr Quat< T >	operator- (Quat< T > const &q) noexcept
	Unary negation — negates all four components.
template<std::floating_point T>
constexpr Quat< T >	operator- (Quat< T > lhs, Quat< T > const &rhs) noexcept
	Component-wise subtraction of two quaternions.
template<std::size_t Dim>
constexpr TreeKey< Dim >	operator- (std::uint32_t v, TreeKey< Dim > key) noexcept
template<std::size_t Rows, std::size_t Cols, class T >
constexpr Mat< Rows, Cols, T >	operator- (T lhs, Mat< Rows, Cols, T > const &rhs) noexcept
	Subtracts every element of rhs from scalar lhs.
template<std::size_t Dim, class T >
constexpr Vec< Dim, T >	operator- (T lhs, Vec< Dim, T > rhs) noexcept
	Subtracts every component of rhs from scalar lhs.
Timer	operator- (Timer lhs, Timer rhs)
template<std::size_t Dim>
constexpr TreeKey< Dim >	operator- (TreeKey< Dim > key, std::uint32_t v) noexcept
template<std::size_t Dim>
constexpr TreeKey< Dim >	operator- (TreeKey< Dim > key, Vec< Dim, std::uint32_t > const &v) noexcept
template<std::size_t Dim>
constexpr TreeKey< Dim >	operator- (Vec< Dim, std::uint32_t > const &v, TreeKey< Dim > key) noexcept
template<std::size_t Dim, class T >
constexpr Vec< Dim, T >	operator- (Vec< Dim, T > lhs, T rhs) noexcept
	Subtracts scalar rhs from every component of lhs.
template<std::size_t Dim, class T >
constexpr Vec< Dim, T >	operator- (Vec< Dim, T > lhs, Vec< Dim, T > const &rhs) noexcept
	Component-wise subtraction of two vectors.
template<std::size_t Rows, std::size_t Cols, class T >
constexpr Mat< Rows, Cols, T >	operator/ (Mat< Rows, Cols, T > lhs, T rhs) noexcept
	Divides every element of lhs by scalar rhs.
template<std::floating_point T>
constexpr Quat< T >	operator/ (Quat< T > lhs, T s) noexcept
	Divides all components of q by scalar s.
template<std::size_t Rows, std::size_t Cols, class T >
constexpr Mat< Rows, Cols, T >	operator/ (T lhs, Mat< Rows, Cols, T > const &rhs) noexcept
	Divides scalar lhs by every element of rhs.
template<std::size_t Dim, class T >
constexpr Vec< Dim, T >	operator/ (T lhs, Vec< Dim, T > rhs) noexcept
	Divides scalar lhs by every component of rhs.
template<std::size_t Dim, class T >
constexpr Vec< Dim, T >	operator/ (Vec< Dim, T > lhs, T rhs) noexcept
	Divides every component of lhs by scalar rhs.
template<std::size_t Dim, class T >
constexpr Vec< Dim, T >	operator/ (Vec< Dim, T > lhs, Vec< Dim, T > const &rhs) noexcept
	Component-wise division of two vectors.
constexpr bool	operator< (OccupancyState lhs, OccupancyState rhs)
template<typename Key , typename T >
bool	operator< (RangeMap< Key, T > const &lhs, RangeMap< Key, T > const &rhs)
template<typename Key >
bool	operator< (RangeSet< Key > const &lhs, RangeSet< Key > const &rhs)
template<std::size_t Dim>
constexpr bool	operator< (TreeKey< Dim > const &lhs, TreeKey< Dim > const &rhs) noexcept
template<std::size_t Dim>
constexpr bool	operator< (TreeNode< Dim > const &lhs, TreeNode< Dim > const &rhs) noexcept
template<class CharT , class Traits , std::size_t N>
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, BitSet< N > x)
std::ostream &	operator<< (std::ostream &os, MapHeader const &header)
std::ostream &	operator<< (std::ostream &os, MapType mt)
template<typename Key , typename T >
std::ostream &	operator<< (std::ostream &os, RangeMap< Key, T > const &range_map)
template<typename Key >
std::ostream &	operator<< (std::ostream &os, RangeSet< Key > const &range_set)
std::ostream &	operator<< (std::ostream &os, ScalarType type)
	Stream-insertion operator for ScalarType.
template<std::size_t Dim>
std::ostream &	operator<< (std::ostream &os, TreeNode< Dim > const &node)
template<std::size_t Dim, std::floating_point T>
std::ostream &	operator<< (std::ostream &out, AABB< Dim, T > const &aabb)
	Output stream operator for AABB.
template<std::size_t Dim, std::floating_point T>
std::ostream &	operator<< (std::ostream &out, Capsule< Dim, T > const &capsule)
	Output stream operator for Capsule.
std::ostream &	operator<< (std::ostream &out, Confidence c)
	Writes the confidence score to out.
template<std::size_t Dim, std::floating_point T>
std::ostream &	operator<< (std::ostream &out, Cylinder< Dim, T > const &cylinder)
	Output stream operator for Cylinder.
template<std::size_t Dim>
std::ostream &	operator<< (std::ostream &out, DistanceInfo< Dim > const &info)
template<std::size_t Dim, std::floating_point T>
std::ostream &	operator<< (std::ostream &out, Ellipsoid< Dim, T > const &ellipsoid)
	Output stream operator for Ellipsoid.
template<std::size_t Dim, std::floating_point T>
std::ostream &	operator<< (std::ostream &out, Frustum< Dim, T > const &frustum)
	Output stream operator for Frustum.
std::ostream &	operator<< (std::ostream &out, Intensity i)
	Writes the raw intensity scalar to out.
std::ostream &	operator<< (std::ostream &out, Label l)
	Writes the raw label integer to out.
template<std::size_t Dim, std::floating_point T>
std::ostream &	operator<< (std::ostream &out, Line< Dim, T > const &line)
	Output stream operator for Line.
template<std::size_t Dim, std::floating_point T>
std::ostream &	operator<< (std::ostream &out, LineSegment< Dim, T > const &ls)
	Output stream operator for LineSegment.
template<std::size_t Rows, std::size_t Cols, class T >
std::ostream &	operator<< (std::ostream &out, Mat< Rows, Cols, T > const &m)
	Writes a matrix to an output stream, one row per line.
template<std::size_t Dim, class T >
std::ostream &	operator<< (std::ostream &out, Normal< Dim, T > const &n)
	Writes a human-readable representation of n to os.
template<std::floating_point T>
std::ostream &	operator<< (std::ostream &out, OBB< 2, T > const &obb)
	Output stream operator for 2D OBB.
template<std::floating_point T>
std::ostream &	operator<< (std::ostream &out, OBB< 3, T > const &obb)
	Output stream operator for 3D OBB.
template<std::floating_point T>
std::ostream &	operator<< (std::ostream &out, OBB< 4, T > const &obb)
	Output stream operator for 4D OBB.
template<std::size_t Dim, std::floating_point T>
std::ostream &	operator<< (std::ostream &out, Plane< Dim, T > const &plane)
	Output stream operator for Plane.
template<std::floating_point T>
std::ostream &	operator<< (std::ostream &out, Quat< T > const &q)
	Writes the quaternion to an output stream as "qw: W qx: X qy: Y qz: Z".
template<class T >
std::ostream &	operator<< (std::ostream &out, Range< T > const &r)
	Writes the range to p out in human-readable format.
template<std::size_t Dim, std::floating_point T>
std::ostream &	operator<< (std::ostream &out, Ray< Dim, T > const &ray)
	Output stream operator for Ray.
std::ostream &	operator<< (std::ostream &out, Semantic s)
	Writes the semantic as "label: confidence" to out.
template<std::size_t Dim, std::floating_point T>
std::ostream &	operator<< (std::ostream &out, Sphere< Dim, T > const &sphere)
	Output stream operator for Sphere.
std::ostream &	operator<< (std::ostream &out, Surfel const &s)
	Writes a human-readable summary of the surfel to out.
template<std::size_t Dim, std::floating_point T>
std::ostream &	operator<< (std::ostream &out, Transform< Dim, T > const &t)
	Writes a human-readable representation of the transform to an output stream.
template<std::size_t Dim, class T >
std::ostream &	operator<< (std::ostream &out, TreeCoord< Dim, T > const &tc)
std::ostream &	operator<< (std::ostream &out, TreeIndex index)
template<std::size_t Dim>
std::ostream &	operator<< (std::ostream &out, TreeKey< Dim > const &key)
template<std::size_t Dim, std::floating_point T>
std::ostream &	operator<< (std::ostream &out, Triangle< Dim, T > const &triangle)
	Output stream operator for Triangle.
template<std::size_t Dim, class T >
std::ostream &	operator<< (std::ostream &out, Vec< Dim, T > const &v)
	Writes a human-readable representation of a vector to a stream.
std::ostream &	operator<< (std::ostream &out, Weight v)
	Writes the raw scalar weight to out.
template<std::size_t Dim, std::integral T>
constexpr Vec< Dim, T >	operator<< (T lhs, Vec< Dim, T > rhs) noexcept
	Left-shifts scalar lhs by every component of rhs (integral types only).
template<std::size_t Dim, std::integral T>
constexpr Vec< Dim, T >	operator<< (Vec< Dim, T > lhs, T rhs) noexcept
	Left-shifts every component of lhs by scalar rhs (integral types only).
template<std::size_t Dim, std::integral T>
constexpr Vec< Dim, T >	operator<< (Vec< Dim, T > lhs, Vec< Dim, T > const &rhs) noexcept
	Component-wise left shift of an integral vector by a per-element amount.
constexpr bool	operator<= (OccupancyState lhs, OccupancyState rhs)
template<typename Key , typename T >
bool	operator<= (RangeMap< Key, T > const &lhs, RangeMap< Key, T > const &rhs)
template<typename Key >
bool	operator<= (RangeSet< Key > const &lhs, RangeSet< Key > const &rhs)
template<std::size_t Dim>
constexpr bool	operator<= (TreeKey< Dim > const &lhs, TreeKey< Dim > const &rhs) noexcept
template<std::size_t Dim>
constexpr bool	operator<= (TreeNode< Dim > const &lhs, TreeNode< Dim > const &rhs) noexcept
template<class... Ts>
constexpr auto	operator<=> (SoA< Ts... > const &lhs, SoA< Ts... > const &rhs)
template<std::size_t Dim>
bool	operator== (DistanceInfo< Dim > const &lhs, DistanceInfo< Dim > const &rhs)
template<std::size_t Dim, std::floating_point T>
bool	operator== (Line< Dim, T > const &lhs, Line< Dim, T > const &rhs) noexcept
	Equality operator for Line.
constexpr bool	operator== (OccupancyState lhs, OccupancyState rhs)
template<typename Key , typename T >
bool	operator== (RangeMap< Key, T > const &lhs, RangeMap< Key, T > const &rhs)
template<typename Key >
bool	operator== (RangeSet< Key > const &lhs, RangeSet< Key > const &rhs)
template<class... Ts>
constexpr bool	operator== (SoA< Ts... > const &lhs, SoA< Ts... > const &rhs)
template<class Derived , std::size_t Dim, class... Blocks>
bool	operator== (Tree< Derived, Dim, Blocks... > const &lhs, Tree< Derived, Dim, Blocks... > const &rhs)
template<std::size_t Dim, class T >
constexpr bool	operator== (TreeCoord< Dim, T > const &lhs, TreeCoord< Dim, T > const &rhs)
template<std::size_t Dim>
constexpr bool	operator== (TreeKey< Dim > const &lhs, TreeKey< Dim > const &rhs) noexcept
template<std::size_t Dim, class T >
bool	operator== (TreeMap< Dim, T > const &lhs, TreeMap< Dim, T > const &rhs)
template<std::size_t Dim>
constexpr bool	operator== (TreeNode< Dim > const &lhs, TreeNode< Dim > const &rhs) noexcept
template<std::size_t Dim>
bool	operator== (TreeSet< Dim > const &lhs, TreeSet< Dim > const &rhs)
constexpr bool	operator> (OccupancyState lhs, OccupancyState rhs)
template<typename Key , typename T >
bool	operator> (RangeMap< Key, T > const &lhs, RangeMap< Key, T > const &rhs)
template<typename Key >
bool	operator> (RangeSet< Key > const &lhs, RangeSet< Key > const &rhs)
template<std::size_t Dim>
constexpr bool	operator> (TreeKey< Dim > const &lhs, TreeKey< Dim > const &rhs) noexcept
template<std::size_t Dim>
constexpr bool	operator> (TreeNode< Dim > const &lhs, TreeNode< Dim > const &rhs) noexcept
constexpr bool	operator>= (OccupancyState lhs, OccupancyState rhs)
template<typename Key , typename T >
bool	operator>= (RangeMap< Key, T > const &lhs, RangeMap< Key, T > const &rhs)
template<typename Key >
bool	operator>= (RangeSet< Key > const &lhs, RangeSet< Key > const &rhs)
template<std::size_t Dim>
constexpr bool	operator>= (TreeKey< Dim > const &lhs, TreeKey< Dim > const &rhs) noexcept
template<std::size_t Dim>
constexpr bool	operator>= (TreeNode< Dim > const &lhs, TreeNode< Dim > const &rhs) noexcept
template<class CharT , class Traits , std::size_t N>
std::basic_istream< CharT, Traits > &	operator>> (std::basic_istream< CharT, Traits > &is, BitSet< N > &x)
std::istream &	operator>> (std::istream &is, MapHeader &header)
template<std::size_t Dim, std::integral T>
constexpr Vec< Dim, T >	operator>> (T lhs, Vec< Dim, T > rhs) noexcept
	Right-shifts scalar lhs by every component of rhs (integral types only).
template<std::size_t Dim, std::integral T>
constexpr Vec< Dim, T >	operator>> (Vec< Dim, T > lhs, T rhs) noexcept
	Right-shifts every component of lhs by scalar rhs (integral types only).
template<std::size_t Dim, std::integral T>
constexpr Vec< Dim, T >	operator>> (Vec< Dim, T > lhs, Vec< Dim, T > const &rhs) noexcept
	Component-wise right shift of an integral vector by a per-element amount.
template<std::size_t N>
constexpr BitSet< N >	operator^ (BitSet< N > lhs, BitSet< N > rhs) noexcept
template<std::size_t Dim, std::integral T>
constexpr Vec< Dim, T >	operator^ (T lhs, Vec< Dim, T > rhs) noexcept
	Bitwise XORs scalar lhs with every component of rhs (integral types only).
template<std::size_t Dim, std::integral T>
constexpr Vec< Dim, T >	operator^ (Vec< Dim, T > lhs, T rhs) noexcept
	Bitwise XORs every component of lhs with scalar rhs (integral types only).
template<std::size_t Dim, std::integral T>
constexpr Vec< Dim, T >	operator^ (Vec< Dim, T > lhs, Vec< Dim, T > const &rhs) noexcept
	Component-wise bitwise XOR of two integral vectors.
template<std::size_t N>
constexpr BitSet< N >	operator| (BitSet< N > lhs, BitSet< N > rhs) noexcept
constexpr MapType	operator| (MapType a, MapType b) noexcept
constexpr MapUtility	operator| (MapUtility a, MapUtility b) noexcept
template<std::size_t Dim, std::integral T>
constexpr Vec< Dim, T >	operator| (T lhs, Vec< Dim, T > rhs) noexcept
	Bitwise ORs scalar lhs with every component of rhs (integral types only).
template<std::size_t Dim, std::integral T>
constexpr Vec< Dim, T >	operator| (Vec< Dim, T > lhs, T rhs) noexcept
	Bitwise ORs every component of lhs with scalar rhs (integral types only).
template<std::size_t Dim, std::integral T>
constexpr Vec< Dim, T >	operator| (Vec< Dim, T > lhs, Vec< Dim, T > const &rhs) noexcept
	Component-wise bitwise OR of two integral vectors.
template<std::size_t Dim>
constexpr Vec< Dim, bool >	operator|| (Vec< Dim, bool > lhs, Vec< Dim, bool > const &rhs) noexcept
	Component-wise logical OR of two bool vectors.
template<std::floating_point T>
Mat< 4, 4, T >	orthogonal (T left, T right, T bottom, T top)
	Builds a right-handed 2-D orthographic projection matrix (no depth clipping).
template<std::floating_point T>
Mat< 4, 4, T >	orthogonal (T left, T right, T bottom, T top, T zNear, T zFar)
	Builds an orthographic projection matrix (OpenCV convention).
template<std::floating_point T>
Mat< 4, 4, T >	perspective (T fovy, T aspect, T near, T far)
	Builds a perspective projection matrix (OpenCV convention).
template<std::floating_point T>
Mat< 4, 4, T >	perspective (T fx, T fy, T cx, T cy, T width, T height, T near, T far)
	Builds a perspective projection matrix (OpenCV convention).
template<std::floating_point T>
T	pitch (Quat< T > const &q) noexcept
	Extracts the pitch angle (rotation about the Y-axis) in radians.
template<std::size_t Dim, class T >
constexpr T	product (Vec< Dim, T > const &v) noexcept
	Computes the product of all elements in a vector.
template<std::floating_point T>
Quat< T >	quatLookAt (Vec< 3, T > const &direction, Vec< 3, T > const &up)
	Builds a quaternion that orients an object to look in direction.
template<typename Key1 , typename Key2 >
RangeSet< Key1 >	rangesDifference (RangeSet< Key1 > const &a, RangeSet< Key2 > const &b)
	Creates a new RangeSet containing the ranges in a which are not find in b.
template<typename Key1 , typename Key2 >
bool	rangesIncludes (RangeSet< Key1 > const &a, RangeSet< Key2 > const &b)
	Returns true if b is a subsequence of a.
template<typename Key1 , typename Key2 >
RangeSet< Key1 >	rangesIntersection (RangeSet< Key1 > const &a, RangeSet< Key2 > const &b)
template<typename Key1 , typename Key2 >
RangeSet< Key1 >	rangesSymmetricDifference (RangeSet< Key1 > const &a, RangeSet< Key2 > const &b)
template<typename Key1 , typename Key2 >
RangeSet< Key1 >	rangesUnion (RangeSet< Key1 > const &a, RangeSet< Key2 > const &b)
template<std::size_t Dim, std::floating_point T>
	Ray (Vec< Dim, T >, Vec< Dim, T >) -> Ray< Dim, T >
template<class T >
bool	read (std::filesystem::path const &file, Image< T > &image)
template<std::size_t Dim, class T , class... Ts>
bool	read (std::filesystem::path const &file, PointCloud< Dim, T, Ts... > &pc)
template<ColorType CT, class T , bool Alpha, bool Weight>
bool	readJPEG (std::filesystem::path const &file, Image< Color< CT, T, Alpha, Weight > > &image)
template<std::size_t Dim, class T , class... Ts>
bool	readOBJ (std::filesystem::path const &file, PointCloud< Dim, T, Ts... > &pc)
template<std::size_t Dim, class T , class... Ts>
bool	readPCD (std::filesystem::path const &file, PointCloud< Dim, T, Ts... > &pc, ufo::Transform3f *viewpoint=nullptr)
template<std::size_t Dim, class T , class... Ts>
bool	readPLY (std::filesystem::path const &file, PointCloud< Dim, T, Ts... > &pc)
template<ColorType CT, class T , bool Alpha, bool Weight>
bool	readPNG (std::filesystem::path const &file, Image< Color< CT, T, Alpha, Weight > > &image)
	Reads a PNG file into an Image of the specified colour type.
template<std::size_t Dim, class T , class... Ts>
bool	readPTS (std::filesystem::path const &file, PointCloud< Dim, T, Ts... > &pc)
template<ColorType CT, class T , bool Alpha, bool Weight>
bool	readQTP (std::filesystem::path const &file, Image< Color< CT, T, Alpha, Weight > > &image)
template<class... Ts>
bool	readUFO (std::filesystem::path const &file, Cloud< Ts... > &cloud)
template<class... Ts>
bool	readUFO (std::istream &in, Cloud< Ts... > &cloud)
template<std::size_t Dim, class T , class... Ts>
bool	readXYZ (std::filesystem::path const &file, PointCloud< Dim, T, Ts... > &pc)
template<std::size_t Dim, class T , class... Ts>
bool	readXYZI (std::filesystem::path const &file, PointCloud< Dim, T, Ts... > &pc)
template<std::size_t Dim, class T , class... Ts>
bool	readXYZN (std::filesystem::path const &file, PointCloud< Dim, T, Ts... > &pc)
template<std::size_t Dim, class T , class... Ts>
bool	readXYZRGB (std::filesystem::path const &file, PointCloud< Dim, T, Ts... > &pc)
template<ufo::execution::ExecutionPolicy P, std::input_iterator InputIt, class T >
T	reduce (P &&policy, InputIt first, InputIt last, T init)
	Reduces the range [first, last) using init and the given execution policy.
template<ufo::execution::ExecutionPolicy P, std::ranges::input_range Range, class T >
T	reduce (P &&policy, Range &&r, T init)
	Reduces the range r using init and the given execution policy.
template<std::size_t Dim, std::floating_point T>
constexpr Vec< Dim, T >	reflect (Vec< Dim, T > const &v, Vec< Dim, T > const &n) noexcept
	Reflects an incident vector about a surface normal.
template<std::size_t Dim, std::floating_point T>
constexpr Vec< Dim, T >	refract (Vec< Dim, T > const &v, Vec< Dim, T > const &n, T eta) noexcept
	Computes the refraction vector for an incident ray entering a new medium.
template<class ExecutionPolicy , class Tree , class Predicate , std::enable_if_t< pred::is_pred_v< Predicate >, bool > = true, std::enable_if_t< execution::is_execution_policy_v< ExecutionPolicy >, bool > = true>
Image< TraceResult< Tree::dimensions()> >	render (ExecutionPolicy &&policy, Tree const &tree, Camera const &camera, Predicate const &pred)
template<class ExecutionPolicy , class Tree , class NodeType , class Predicate , std::enable_if_t< Tree::template is_node_type_v< NodeType >, bool > = true, std::enable_if_t< pred::is_pred_v< Predicate >, bool > = true, std::enable_if_t< execution::is_execution_policy_v< ExecutionPolicy >, bool > = true>
Image< TraceResult< Tree::dimensions()> >	render (ExecutionPolicy &&policy, Tree const &tree, NodeType const &node, Camera const &camera, Predicate const &pred)
template<class Tree , class Predicate , std::enable_if_t< pred::is_pred_v< Predicate >, bool > = true>
Image< TraceResult< Tree::dimensions()> >	render (Tree const &tree, Camera const &camera, Predicate const &pred)
template<class Tree , class NodeType , class Predicate , std::enable_if_t< Tree::template is_node_type_v< NodeType >, bool > = true, std::enable_if_t< pred::is_pred_v< Predicate >, bool > = true>
Image< TraceResult< Tree::dimensions()> >	render (Tree const &tree, NodeType const &node, Camera const &camera, Predicate const &pred)
template<class Map , class Predicate = pred::True, std::enable_if_t< pred::is_pred_v< Predicate, Map >, bool > = true>
std::pair< Image< typename Map::Node >, Image< float > >	renderGPU (Map const &map, Camera const &camera, Predicate const &pred=pred::True{}, bool only_exists=true)
template<class NodeType , class Map , class Predicate = pred::True, std::enable_if_t< Map::template is_node_type_v< NodeType >, bool > = true, std::enable_if_t< pred::is_pred_v< Predicate, Map >, bool > = true>
std::pair< Image< typename Map::Node >, Image< float > >	renderGPU (NodeType const &node, Map const &map, Camera const &camera, Predicate pred=pred::True{}, bool only_exists=true)
template<std::floating_point T>
T	roll (Quat< T > const &q) noexcept
	Extracts the roll angle (rotation about the X-axis) in radians.
template<std::floating_point T>
Mat< 4, 4, T >	rotate (Mat< 4, 4, T > const &m, T angle, Vec< 3, T > const &v)
	Applies an axis-angle rotation to a 4×4 matrix.
template<std::floating_point T>
Quat< T >	rotate (Quat< T > const &q, T angle, Vec< 3, T > axis)
	Appends an angle-axis rotation to a quaternion.
template<std::size_t Dim, std::floating_point T>
constexpr Vec< Dim, T >	round (Vec< Dim, T > v) noexcept
	Returns the component-wise rounding to nearest integer of a floating-point vector.
void	rtrim (std::string &s)
	Removes trailing whitespace from the string (in-place).
std::string	rtrimCopy (std::string s)
	Returns a copy of the string with trailing whitespace removed.
template<std::size_t Dim, class T >
constexpr Vec< Dim, T >	sign (Vec< Dim, T > const &x) noexcept
	Returns the component-wise sign of a vector.
template<class... Ts>
constexpr auto	size (SoA< Ts... > const &c)
template<std::floating_point T>
Quat< T >	slerp (Quat< T > const &x, Quat< T > const &y, T a)
	Spherical linear interpolation (SLERP) between two unit quaternions.
template<std::floating_point T, std::floating_point S>
Quat< T >	slerp (Quat< T > const &x, Quat< T > const &y, T a, S k)
	SLERP with k extra full spins (Graphics Gems III, page 96).
template<class... Ts, class... Us>
	SoA (SoA< Ts... >, SoA< Us... >) -> SoA< Ts..., Us... >
template<class... Ts, class... Us, class... Vs>
	SoA (SoA< Ts... >, SoA< Us... >, SoA< Vs... >) -> SoA< Ts..., Us..., Vs... >
template<class... Ts, class... Us, class V , class Alloc >
	SoA (SoA< Ts... >, SoA< Us... >, std::vector< V, Alloc >) -> SoA< Ts..., Us..., V >
template<class... Ts, class U , class Alloc >
	SoA (SoA< Ts... >, std::vector< U, Alloc >) -> SoA< Ts..., U >
template<class... Ts, class U , class Alloc , class... Vs>
	SoA (SoA< Ts... >, std::vector< U, Alloc >, SoA< Vs... >) -> SoA< Ts..., U, Vs... >
template<class... Ts, class U1 , class Alloc1 , class U2 , class Alloc2 >
	SoA (SoA< Ts... >, std::vector< U1, Alloc1 >, std::vector< U2, Alloc2 >) -> SoA< Ts..., U1, U2 >
template<class... Ts>
	SoA (std::initializer_list< std::tuple< Ts... > >) -> SoA< Ts... >
template<class... Ts>
	SoA (std::size_t, std::tuple< Ts... >) -> SoA< Ts... >
template<class T , class Alloc , class... Us>
	SoA (std::vector< T, Alloc >, SoA< Us... >) -> SoA< T, Us... >
template<class T , class Alloc , class... Us, class... Vs>
	SoA (std::vector< T, Alloc >, SoA< Us... >, SoA< Vs... >) -> SoA< T, Us..., Vs... >
template<class T1 , class Alloc1 , class... Us, class T2 , class Alloc2 >
	SoA (std::vector< T1, Alloc1 >, SoA< Us... >, std::vector< T2, Alloc2 >) -> SoA< T1, Us..., T2 >
template<class T1 , class Alloc1 , class T2 , class Alloc2 >
	SoA (std::vector< T1, Alloc1 >, std::vector< T2, Alloc2 >) -> SoA< T1, T2 >
template<class T1 , class Alloc1 , class T2 , class Alloc2 , class... Vs>
	SoA (std::vector< T1, Alloc1 >, std::vector< T2, Alloc2 >, SoA< Vs... >) -> SoA< T1, T2, Vs... >
template<class T1 , class Alloc1 , class T2 , class Alloc2 , class T3 , class Alloc3 >
	SoA (std::vector< T1, Alloc1 >, std::vector< T2, Alloc2 >, std::vector< T3, Alloc3 >) -> SoA< T1, T2, T3 >
template<class... Ts>
	SoA (std::vector< Ts >...) -> SoA< Ts... >
template<std::size_t Dim>
constexpr bool	some (Vec< Dim, bool > const &v) noexcept
	Returns true if some but not all components of a bool vector are true.
template<std::size_t Dim, std::floating_point T>
	Sphere (Vec< Dim, T >, T) -> Sphere< Dim, T >
std::vector< std::string >	split (std::string const &s, char delimiter)
	Splits a string into a vector of substrings using a delimiter.
bool	startsWith (std::string const &s, std::string const &prefix)
	Checks if a string starts with a given prefix.
template<std::size_t Dim, class T >
constexpr T	sum (Vec< Dim, T > const &v) noexcept
	Computes the sum of all elements in a vector.
template<std::floating_point T>
void	swap (Quat< T > &lhs, Quat< T > &rhs) noexcept
	Non-member swap — exchanges all components of lhs and rhs.
template<typename Key , typename T >
void	swap (RangeMap< Key, T > &lhs, RangeMap< Key, T > &rhs) noexcept(noexcept(lhs.swap(rhs)))
template<typename Key >
void	swap (RangeSet< Key > &lhs, RangeSet< Key > &rhs) noexcept(noexcept(lhs.swap(rhs)))
template<class... Ts>
void	swap (TreeContainer< Ts... > &lhs, TreeContainer< Ts... > &rhs)
template<std::size_t Dim>
void	swap (TreeKey< Dim > &lhs, TreeKey< Dim > &rhs) noexcept
constexpr std::string_view	to_string (MapType mt)
std::string	tolower (std::string s)
	Converts all characters in the string to lowercase.
constexpr std::string_view	toString (ScalarType type) noexcept
	Returns a human-readable string for a ScalarType value.
std::string	toupper (std::string s)
	Converts all characters in the string to uppercase.
template<class ExecutionPolicy , std::size_t Dim, class T , class... Rest> requires execution::is_execution_policy_v<ExecutionPolicy>
PointCloud< Dim, T, Rest... >	transform (ExecutionPolicy &&policy, Transform< Dim, T > const &t, PointCloud< Dim, T, Rest... > pc)
	Applies a rigid transform to every point position and returns the result, using the given execution policy.
template<std::input_iterator InputIt, class OutputIt , class UnaryOp , class Proj = std::identity>
constexpr OutputIt	transform (InputIt first1, InputIt last1, OutputIt d_first, UnaryOp unary_op, Proj proj={})
	Applies unary_op to each element of [first1, last1) and writes the results to [d_first, ...) sequentially.
template<std::input_iterator InputIt1, std::input_iterator InputIt2, class OutputIt , class BinaryOp , class Proj1 = std::identity, class Proj2 = std::identity>
constexpr OutputIt	transform (InputIt1 first1, InputIt1 last1, InputIt2 first2, OutputIt d_first, BinaryOp binary_op, Proj1 proj1={}, Proj2 proj2={})
	Applies binary_op to corresponding pairs of elements from [first1, last1) and [first2, ...), writing results to [d_first, ...) sequentially.
template<std::ranges::input_range Range1, std::input_iterator InputIt2, std::weakly_incrementable OutputIt, class BinaryOp , class Proj1 = std::identity, class Proj2 = std::identity> requires ( !ufo::execution::ExecutionPolicy<std::remove_cvref_t<Range1>> && std::indirectly_writable< OutputIt, std::indirect_result_t< BinaryOp, std::projected<std::ranges::iterator_t<Range1>, Proj1>, std::projected<InputIt2, Proj2>>>)
constexpr std::ranges::binary_transform_result< std::ranges::iterator_t< Range1 >, InputIt2, OutputIt >	transform (Range1 &&r1, InputIt2 first2, OutputIt d_first, BinaryOp binary_op, Proj1 proj1={}, Proj2 proj2={})
	Applies binary_op to corresponding pairs of elements from range r1 and first2, writing results to d_first sequentially.
template<std::ranges::input_range Range1, std::weakly_incrementable OutputIt, class UnaryOp , class Proj = std::identity> requires ( !ufo::execution::ExecutionPolicy<std::remove_cvref_t<Range1>> && std::indirectly_writable< OutputIt, std::indirect_result_t< UnaryOp, std::projected<std::ranges::iterator_t<Range1>, Proj>>>)
constexpr std::ranges::unary_transform_result< std::ranges::iterator_t< Range1 >, OutputIt >	transform (Range1 &&r1, OutputIt d_first, UnaryOp unary_op, Proj proj={})
	Applies unary_op to each element in range r1 and writes the results to d_first sequentially.
template<ufo::execution::ExecutionPolicy T, std::random_access_iterator RandomIt1, std::random_access_iterator RandomIt2, class UnaryOp , class Proj = std::identity> requires (!std::input_or_output_iterator<UnaryOp>)
RandomIt2	transform (T &&policy, RandomIt1 first1, RandomIt1 last1, RandomIt2 d_first, UnaryOp unary_op, Proj proj={})
	Applies unary_op to each element of [first1, last1) and writes the results to [d_first, ...) using the given execution policy.
template<ufo::execution::ExecutionPolicy T, std::random_access_iterator RandomIt1, std::random_access_iterator RandomIt2, std::random_access_iterator RandomIt3, class BinaryOp , class Proj1 = std::identity, class Proj2 = std::identity>
RandomIt3	transform (T &&policy, RandomIt1 first1, RandomIt1 last1, RandomIt2 first2, RandomIt3 d_first, BinaryOp binary_op, Proj1 proj1={}, Proj2 proj2={})
	Applies binary_op to corresponding pairs of elements from [first1, last1) and [first2, ...), writing results to [d_first, ...) using the given execution policy.
template<ufo::execution::ExecutionPolicy T, std::ranges::random_access_range Range1, std::random_access_iterator RandomIt2, class UnaryOp , class Proj = std::identity> requires ( std::indirectly_writable< RandomIt2, std::indirect_result_t< UnaryOp, std::projected<std::ranges::iterator_t<Range1>, Proj>>>)
RandomIt2	transform (T &&policy, Range1 &&r1, RandomIt2 d_first, UnaryOp unary_op, Proj proj={})
	Applies unary_op to each element in range r1 and writes the results to d_first using the given execution policy.
template<ufo::execution::ExecutionPolicy T, std::ranges::random_access_range Range1, std::random_access_iterator RandomIt2, std::random_access_iterator RandomIt3, class BinaryOp , class Proj1 = std::identity, class Proj2 = std::identity> requires ( std::indirectly_writable< RandomIt3, std::indirect_result_t< BinaryOp, std::projected<std::ranges::iterator_t<Range1>, Proj1>, std::projected<RandomIt2, Proj2>>>)
RandomIt3	transform (T &&policy, Range1 &&r1, RandomIt2 first2, RandomIt3 d_first, BinaryOp binary_op, Proj1 proj1={}, Proj2 proj2={})
	Applies binary_op to corresponding pairs of elements from range r1 and first2, writing results to d_first using the given execution policy.
template<std::size_t Dim, class T , class... Rest>
PointCloud< Dim, T, Rest... >	transform (Transform< Dim, T > const &t, PointCloud< Dim, T, Rest... > pc)
	Applies a rigid transform to every point position and returns the result.
template<class ExecutionPolicy , std::size_t Dim, class T , class... Rest> requires execution::is_execution_policy_v<ExecutionPolicy>
void	transformInPlace (ExecutionPolicy &&policy, Transform< Dim, T > const &t, PointCloud< Dim, T, Rest... > &pc)
	Applies a rigid transform to every point position in-place, using the given execution policy.
template<std::size_t Dim, class T , class... Rest>
void	transformInPlace (Transform< Dim, T > const &t, PointCloud< Dim, T, Rest... > &pc)
	Applies a rigid transform to every point position in-place.
template<std::size_t Rows, std::size_t Cols, class T >
constexpr Mat< Cols, Rows, T >	transpose (Mat< Rows, Cols, T > const &m) noexcept
	Returns the transpose of a matrix.
template<std::size_t Dim, class T >
	TreeCoord (Vec< Dim, T >) -> TreeCoord< Dim, T >
template<std::size_t Dim, class T >
	TreeCoord (Vec< Dim, T >, unsigned) -> TreeCoord< Dim, T >
template<std::size_t Dim>
	TreeNode (TreeCode< Dim >, TreeIndex) -> TreeNode< Dim >
template<std::size_t Dim, std::floating_point T>
	Triangle (Vec< Dim, T >, Vec< Dim, T >, Vec< Dim, T >) -> Triangle< Dim, T >
void	trim (std::string &s)
	Removes leading and trailing whitespace from the string (in-place).
std::string	trimCopy (std::string s)
	Returns a copy of the string with leading and trailing whitespace removed.
template<std::size_t Dim, std::floating_point T>
constexpr Vec< Dim, T >	trunc (Vec< Dim, T > v) noexcept
	Returns the component-wise truncation toward zero of a floating-point vector.
template<class T , class... Ts>
constexpr auto	view (SoA< Ts... > &soa)
template<class T , class... Ts>
constexpr auto	view (SoA< Ts... > const &soa)
template<class T >
bool	write (std::filesystem::path const &file, Image< T > const &image)
template<std::size_t Dim, class T , class... Ts>
bool	write (std::filesystem::path const &file, PointCloud< Dim, T, Ts... > const &pc)
template<ColorType CT, class T , bool Alpha, bool Weight>
bool	writeJPEG (std::filesystem::path const &file, Image< Color< CT, T, Alpha, Weight > > const &image, int quality=90)
template<std::size_t Dim, class T , class... Ts>
bool	writeOBJ (std::filesystem::path const &file, PointCloud< Dim, T, Ts... > const &pc)
template<std::size_t Dim, class T , class... Ts>
bool	writePCD (std::filesystem::path const &file, PointCloud< Dim, T, Ts... > const &pc, bool ascii=false, ufo::Transform3f viewpoint=ufo::Transform3f())
template<std::size_t Dim, class T , class... Ts>
bool	writePLY (std::filesystem::path const &file, PointCloud< Dim, T, Ts... > const &pc, bool ascii=false)
template<ColorType CT, class T , bool Alpha, bool Weight>
bool	writePNG (std::filesystem::path const &file, Image< Color< CT, T, Alpha, Weight > > const &image)
	Writes an Image to a PNG file.
template<std::size_t Dim, class T , class... Ts>
bool	writePTS (std::filesystem::path const &file, PointCloud< Dim, T, Ts... > const &pc)
template<ColorType CT, class T , bool Alpha, bool Weight>
bool	writeQTP (std::filesystem::path const &file, Image< Color< CT, T, Alpha, Weight > > const &image, int quality=90)
template<class... Ts>
bool	writeUFO (std::filesystem::path const &file, Cloud< Ts... > const &cloud, CloudUFOOptions const &options=CloudUFOOptions())
template<class... Ts>
bool	writeUFO (std::ostream &out, Cloud< Ts... > const &cloud, CloudUFOOptions const &options=CloudUFOOptions())
template<std::size_t Dim, class T , class... Ts>
bool	writeXYZ (std::filesystem::path const &file, PointCloud< Dim, T, Ts... > const &pc)
template<std::size_t Dim, class T , class... Ts>
bool	writeXYZI (std::filesystem::path const &file, PointCloud< Dim, T, Ts... > const &pc)
template<std::size_t Dim, class T , class... Ts>
bool	writeXYZN (std::filesystem::path const &file, PointCloud< Dim, T, Ts... > const &pc)
template<std::size_t Dim, class T , class... Ts>
bool	writeXYZRGB (std::filesystem::path const &file, PointCloud< Dim, T, Ts... > const &pc)
template<std::floating_point T>
T	yaw (Quat< T > const &q) noexcept
	Extracts the yaw angle (rotation about the Z-axis) in radians.
template<std::size_t R, std::size_t C, class T = float>
constexpr Mat< R, C, T >	zeros () noexcept
	Returns an R × C matrix with all elements set to zero.
template<class A , class B >
constexpr auto	closestPoint (A const &a, B const &b)
	Computes the closest point on a shape to another shape.
template<class T >
constexpr int	sign (T val) noexcept
	Returns the sign of a value.
template<std::floating_point T>
constexpr T	radians (T deg) noexcept
	Converts degrees to radians.
template<std::floating_point T>
constexpr T	degrees (T rad) noexcept
	Converts radians to degrees.
template<class T > requires std::is_arithmetic_v<T>
constexpr T	ipow (T base, int exp) noexcept
	Computes integer power of a base.
template<std::floating_point T>
constexpr T	probabilityToLogit (T probability)
	Converts probability to logit value.
template<std::floating_point T>
constexpr T	logitToProbability (T logit)
	Converts logit value to probability.
std::ostream &	operator<< (std::ostream &os, OrthogonalCamera const &camera)
	Writes a human-readable summary of camera to os.
std::ostream &	operator<< (std::ostream &os, OrthogonalIntrinsics const &intrinsics)
	Writes a human-readable summary of intrinsics to os.
std::ostream &	operator<< (std::ostream &os, PerspectiveCamera const &camera)
	Writes a human-readable summary of camera to os.
std::ostream &	operator<< (std::ostream &os, PerspectiveIntrinsics const &intrinsics)
	Writes a human-readable summary of intrinsics to os.
template<Color C>
constexpr alpha_type_t< C >	alpha (C color) noexcept
	Returns the un-weighted alpha of color.
template<typename Target , Color C>
constexpr Target	alpha (C color) noexcept
	Returns the alpha of color converted to Target.
template<Color C>
constexpr add_alpha_t< C >	addAlpha (C color, alpha_type_t< C > a=init_alpha_v< C >) noexcept
	Returns a copy of color with an alpha channel set to a.
template<Color C>
constexpr remove_alpha_t< C >	removeAlpha (C color) noexcept
	Returns a copy of color with the alpha channel removed.
template<Color C> requires ColorWithAlpha<C> && FloatingPointColor<C>
constexpr C	alphaBlend (C fg, C bg) noexcept
	Blends fg over bg using standard Porter-Duff "over" compositing.
template<Color C> requires ColorWithAlpha<C> && FloatingPointColor<C>
constexpr C	premultiplyAlpha (C color) noexcept
	Returns a copy of color with each channel multiplied by its alpha value.
template<Color C> requires ColorWithAlpha<C> && FloatingPointColor<C>
constexpr C	unpremultiplyAlpha (C color) noexcept
	Returns a copy of color with each channel divided by its alpha value.
template<Color C>
constexpr C &	operator+= (C &lhs, C const &rhs)
	Adds two colors component-wise.
template<Color C>
constexpr C	operator+ (C lhs, C const &rhs)
	Adds two colors component-wise.
template<Color C>
constexpr C &	operator-= (C &lhs, C const &rhs)
	Subtracts two colors component-wise.
template<Color C>
constexpr C	operator- (C lhs, C const &rhs)
	Subtracts two colors component-wise.
template<Color C>
constexpr C &	operator*= (C &lhs, float rhs)
	Multiplies a color by a scalar.
template<Color C>
constexpr C &	operator*= (C &lhs, C const &rhs)
	Multiplies two colors component-wise.
template<Color C>
constexpr C	operator* (C lhs, C const &rhs)
	Multiplies two colors component-wise.
template<Color C>
constexpr C	operator* (C lhs, float rhs)
	Multiplies a color by a scalar.
template<Color C>
constexpr C	operator* (float lhs, C rhs)
	Multiplies a scalar by a color.
template<Color C>
constexpr C &	operator/= (C &lhs, C const &rhs)
	Divides a color by another color component-wise.
template<Color C>
constexpr C &	operator/= (C &lhs, float rhs)
	Divides a color by a scalar.
template<Color C>
constexpr C	operator/ (C lhs, C const &rhs)
	Divides two colors component-wise.
template<Color C>
constexpr C	operator/ (C lhs, float rhs)
	Divides a color by a scalar.
template<Color C>
constexpr C	operator/ (float lhs, C rhs)
	Divides a scalar by a color.
template<Color C>
constexpr C	average (C a, C const &b)
	Computes the average of two colors.
template<std::ranges::input_range R> requires Color<std::ranges::range_value_t<R>>
constexpr std::ranges::range_value_t< R >	average (R &&r)
	Computes the average of a range of colors.
template<std::input_iterator InputIt, std::sentinel_for< InputIt > Sentinel> requires Color<std::iter_value_t<InputIt>>
constexpr std::iter_value_t< InputIt >	average (InputIt first, Sentinel last)
	Computes the average of a range of colors.
template<Color C>
constexpr C	average (std::initializer_list< C > il)
	Computes the average of an initializer list of colors.
template<Color C>
constexpr C	blend (C a, C const &b, float t)
	Blends two colors using a factor t.
template<std::ranges::input_range R, std::ranges::input_range W> requires Color<std::ranges::range_value_t<R>> && std::floating_point<std::ranges::range_value_t<W>>
constexpr std::ranges::range_value_t< R >	blend (R &&r, W &&w)
	Blends multiple colors using a range of weights.
template<std::input_iterator InputIt1, std::sentinel_for< InputIt1 > Sentinel, std::input_iterator InputIt2> requires Color<std::iter_value_t<InputIt1>> && std::floating_point<std::iter_value_t<InputIt2>>
constexpr std::iter_value_t< InputIt1 >	blend (InputIt1 first, Sentinel last, InputIt2 first_weight)
	Blends multiple colors using a range of weights.
template<std::ranges::input_range R, std::floating_point T> requires Color<std::ranges::range_value_t<R>>
constexpr std::ranges::range_value_t< R >	blend (R &&r, std::initializer_list< T > w)
	Blends multiple colors using an initializer list of weights.
template<Color C, std::floating_point T>
constexpr C	blend (std::initializer_list< C > r, std::initializer_list< T > w)
	Blends multiple colors using an initializer list of colors and weights.
template<Color To, Color From>
constexpr To	convert (From const &color)
	Convert a color from one type to another.
template<typename T , Color From> requires (std::floating_point<T> || std::integral<T>)
constexpr auto	convert (From const &color)
	Convert a color from one type to another.
template<ColorFlags F, Color From>
constexpr auto	convert (From const &color)
	Convert a color from one type to another.
template<typename T , ColorFlags F, Color From> requires (std::floating_point<T> || std::integral<T>)
constexpr auto	convert (From const &color)
	Convert a color from one type to another.
template<Color From, Color To>
constexpr void	convert (From const &in, To &out)
	Convert a color from one type to another and assign to an output variable.
template<Color C, std::size_t N>
constexpr C	colorMap (std::array< C, N > const &map, float value, float min_value, float max_value)
	Maps a value to a color using a color map.
template<Color C>
constexpr weight_type_t< C >	weight (C color) noexcept
	Returns the weight of color, or 1 if color has no weight field.
template<Color C>
constexpr add_weight_t< C >	addWeight (C color, float w=1.0f) noexcept
	Returns a copy of color with a weight field set to w.
template<Color C>
constexpr remove_weight_t< C >	removeWeight (C color) noexcept
	Returns a copy of color with the weight field removed.

Variables
template<class T , class... Ts>
constexpr bool	contains_constructible_type_v
template<class T , class... Ts>
constexpr bool	contains_convertible_type_v
template<class T , class... Ts>
constexpr bool	contains_type_v = contains_type<T, Ts...>::value
template<class... T>
constexpr bool	dependent_false_v = dependent_false<T...>::value
template<class T , class... Types>
constexpr std::size_t	index_v = index<T, Types...>::value
template<class Map >
constexpr bool	is_labels_map_v = is_labels_map<Map>::value
template<class T >
constexpr bool	is_pair_v = is_pair<T>::value
template<class Map >
constexpr bool	is_semantic_set_map_v = is_semantic_set_map<Map>::value
template<template< class... > class T, class... Us>
constexpr bool	is_specialization_of_v = is_specialization_of<T, Us...>::value
template<class T >
constexpr bool	is_string_v = is_string<T>::value
template<class T >
constexpr bool	is_tuple_v = is_tuple<T>::value
template<class T , class... Rest>
constexpr bool	is_unique_v = is_unique<T, Rest...>::value
static constexpr PolynomialSensorError const	KinectV1ErrorFunction
static constexpr ExponentialSensorError const	KinectV2ErrorFunction {0.0005877f, 0.9925f}
template<class T >
constexpr ScalarType	scalar_type_v = detail::scalarTypeOf<T>()
	The ScalarType enumerator for T, or ScalarType::UNKNOWN if T is not a recognised scalar type.
static constexpr ExponentialSensorError const	ZEDErrorFunction {0.007437f, 0.3855f}
enum class	ColorDeltaE { EUCLIDEAN , OK }
template<Color C>
constexpr float	deltaEEuclideanSquared (C const &color, C const &sample)
	Computes the squared Euclidean distance between two colors.
template<Color C>
constexpr float	deltaEEuclidean (C const &color, C const &sample)
	Computes the Euclidean distance between two colors.
template<Color C>
constexpr float	deltaEOkSquared (C const &color, C const &sample, float const ab_scale=2.0f)
	Computes the squared Ok delta E distance between two colors.
template<Color C>
constexpr float	deltaEOk (C const &color, C const &sample, float const ab_scale=2.0f)
	Computes the Ok delta E distance between two colors.
template<Color C>
constexpr float	deltaESquared (C const &color, C const &sample, ColorDeltaE method=ColorDeltaE::EUCLIDEAN, ColorSpace space=ColorSpace::NATIVE)
	Computes the squared distance between two colors using a specified method.
template<Color C>
constexpr float	deltaE (C const &color, C const &sample, ColorDeltaE method=ColorDeltaE::EUCLIDEAN, ColorSpace space=ColorSpace::NATIVE)
	Computes the distance between two colors using a specified method.
enum class	ColorFlags : std::uint8_t { ColorFlags::None = 0 , ColorFlags::Alpha = 1 << 0 , ColorFlags::Weight = 1 << 1 , ColorFlags::All = Alpha | Weight }
	Bitmask controlling optional fields in a Color specialisation. More...
constexpr ColorFlags	operator| (ColorFlags a, ColorFlags b) noexcept
	Bitwise OR for combining ColorFlags.
constexpr ColorFlags	operator& (ColorFlags a, ColorFlags b) noexcept
	Bitwise AND for testing ColorFlags.
constexpr ColorFlags	operator~ (ColorFlags a) noexcept
	Bitwise complement - inverts all valid ColorFlags bits.
consteval bool	alphaset (ColorFlags flags) noexcept
	Returns true if the Alpha flag is set.
consteval bool	weightset (ColorFlags flags) noexcept
	Returns true if the Weight flag is set.
constexpr std::string_view	toString (ColorFlags flags) noexcept
	Returns a human-readable string for a ColorFlags value.
std::ostream &	operator<< (std::ostream &os, ColorFlags flags)
	Stream-insertion operator for ColorFlags.
enum class	ColorSpace {   NATIVE , Rgb , Oklab , Oklab2 ,   Oklch }
	Selects the working color space for color operations. More...
constexpr std::string_view	toString (ColorSpace cs) noexcept
	Returns a human-readable name for cs.
std::ostream &	operator<< (std::ostream &out, ColorSpace cs)
	Writes the color-space name to out.
enum class	ColorModel {   Gray , Lab , Lch , Lrgb ,   Rgb }
	Tag identifying the color model of a color type. More...
template<class... Ts>
using	first_color_t = typename first_color< Ts... >::type
template<class T >
using	value_type_t = typename color_traits< T >::value_type
	Extracts the channel scalar type of a color.
template<class T >
using	alpha_type_t = typename color_traits< T >::value_type
	Extracts the alpha scalar type of a color.
template<class T >
using	add_alpha_t = typename color_traits< T >::template rebind_flags< color_traits< T >::flags|ColorFlags::Alpha >
	Adds ColorFlags::Alpha to a color type.
template<class T >
using	remove_alpha_t = typename color_traits< T >::template rebind_flags< color_traits< T >::flags &~ColorFlags::Alpha >
	Removes ColorFlags::Alpha from a color type.
template<class T >
using	weight_type_t = typename color_traits< T >::weight_type
	Extracts the weight scalar type of a color.
template<class T >
using	add_weight_t = typename color_traits< T >::template rebind_flags< color_traits< T >::flags|ColorFlags::Weight >
	Adds ColorFlags::Weight to a color type.
template<class T >
using	remove_weight_t = typename color_traits< T >::template rebind_flags< color_traits< T >::flags &~ColorFlags::Weight >
	Removes ColorFlags::Weight from a color type.
template<class T >
constexpr bool	is_color_v = is_color<T>::value
template<class... Ts>
constexpr bool	contains_color_v = contains_color<Ts...>::value
template<class T >
constexpr bool	has_alpha_v = has_alpha<T>::value
template<class T >
constexpr auto	init_alpha_v = init_alpha<T>::value
template<class T >
constexpr bool	has_weight_v = has_weight<T>::value
using	SmallGray = Gray< std::uint8_t >
	8-bit grayscale color.
using	SmallGrayA = Gray< std::uint8_t, ColorFlags::Alpha >
	8-bit grayscale color with alpha.
using	SmallGrayW = Gray< std::uint8_t, ColorFlags::Weight >
	8-bit grayscale color with weight.
using	SmallGrayAW = Gray< std::uint8_t, ColorFlags::Alpha|ColorFlags::Weight >
	8-bit grayscale color with alpha and weight.
using	FineGray = Gray< float >
	Floating-point grayscale color.
using	FineGrayA = Gray< float, ColorFlags::Alpha >
	Floating-point grayscale color with alpha.
using	FineGrayW = Gray< float, ColorFlags::Weight >
	Floating-point grayscale color with weight.
using	FineGrayAW = Gray< float, ColorFlags::Alpha|ColorFlags::Weight >
	Floating-point grayscale color with alpha and weight.
template<class T , ColorFlags Flags>
constexpr T	gray (Gray< T, Flags > color) noexcept
	Returns the un-weighted gray channel value.
template<class T , ColorFlags Flags>
std::ostream &	operator<< (std::ostream &out, Gray< T, Flags > const &c)
	Writes a human-readable representation of c to out.
using	SmallLab = Lab< std::uint8_t >
	8-bit Oklab color.
using	SmallLabA = Lab< std::uint8_t, ColorFlags::Alpha >
	8-bit Oklab color with alpha.
using	SmallLabW = Lab< std::uint8_t, ColorFlags::Weight >
	8-bit Oklab color with weight.
using	SmallLabAW = Lab< std::uint8_t, ColorFlags::Alpha|ColorFlags::Weight >
	8-bit Oklab color with alpha and weight.
using	FineLab = Lab< float >
	Floating-point Oklab color.
using	FineLabA = Lab< float, ColorFlags::Alpha >
	Floating-point Oklab color with alpha.
using	FineLabW = Lab< float, ColorFlags::Weight >
	Floating-point Oklab color with weight.
using	FineLabAW = Lab< float, ColorFlags::Alpha|ColorFlags::Weight >
	Floating-point Oklab color with alpha and weight.
template<class T , ColorFlags Flags>
constexpr T	lightness (Lab< T, Flags > color) noexcept
	Returns the un-weighted lightness value.
template<class T , ColorFlags Flags>
constexpr T	a (Lab< T, Flags > color) noexcept
	Returns the un-weighted green–red axis value.
template<class T , ColorFlags Flags>
constexpr T	b (Lab< T, Flags > color) noexcept
	Returns the un-weighted blue–yellow axis value.
template<class T , ColorFlags Flags>
std::ostream &	operator<< (std::ostream &out, Lab< T, Flags > const &c)
	Writes a human-readable representation of c to out.
using	SmallLch = Lch< std::uint8_t >
	8-bit OkLch color.
using	SmallLchA = Lch< std::uint8_t, ColorFlags::Alpha >
	8-bit OkLch color with alpha.
using	SmallLchW = Lch< std::uint8_t, ColorFlags::Weight >
	8-bit OkLch color with weight.
using	SmallLchAW = Lch< std::uint8_t, ColorFlags::Alpha|ColorFlags::Weight >
	8-bit OkLch color with alpha and weight.
using	FineLch = Lch< float >
	Floating-point OkLch color.
using	FineLchA = Lch< float, ColorFlags::Alpha >
	Floating-point OkLch color with alpha.
using	FineLchW = Lch< float, ColorFlags::Weight >
	Floating-point OkLch color with weight.
using	FineLchAW = Lch< float, ColorFlags::Alpha|ColorFlags::Weight >
	Floating-point OkLch color with alpha and weight.
template<class T , ColorFlags Flags>
constexpr T	lightness (Lch< T, Flags > color) noexcept
	Returns the un-weighted lightness value.
template<class T , ColorFlags Flags>
constexpr T	chroma (Lch< T, Flags > color) noexcept
	Returns the un-weighted chroma value.
template<class T , ColorFlags Flags>
constexpr T	hue (Lch< T, Flags > color) noexcept
	Returns the un-weighted hue angle value.
template<class T , ColorFlags Flags>
std::ostream &	operator<< (std::ostream &out, Lch< T, Flags > const &c)
	Writes a human-readable representation of c to out.
using	SmallLrgb = Lrgb< std::uint8_t >
	8-bit linear RGB color.
using	SmallLrgbA = Lrgb< std::uint8_t, ColorFlags::Alpha >
	8-bit linear RGB color with alpha.
using	SmallLrgbW = Lrgb< std::uint8_t, ColorFlags::Weight >
	8-bit linear RGB color with weight.
using	SmallLrgbAW = Lrgb< std::uint8_t, ColorFlags::Alpha|ColorFlags::Weight >
	8-bit linear RGB color with alpha and weight.
using	FineLrgb = Lrgb< float >
	Floating-point linear RGB color.
using	FineLrgbA = Lrgb< float, ColorFlags::Alpha >
	Floating-point linear RGB color with alpha.
using	FineLrgbW = Lrgb< float, ColorFlags::Weight >
	Floating-point linear RGB color with weight.
using	FineLrgbAW = Lrgb< float, ColorFlags::Alpha|ColorFlags::Weight >
	Floating-point linear RGB color with alpha and weight.
template<class T , ColorFlags Flags>
constexpr T	red (Lrgb< T, Flags > color) noexcept
	Returns the un-weighted red channel value.
template<class T , ColorFlags Flags>
constexpr T	green (Lrgb< T, Flags > color) noexcept
	Returns the un-weighted green channel value.
template<class T , ColorFlags Flags>
constexpr T	blue (Lrgb< T, Flags > color) noexcept
	Returns the un-weighted blue channel value.
template<class T , ColorFlags Flags>
std::ostream &	operator<< (std::ostream &out, Lrgb< T, Flags > const &c)
	Writes a human-readable representation of c to out.
using	SmallRgb = Rgb< std::uint8_t >
	8-bit sRGB color.
using	SmallRgbA = Rgb< std::uint8_t, ColorFlags::Alpha >
	8-bit sRGB color with alpha.
using	SmallRgbW = Rgb< std::uint8_t, ColorFlags::Weight >
	8-bit sRGB color with weight.
using	SmallRgbAW = Rgb< std::uint8_t, ColorFlags::Alpha|ColorFlags::Weight >
	8-bit sRGB color with alpha and weight.
using	FineRgb = Rgb< float >
	Floating-point sRGB color.
using	FineRgbA = Rgb< float, ColorFlags::Alpha >
	Floating-point sRGB color with alpha.
using	FineRgbW = Rgb< float, ColorFlags::Weight >
	Floating-point sRGB color with weight.
using	FineRgbAW = Rgb< float, ColorFlags::Alpha|ColorFlags::Weight >
	Floating-point sRGB color with alpha and weight.
template<class T , ColorFlags Flags>
constexpr T	red (Rgb< T, Flags > color) noexcept
	Returns the un-weighted red channel value.
template<class T , ColorFlags Flags>
constexpr T	green (Rgb< T, Flags > color) noexcept
	Returns the un-weighted green channel value.
template<class T , ColorFlags Flags>
constexpr T	blue (Rgb< T, Flags > color) noexcept
	Returns the un-weighted blue channel value.
template<class T , ColorFlags Flags>
std::ostream &	operator<< (std::ostream &out, Rgb< T, Flags > const &c)
	Writes a human-readable representation of c to out.
using	ImageSmallGray = Image< SmallGray >
	An image with 8-bit per channel gray pixels.
using	ImageFineGray = Image< FineGray >
	An image with 32-bit per channel gray pixels.
using	ImageSmallRgb = Image< SmallRgb >
	An image with 8-bit per channel RGB pixels.
using	ImageSmallRgbA = Image< SmallRgbA >
	An image with 8-bit per channel RGBA pixels.
using	ImageFineRgb = Image< FineRgb >
	An image with 32-bit per channel RGB pixels.
using	ImageFineRgbA = Image< FineRgbA >
	An image with 32-bit per channel RGBA pixels.
template<class T >
void	swap (Image< T > &lhs, Image< T > &rhs) noexcept
	Swaps two images in O(1).
template<class From , class To >
void	convert (Image< From > const &src, Image< To > &dest)
	Converts an image from one pixel type to another (in-place output).
template<class To , class From >
Image< To >	convert (Image< From > const &image)
	Converts an image from one pixel type to another, returning the result.

Detailed Description

All vision-related classes and functions.

UFOMap: An Efficient Probabilistic 3D Mapping Framework That Embraces the Unknown

Author

Daniel Duberg (ddube.nosp@m.rg@k.nosp@m.th.se)

See also

https://github.com/UnknownFreeOccupied/ufomap

Version

1.0

Date

2022-05-13

Copyright

Copyright (c) 2022, Daniel Duberg, KTH Royal Institute of Technology

BSD 3-Clause License

Copyright (c) 2022, Daniel Duberg, KTH Royal Institute of Technology All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Author

Daniel Duberg (danie.nosp@m.ldub.nosp@m.erg@g.nosp@m.mail.nosp@m..com)

See also

https://github.com/UnknownFreeOccupied/ufo

Version

1.0

Date

2026-02-22

Copyright

Copyright (c) 2020-2026, Daniel Duberg

BSD 3-Clause License

Copyright (c) 2020-2026, Daniel Duberg All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

UFOMap: An Efficient Probabilistic 3D Mapping Framework That Embraces the Unknown

Author

Daniel Duberg (ddube.nosp@m.rg@k.nosp@m.th.se), Ramona Häuselmann (ramon.nosp@m.aha@.nosp@m.kth.s.nosp@m.e)

See also

https://github.com/UnknownFreeOccupied/ufomap

Version

1.0

Date

2022-05-13

Copyright

Copyright (c) 2022, Daniel Duberg, KTH Royal Institute of Technology

BSD 3-Clause License

Copyright (c) 2022, Daniel Duberg, KTH Royal Institute of Technology All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

UFOMap: An Efficient Probabilistic 3D Mapping Framework That Embraces the Unknown

Author

Daniel Duberg (ddube.nosp@m.rg@k.nosp@m.th.se)

See also

https://github.com/UnknownFreeOccupied/ufomap

Version

1.0

Date

2022-05-13

Copyright

Copyright (c) 2022, Daniel Duberg, KTH Royal Institute of Technology

BSD 3-Clause License

Copyright (c) 2022, Daniel Duberg, KTH Royal Institute of Technology All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permissesion.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

UFOMap: An Efficient Probabilistic 3D Mapping Framework That Embraces the Unknown

Author

Daniel Duberg (ddube.nosp@m.rg@k.nosp@m.th.se)

See also

https://github.com/UnknownFreeOccupied/ufomap

Version

1.0

Date

2022-05-13

Copyright

Copyright (c) 2022, Daniel Duberg, KTH Royal Institute of Technology All rights reserved.

BSD 3-Clause License

Copyright (c) 2022, Daniel Duberg, KTH Royal Institute of Technology All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Author

Daniel Duberg (danie.nosp@m.ldub.nosp@m.erg@g.nosp@m.mail.nosp@m..com)

See also

https://github.com/UnknownFreeOccupied/ufo

Version

1.0

Date

2026-02-22

Copyright

BSD 3-Clause License

Copyright (c) 2020-2026, Daniel Duberg All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Typedef Documentation

AABB1

template<std::floating_point T>

using ufo::AABB1 = typedef AABB<1, T>

Definition at line 224 of file aabb.hpp.

AABB1d

using ufo::AABB1d = typedef AABB<1, double>

Definition at line 237 of file aabb.hpp.

AABB1f

using ufo::AABB1f = typedef AABB<1, float>

Definition at line 232 of file aabb.hpp.

AABB2

template<std::floating_point T>

using ufo::AABB2 = typedef AABB<2, T>

Definition at line 226 of file aabb.hpp.

AABB2d

using ufo::AABB2d = typedef AABB<2, double>

Definition at line 238 of file aabb.hpp.

AABB2f

using ufo::AABB2f = typedef AABB<2, float>

Definition at line 233 of file aabb.hpp.

AABB3

template<std::floating_point T>

using ufo::AABB3 = typedef AABB<3, T>

Definition at line 228 of file aabb.hpp.

AABB3d

using ufo::AABB3d = typedef AABB<3, double>

Definition at line 239 of file aabb.hpp.

AABB3f

using ufo::AABB3f = typedef AABB<3, float>

Definition at line 234 of file aabb.hpp.

AABB4

template<std::floating_point T>

using ufo::AABB4 = typedef AABB<4, T>

Definition at line 230 of file aabb.hpp.

AABB4d

using ufo::AABB4d = typedef AABB<4, double>

Definition at line 240 of file aabb.hpp.

AABB4f

using ufo::AABB4f = typedef AABB<4, float>

Definition at line 235 of file aabb.hpp.

argument

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

using ufo::argument = typedef decltype(argument_helper<ArgNum>(std::declval<F>()))

Definition at line 107 of file type_traits.hpp.

argument_helper_2_t

template<std::size_t ArgNum, typename... Args>

using ufo::argument_helper_2_t = typedef typename argument_helper_2<ArgNum, Args...>::type

Definition at line 80 of file type_traits.hpp.

as_tuple_t

template<class T >

using ufo::as_tuple_t = typedef typename as_tuple<T>::type

Definition at line 161 of file type_traits.hpp.

BinaryCode

using ufo::BinaryCode = typedef TreeCode<1>

Definition at line 544 of file code.hpp.

BinaryCoord

using ufo::BinaryCoord = typedef TreeCoord<1, float>

Definition at line 159 of file coord.hpp.

BinaryKey

using ufo::BinaryKey = typedef TreeKey<1>

Definition at line 180 of file key.hpp.

BinaryNode

using ufo::BinaryNode = typedef TreeNode<1>

Definition at line 126 of file node.hpp.

BinaryTreeMap

template<class T >

using ufo::BinaryTreeMap = typedef TreeMap<1, T>

Definition at line 1259 of file tree_map.hpp.

BinaryTreeSet

using ufo::BinaryTreeSet = typedef TreeSet<1>

Definition at line 1106 of file tree_set.hpp.

Capsule1

template<std::floating_point T>

using ufo::Capsule1 = typedef Capsule<1, T>

Definition at line 206 of file capsule.hpp.

Capsule1d

using ufo::Capsule1d = typedef Capsule<1, double>

Definition at line 219 of file capsule.hpp.

Capsule1f

using ufo::Capsule1f = typedef Capsule<1, float>

Definition at line 214 of file capsule.hpp.

Capsule2

template<std::floating_point T>

using ufo::Capsule2 = typedef Capsule<2, T>

Definition at line 208 of file capsule.hpp.

Capsule2d

using ufo::Capsule2d = typedef Capsule<2, double>

Definition at line 220 of file capsule.hpp.

Capsule2f

using ufo::Capsule2f = typedef Capsule<2, float>

Definition at line 215 of file capsule.hpp.

Capsule3

template<std::floating_point T>

using ufo::Capsule3 = typedef Capsule<3, T>

Definition at line 210 of file capsule.hpp.

Capsule3d

using ufo::Capsule3d = typedef Capsule<3, double>

Definition at line 221 of file capsule.hpp.

Capsule3f

using ufo::Capsule3f = typedef Capsule<3, float>

Definition at line 216 of file capsule.hpp.

Capsule4

template<std::floating_point T>

using ufo::Capsule4 = typedef Capsule<4, T>

Definition at line 212 of file capsule.hpp.

Capsule4d

using ufo::Capsule4d = typedef Capsule<4, double>

Definition at line 222 of file capsule.hpp.

Capsule4f

using ufo::Capsule4f = typedef Capsule<4, float>

Definition at line 217 of file capsule.hpp.

Cloud

template<class... Ts>

using ufo::Cloud = typedef SoA<Ts...>

Definition at line 51 of file cloud.hpp.

ColorMap

using ufo::ColorMap = typedef ColorMapT<FineLabW>

Definition at line 62 of file map.hpp.

Coord1

template<class T = float>

using ufo::Coord1 = typedef TreeCoord<1, T>

Definition at line 165 of file coord.hpp.

Coord1d

using ufo::Coord1d = typedef TreeCoord<1, double>

Definition at line 178 of file coord.hpp.

Coord1f

using ufo::Coord1f = typedef TreeCoord<1, float>

Definition at line 173 of file coord.hpp.

Coord2

template<class T = float>

using ufo::Coord2 = typedef TreeCoord<2, T>

Definition at line 167 of file coord.hpp.

Coord2d

using ufo::Coord2d = typedef TreeCoord<2, double>

Definition at line 179 of file coord.hpp.

Coord2f

using ufo::Coord2f = typedef TreeCoord<2, float>

Definition at line 174 of file coord.hpp.

Coord3

template<class T = float>

using ufo::Coord3 = typedef TreeCoord<3, T>

Definition at line 169 of file coord.hpp.

Coord3d

using ufo::Coord3d = typedef TreeCoord<3, double>

Definition at line 180 of file coord.hpp.

Coord3f

using ufo::Coord3f = typedef TreeCoord<3, float>

Definition at line 175 of file coord.hpp.

Coord4

template<class T = float>

using ufo::Coord4 = typedef TreeCoord<4, T>

Definition at line 171 of file coord.hpp.

Coord4d

using ufo::Coord4d = typedef TreeCoord<4, double>

Definition at line 181 of file coord.hpp.

Coord4f

using ufo::Coord4f = typedef TreeCoord<4, float>

Definition at line 176 of file coord.hpp.

Cylinder1

template<std::floating_point T>

using ufo::Cylinder1 = typedef Cylinder<1, T>

Definition at line 235 of file cylinder.hpp.

Cylinder1d

using ufo::Cylinder1d = typedef Cylinder<1, double>

Definition at line 248 of file cylinder.hpp.

Cylinder1f

using ufo::Cylinder1f = typedef Cylinder<1, float>

Definition at line 243 of file cylinder.hpp.

Cylinder2

template<std::floating_point T>

using ufo::Cylinder2 = typedef Cylinder<2, T>

Definition at line 237 of file cylinder.hpp.

Cylinder2d

using ufo::Cylinder2d = typedef Cylinder<2, double>

Definition at line 249 of file cylinder.hpp.

Cylinder2f

using ufo::Cylinder2f = typedef Cylinder<2, float>

Definition at line 244 of file cylinder.hpp.

Cylinder3

template<std::floating_point T>

using ufo::Cylinder3 = typedef Cylinder<3, T>

Definition at line 239 of file cylinder.hpp.

Cylinder3d

using ufo::Cylinder3d = typedef Cylinder<3, double>

Definition at line 250 of file cylinder.hpp.

Cylinder3f

using ufo::Cylinder3f = typedef Cylinder<3, float>

Definition at line 245 of file cylinder.hpp.

Cylinder4

template<std::floating_point T>

using ufo::Cylinder4 = typedef Cylinder<4, T>

Definition at line 241 of file cylinder.hpp.

Cylinder4d

using ufo::Cylinder4d = typedef Cylinder<4, double>

Definition at line 251 of file cylinder.hpp.

Cylinder4f

using ufo::Cylinder4f = typedef Cylinder<4, float>

Definition at line 246 of file cylinder.hpp.

DistanceMapFast

template<class Derived , class Tree >

using ufo::DistanceMapFast = typedef DistanceMap<Derived, Tree, true>

Definition at line 1209 of file map.hpp.

DistanceMapSmall

template<class Derived , class Tree >

using ufo::DistanceMapSmall = typedef DistanceMap<Derived, Tree, false>

Definition at line 1212 of file map.hpp.

Ellipsoid1

template<std::floating_point T>

using ufo::Ellipsoid1 = typedef Ellipsoid<1, T>

Definition at line 217 of file ellipsoid.hpp.

Ellipsoid1d

using ufo::Ellipsoid1d = typedef Ellipsoid<1, double>

Definition at line 230 of file ellipsoid.hpp.

Ellipsoid1f

using ufo::Ellipsoid1f = typedef Ellipsoid<1, float>

Definition at line 225 of file ellipsoid.hpp.

Ellipsoid2

template<std::floating_point T>

using ufo::Ellipsoid2 = typedef Ellipsoid<2, T>

Definition at line 219 of file ellipsoid.hpp.

Ellipsoid2d

using ufo::Ellipsoid2d = typedef Ellipsoid<2, double>

Definition at line 231 of file ellipsoid.hpp.

Ellipsoid2f

using ufo::Ellipsoid2f = typedef Ellipsoid<2, float>

Definition at line 226 of file ellipsoid.hpp.

Ellipsoid3

template<std::floating_point T>

using ufo::Ellipsoid3 = typedef Ellipsoid<3, T>

Definition at line 221 of file ellipsoid.hpp.

Ellipsoid3d

using ufo::Ellipsoid3d = typedef Ellipsoid<3, double>

Definition at line 232 of file ellipsoid.hpp.

Ellipsoid3f

using ufo::Ellipsoid3f = typedef Ellipsoid<3, float>

Definition at line 227 of file ellipsoid.hpp.

Ellipsoid4

template<std::floating_point T>

using ufo::Ellipsoid4 = typedef Ellipsoid<4, T>

Definition at line 223 of file ellipsoid.hpp.

Ellipsoid4d

using ufo::Ellipsoid4d = typedef Ellipsoid<4, double>

Definition at line 233 of file ellipsoid.hpp.

Ellipsoid4f

using ufo::Ellipsoid4f = typedef Ellipsoid<4, float>

Definition at line 228 of file ellipsoid.hpp.

FineGray

using ufo::FineGray = typedef Gray<float>

Floating-point grayscale color.

Definition at line 258 of file gray.hpp.

FineGrayA

using ufo::FineGrayA = typedef Gray<float, ColorFlags::Alpha>

Floating-point grayscale color with alpha.

Definition at line 263 of file gray.hpp.

FineGrayAW

using ufo::FineGrayAW = typedef Gray<float, ColorFlags::Alpha | ColorFlags::Weight>

Floating-point grayscale color with alpha and weight.

Definition at line 273 of file gray.hpp.

FineGrayW

using ufo::FineGrayW = typedef Gray<float, ColorFlags::Weight>

Floating-point grayscale color with weight.

Definition at line 268 of file gray.hpp.

FineLab

using ufo::FineLab = typedef Lab<float>

Floating-point Oklab color.

Definition at line 358 of file lab.hpp.

FineLabA

using ufo::FineLabA = typedef Lab<float, ColorFlags::Alpha>

Floating-point Oklab color with alpha.

Definition at line 363 of file lab.hpp.

FineLabAW

using ufo::FineLabAW = typedef Lab<float, ColorFlags::Alpha | ColorFlags::Weight>

Floating-point Oklab color with alpha and weight.

Definition at line 373 of file lab.hpp.

FineLabW

using ufo::FineLabW = typedef Lab<float, ColorFlags::Weight>

Floating-point Oklab color with weight.

Definition at line 368 of file lab.hpp.

FineLch

using ufo::FineLch = typedef Lch<float>

Floating-point OkLch color.

Definition at line 358 of file lch.hpp.

FineLchA

using ufo::FineLchA = typedef Lch<float, ColorFlags::Alpha>

Floating-point OkLch color with alpha.

Definition at line 363 of file lch.hpp.

FineLchAW

using ufo::FineLchAW = typedef Lch<float, ColorFlags::Alpha | ColorFlags::Weight>

Floating-point OkLch color with alpha and weight.

Definition at line 373 of file lch.hpp.

FineLchW

using ufo::FineLchW = typedef Lch<float, ColorFlags::Weight>

Floating-point OkLch color with weight.

Definition at line 368 of file lch.hpp.

FineLrgb

using ufo::FineLrgb = typedef Lrgb<float>

Floating-point linear RGB color.

Definition at line 357 of file lrgb.hpp.

FineLrgbA

using ufo::FineLrgbA = typedef Lrgb<float, ColorFlags::Alpha>

Floating-point linear RGB color with alpha.

Definition at line 362 of file lrgb.hpp.

FineLrgbAW

using ufo::FineLrgbAW = typedef Lrgb<float, ColorFlags::Alpha | ColorFlags::Weight>

Floating-point linear RGB color with alpha and weight.

Definition at line 372 of file lrgb.hpp.

FineLrgbW

using ufo::FineLrgbW = typedef Lrgb<float, ColorFlags::Weight>

Floating-point linear RGB color with weight.

Definition at line 367 of file lrgb.hpp.

FineRgb

using ufo::FineRgb = typedef Rgb<float>

Floating-point sRGB color.

Definition at line 357 of file rgb.hpp.

FineRgbA

using ufo::FineRgbA = typedef Rgb<float, ColorFlags::Alpha>

Floating-point sRGB color with alpha.

Definition at line 362 of file rgb.hpp.

FineRgbAW

using ufo::FineRgbAW = typedef Rgb<float, ColorFlags::Alpha | ColorFlags::Weight>

Floating-point sRGB color with alpha and weight.

Definition at line 372 of file rgb.hpp.

FineRgbW

using ufo::FineRgbW = typedef Rgb<float, ColorFlags::Weight>

Floating-point sRGB color with weight.

Definition at line 367 of file rgb.hpp.

Frustum1

template<std::floating_point T>

using ufo::Frustum1 = typedef Frustum<1, T>

Definition at line 317 of file frustum.hpp.

Frustum1d

using ufo::Frustum1d = typedef Frustum<1, double>

Definition at line 330 of file frustum.hpp.

Frustum1f

using ufo::Frustum1f = typedef Frustum<1, float>

Definition at line 325 of file frustum.hpp.

Frustum2

template<std::floating_point T>

using ufo::Frustum2 = typedef Frustum<2, T>

Definition at line 319 of file frustum.hpp.

Frustum2d

using ufo::Frustum2d = typedef Frustum<2, double>

Definition at line 331 of file frustum.hpp.

Frustum2f

using ufo::Frustum2f = typedef Frustum<2, float>

Definition at line 326 of file frustum.hpp.

Frustum3

template<std::floating_point T>

using ufo::Frustum3 = typedef Frustum<3, T>

Definition at line 321 of file frustum.hpp.

Frustum3d

using ufo::Frustum3d = typedef Frustum<3, double>

Definition at line 332 of file frustum.hpp.

Frustum3f

using ufo::Frustum3f = typedef Frustum<3, float>

Definition at line 327 of file frustum.hpp.

Frustum4

template<std::floating_point T>

using ufo::Frustum4 = typedef Frustum<4, T>

Definition at line 323 of file frustum.hpp.

Frustum4d

using ufo::Frustum4d = typedef Frustum<4, double>

Definition at line 333 of file frustum.hpp.

Frustum4f

using ufo::Frustum4f = typedef Frustum<4, float>

Definition at line 328 of file frustum.hpp.

FrustumX

template<std::size_t Dim, std::floating_point T>

using ufo::FrustumX = typedef Frustum<Dim, T>

Definition at line 314 of file frustum.hpp.

HexCode

using ufo::HexCode = typedef TreeCode<4>

Definition at line 547 of file code.hpp.

HexCoord

using ufo::HexCoord = typedef TreeCoord<4, float>

Definition at line 162 of file coord.hpp.

HexKey

using ufo::HexKey = typedef TreeKey<4>

Definition at line 183 of file key.hpp.

HexNode

using ufo::HexNode = typedef TreeNode<4>

Definition at line 129 of file node.hpp.

HextreeMap

template<class T >

using ufo::HextreeMap = typedef TreeMap<4, T>

Definition at line 1268 of file tree_map.hpp.

HextreeSet

using ufo::HextreeSet = typedef TreeSet<4>

Definition at line 1112 of file tree_set.hpp.

ImageFineGray

using ufo::ImageFineGray = typedef Image<FineGray>

An image with 32-bit per channel gray pixels.

Definition at line 632 of file image.hpp.

ImageFineRgb

using ufo::ImageFineRgb = typedef Image<FineRgb>

An image with 32-bit per channel RGB pixels.

Definition at line 644 of file image.hpp.

ImageFineRgbA

using ufo::ImageFineRgbA = typedef Image<FineRgbA>

An image with 32-bit per channel RGBA pixels.

Definition at line 648 of file image.hpp.

ImageSmallGray

using ufo::ImageSmallGray = typedef Image<SmallGray>

An image with 8-bit per channel gray pixels.

Definition at line 628 of file image.hpp.

ImageSmallRgb

using ufo::ImageSmallRgb = typedef Image<SmallRgb>

An image with 8-bit per channel RGB pixels.

Definition at line 636 of file image.hpp.

ImageSmallRgbA

using ufo::ImageSmallRgbA = typedef Image<SmallRgbA>

An image with 8-bit per channel RGBA pixels.

Definition at line 640 of file image.hpp.

index_type_t

template<std::size_t I, class... Ts>

using ufo::index_type_t = typedef typename index_type<I, Ts...>::type

Definition at line 224 of file type_traits.hpp.

Line1

template<std::floating_point T>

using ufo::Line1 = typedef Line<1, T>

Definition at line 253 of file line.hpp.

Line1d

using ufo::Line1d = typedef Line<1, double>

Definition at line 266 of file line.hpp.

Line1f

using ufo::Line1f = typedef Line<1, float>

Definition at line 261 of file line.hpp.

Line2

template<std::floating_point T>

using ufo::Line2 = typedef Line<2, T>

Definition at line 255 of file line.hpp.

Line2d

using ufo::Line2d = typedef Line<2, double>

Definition at line 267 of file line.hpp.

Line2f

using ufo::Line2f = typedef Line<2, float>

Definition at line 262 of file line.hpp.

Line3

template<std::floating_point T>

using ufo::Line3 = typedef Line<3, T>

Definition at line 257 of file line.hpp.

Line3d

using ufo::Line3d = typedef Line<3, double>

Definition at line 268 of file line.hpp.

Line3f

using ufo::Line3f = typedef Line<3, float>

Definition at line 263 of file line.hpp.

Line4

template<std::floating_point T>

using ufo::Line4 = typedef Line<4, T>

Definition at line 259 of file line.hpp.

Line4d

using ufo::Line4d = typedef Line<4, double>

Definition at line 269 of file line.hpp.

Line4f

using ufo::Line4f = typedef Line<4, float>

Definition at line 264 of file line.hpp.

LineSegment1

template<std::floating_point T>

using ufo::LineSegment1 = typedef LineSegment<1, T>

Definition at line 202 of file line_segment.hpp.

LineSegment1d

using ufo::LineSegment1d = typedef LineSegment<1, double>

Definition at line 215 of file line_segment.hpp.

LineSegment1f

using ufo::LineSegment1f = typedef LineSegment<1, float>

Definition at line 210 of file line_segment.hpp.

LineSegment2

template<std::floating_point T>

using ufo::LineSegment2 = typedef LineSegment<2, T>

Definition at line 204 of file line_segment.hpp.

LineSegment2d

using ufo::LineSegment2d = typedef LineSegment<2, double>

Definition at line 216 of file line_segment.hpp.

LineSegment2f

using ufo::LineSegment2f = typedef LineSegment<2, float>

Definition at line 211 of file line_segment.hpp.

LineSegment3

template<std::floating_point T>

using ufo::LineSegment3 = typedef LineSegment<3, T>

Definition at line 206 of file line_segment.hpp.

LineSegment3d

using ufo::LineSegment3d = typedef LineSegment<3, double>

Definition at line 217 of file line_segment.hpp.

LineSegment3f

using ufo::LineSegment3f = typedef LineSegment<3, float>

Definition at line 212 of file line_segment.hpp.

LineSegment4

template<std::floating_point T>

using ufo::LineSegment4 = typedef LineSegment<4, T>

Definition at line 208 of file line_segment.hpp.

LineSegment4d

using ufo::LineSegment4d = typedef LineSegment<4, double>

Definition at line 218 of file line_segment.hpp.

LineSegment4f

using ufo::LineSegment4f = typedef LineSegment<4, float>

Definition at line 213 of file line_segment.hpp.

Map1D

template<class... Maps>

using ufo::Map1D = typedef Map<1, Maps...>

Definition at line 57 of file ufomap.hpp.

Map2D

template<class... Maps>

using ufo::Map2D = typedef Map<2, Maps...>

Definition at line 60 of file ufomap.hpp.

Map3D

template<class... Maps>

using ufo::Map3D = typedef Map<3, Maps...>

Definition at line 63 of file ufomap.hpp.

Map4D

template<class... Maps>

using ufo::Map4D = typedef Map<4, Maps...>

Definition at line 66 of file ufomap.hpp.

Mat2d

using ufo::Mat2d = typedef Mat2<double>

Definition at line 759 of file mat.hpp.

Mat2f

using ufo::Mat2f = typedef Mat2<float>

Definition at line 758 of file mat.hpp.

Mat2x2d

using ufo::Mat2x2d = typedef Mat2d

Definition at line 767 of file mat.hpp.

Mat2x2f

using ufo::Mat2x2f = typedef Mat2f

Definition at line 766 of file mat.hpp.

Mat3

template<class T = float>

using ufo::Mat3 = typedef Mat<3, 3, T>

Definition at line 753 of file mat.hpp.

Mat3d

using ufo::Mat3d = typedef Mat3<double>

Definition at line 761 of file mat.hpp.

Mat3f

using ufo::Mat3f = typedef Mat3<float>

Definition at line 760 of file mat.hpp.

Mat3x3d

using ufo::Mat3x3d = typedef Mat3d

Definition at line 769 of file mat.hpp.

Mat3x3f

using ufo::Mat3x3f = typedef Mat3f

Definition at line 768 of file mat.hpp.

Mat4

template<class T = float>

using ufo::Mat4 = typedef Mat<4, 4, T>

Definition at line 755 of file mat.hpp.

Mat4d

using ufo::Mat4d = typedef Mat4<double>

Definition at line 763 of file mat.hpp.

Mat4f

using ufo::Mat4f = typedef Mat4<float>

Definition at line 762 of file mat.hpp.

Mat4x4d

using ufo::Mat4x4d = typedef Mat4d

Definition at line 771 of file mat.hpp.

Mat4x4f

using ufo::Mat4x4f = typedef Mat4f

Definition at line 770 of file mat.hpp.

Misses

using ufo::Misses = typedef std::vector<Miss>

Definition at line 53 of file misses.hpp.

Normal2d

using ufo::Normal2d = typedef Normal<2, double>

2D double-precision surface normal.

Definition at line 124 of file normal.hpp.

Normal2f

using ufo::Normal2f = typedef Normal<2>

2D single-precision surface normal.

Definition at line 112 of file normal.hpp.

Normal3d

using ufo::Normal3d = typedef Normal<3, double>

3D double-precision surface normal.

Definition at line 128 of file normal.hpp.

Normal3f

using ufo::Normal3f = typedef Normal<3>

3D single-precision surface normal.

Definition at line 116 of file normal.hpp.

Normal4d

using ufo::Normal4d = typedef Normal<4, double>

4D double-precision surface normal.

Definition at line 132 of file normal.hpp.

Normal4f

using ufo::Normal4f = typedef Normal<4>

4D single-precision surface normal.

Definition at line 120 of file normal.hpp.

OBB1

template<class T >

using ufo::OBB1 = typedef OBB<1, T>

Definition at line 577 of file obb.hpp.

OBB1d

using ufo::OBB1d = typedef OBB<1, double>

Definition at line 590 of file obb.hpp.

OBB1f

using ufo::OBB1f = typedef OBB<1, float>

Definition at line 585 of file obb.hpp.

OBB2

template<class T >

using ufo::OBB2 = typedef OBB<2, T>

Definition at line 579 of file obb.hpp.

OBB2d

using ufo::OBB2d = typedef OBB<2, double>

Definition at line 591 of file obb.hpp.

OBB2f

using ufo::OBB2f = typedef OBB<2, float>

Definition at line 586 of file obb.hpp.

OBB3

template<class T >

using ufo::OBB3 = typedef OBB<3, T>

Definition at line 581 of file obb.hpp.

OBB3d

using ufo::OBB3d = typedef OBB<3, double>

Definition at line 592 of file obb.hpp.

OBB3f

using ufo::OBB3f = typedef OBB<3, float>

Definition at line 587 of file obb.hpp.

OBB4

template<class T >

using ufo::OBB4 = typedef OBB<4, T>

Definition at line 583 of file obb.hpp.

OBB4d

using ufo::OBB4d = typedef OBB<4, double>

Definition at line 593 of file obb.hpp.

OBB4f

using ufo::OBB4f = typedef OBB<4, float>

Definition at line 588 of file obb.hpp.

OccupancyColorVoidRegionMap

using ufo::OccupancyColorVoidRegionMap = typedef OccupancyColorVoidRegionMapT<false>

Definition at line 66 of file map.hpp.

OccupancyColorVoidRegionMapSmall

using ufo::OccupancyColorVoidRegionMapSmall = typedef OccupancyColorVoidRegionMapT<true>

Definition at line 67 of file map.hpp.

OccupancyMap

using ufo::OccupancyMap = typedef OccupancyMapT<float>

Definition at line 62 of file map.hpp.

OccupancyMapSmall

using ufo::OccupancyMapSmall = typedef OccupancyMapT<std::int8_t>

Definition at line 63 of file map.hpp.

OccupancyMapTiny

using ufo::OccupancyMapTiny = typedef OccupancyMapT<OccupancyState>

Definition at line 64 of file map.hpp.

OctCode

using ufo::OctCode = typedef TreeCode<3>

Definition at line 546 of file code.hpp.

OctCoord

using ufo::OctCoord = typedef TreeCoord<3, float>

Definition at line 161 of file coord.hpp.

OctKey

using ufo::OctKey = typedef TreeKey<3>

Definition at line 182 of file key.hpp.

OctNode

using ufo::OctNode = typedef TreeNode<3>

Definition at line 128 of file node.hpp.

OctreeMap

template<class T >

using ufo::OctreeMap = typedef TreeMap<3, T>

Definition at line 1265 of file tree_map.hpp.

OctreeSet

using ufo::OctreeSet = typedef TreeSet<3>

Definition at line 1110 of file tree_set.hpp.

Plane3d

using ufo::Plane3d = typedef Plane<3, double>

Definition at line 206 of file plane.hpp.

Plane3f

using ufo::Plane3f = typedef Plane<3, float>

Definition at line 205 of file plane.hpp.

PointCloud

template<std::size_t Dim, class T , class... Rest>

using ufo::PointCloud = typedef Cloud<Vec<Dim, T>, Rest...>

A structure-of-arrays point cloud whose first channel is Dim-dimensional positions of scalar type T.

PointCloud is an alias for Cloud<Vec<Dim, T>, Rest...>, which stores per-point data in separate contiguous arrays (one per channel) for cache-friendly access. The position channel is always channel 0; any additional per-point attributes (colors, normals, intensities, ...) are appended as Rest....

Template Parameters

Dim	Spatial dimensionality (typically 2, 3, or 4).
T	Scalar type for position coordinates (e.g., float, double).
Rest	Additional per-point attribute types stored in separate SoA channels.

Definition at line 72 of file point_cloud.hpp.

PointCloud2d

using ufo::PointCloud2d = typedef PointCloud<2, double>

2D double-precision point cloud (positions only).

Definition at line 81 of file point_cloud.hpp.

PointCloud2f

using ufo::PointCloud2f = typedef PointCloud<2, float>

2D single-precision point cloud (positions only).

Definition at line 75 of file point_cloud.hpp.

PointCloud3d

using ufo::PointCloud3d = typedef PointCloud<3, double>

3D double-precision point cloud (positions only).

Definition at line 83 of file point_cloud.hpp.

PointCloud3f

using ufo::PointCloud3f = typedef PointCloud<3, float>

3D single-precision point cloud (positions only).

Definition at line 77 of file point_cloud.hpp.

PointCloud4d

using ufo::PointCloud4d = typedef PointCloud<4, double>

4D double-precision point cloud (positions only).

Definition at line 85 of file point_cloud.hpp.

PointCloud4f

using ufo::PointCloud4f = typedef PointCloud<4, float>

4D single-precision point cloud (positions only).

Definition at line 79 of file point_cloud.hpp.

QuadCode

using ufo::QuadCode = typedef TreeCode<2>

Definition at line 545 of file code.hpp.

QuadCoord

using ufo::QuadCoord = typedef TreeCoord<2, float>

Definition at line 160 of file coord.hpp.

QuadKey

using ufo::QuadKey = typedef TreeKey<2>

Definition at line 181 of file key.hpp.

QuadNode

using ufo::QuadNode = typedef TreeNode<2>

Definition at line 127 of file node.hpp.

QuadtreeMap

template<class T >

using ufo::QuadtreeMap = typedef TreeMap<2, T>

Definition at line 1262 of file tree_map.hpp.

QuadtreeSet

using ufo::QuadtreeSet = typedef TreeSet<2>

Definition at line 1108 of file tree_set.hpp.

Quatd

using ufo::Quatd = typedef Quat<double>

Definition at line 428 of file quat.hpp.

Ray1

template<std::floating_point T>

using ufo::Ray1 = typedef Ray<1, T>

Definition at line 192 of file ray.hpp.

Ray1d

using ufo::Ray1d = typedef Ray<1, double>

Definition at line 205 of file ray.hpp.

Ray1f

using ufo::Ray1f = typedef Ray<1, float>

Definition at line 200 of file ray.hpp.

Ray2

template<std::floating_point T>

using ufo::Ray2 = typedef Ray<2, T>

Definition at line 194 of file ray.hpp.

Ray2d

using ufo::Ray2d = typedef Ray<2, double>

Definition at line 206 of file ray.hpp.

Ray2f

using ufo::Ray2f = typedef Ray<2, float>

Definition at line 201 of file ray.hpp.

Ray3

template<std::floating_point T>

using ufo::Ray3 = typedef Ray<3, T>

Definition at line 196 of file ray.hpp.

Ray3d

using ufo::Ray3d = typedef Ray<3, double>

Definition at line 207 of file ray.hpp.

Ray3f

using ufo::Ray3f = typedef Ray<3, float>

Definition at line 202 of file ray.hpp.

Ray4

template<std::floating_point T>

using ufo::Ray4 = typedef Ray<4, T>

Definition at line 198 of file ray.hpp.

Ray4d

using ufo::Ray4d = typedef Ray<4, double>

Definition at line 208 of file ray.hpp.

Ray4f

using ufo::Ray4f = typedef Ray<4, float>

Definition at line 203 of file ray.hpp.

remove_cvref_t

template<class T >

using ufo::remove_cvref_t = typedef typename remove_cvref<T>::type

Definition at line 240 of file type_traits.hpp.

SerializedBlocks

template<std::size_t BF>

using ufo::SerializedBlocks = typedef std::vector<SerializedBlock<BF> >

Definition at line 64 of file serialized_block.hpp.

SmallGray

using ufo::SmallGray = typedef Gray<std::uint8_t>

8-bit grayscale color.

Definition at line 238 of file gray.hpp.

SmallGrayA

using ufo::SmallGrayA = typedef Gray<std::uint8_t, ColorFlags::Alpha>

8-bit grayscale color with alpha.

Definition at line 243 of file gray.hpp.

SmallGrayAW

using ufo::SmallGrayAW = typedef Gray<std::uint8_t, ColorFlags::Alpha | ColorFlags::Weight>

8-bit grayscale color with alpha and weight.

Definition at line 253 of file gray.hpp.

SmallGrayW

using ufo::SmallGrayW = typedef Gray<std::uint8_t, ColorFlags::Weight>

8-bit grayscale color with weight.

Definition at line 248 of file gray.hpp.

SmallLab

using ufo::SmallLab = typedef Lab<std::uint8_t>

8-bit Oklab color.

Definition at line 338 of file lab.hpp.

SmallLabA

using ufo::SmallLabA = typedef Lab<std::uint8_t, ColorFlags::Alpha>

8-bit Oklab color with alpha.

Definition at line 343 of file lab.hpp.

SmallLabAW

using ufo::SmallLabAW = typedef Lab<std::uint8_t, ColorFlags::Alpha | ColorFlags::Weight>

8-bit Oklab color with alpha and weight.

Definition at line 353 of file lab.hpp.

SmallLabW

using ufo::SmallLabW = typedef Lab<std::uint8_t, ColorFlags::Weight>

8-bit Oklab color with weight.

Definition at line 348 of file lab.hpp.

SmallLch

using ufo::SmallLch = typedef Lch<std::uint8_t>

8-bit OkLch color.

Definition at line 338 of file lch.hpp.

SmallLchA

using ufo::SmallLchA = typedef Lch<std::uint8_t, ColorFlags::Alpha>

8-bit OkLch color with alpha.

Definition at line 343 of file lch.hpp.

SmallLchAW

using ufo::SmallLchAW = typedef Lch<std::uint8_t, ColorFlags::Alpha | ColorFlags::Weight>

8-bit OkLch color with alpha and weight.

Definition at line 353 of file lch.hpp.

SmallLchW

using ufo::SmallLchW = typedef Lch<std::uint8_t, ColorFlags::Weight>

8-bit OkLch color with weight.

Definition at line 348 of file lch.hpp.

SmallLrgb

using ufo::SmallLrgb = typedef Lrgb<std::uint8_t>

8-bit linear RGB color.

Definition at line 337 of file lrgb.hpp.

SmallLrgbA

using ufo::SmallLrgbA = typedef Lrgb<std::uint8_t, ColorFlags::Alpha>

8-bit linear RGB color with alpha.

Definition at line 342 of file lrgb.hpp.

SmallLrgbAW

using ufo::SmallLrgbAW = typedef Lrgb<std::uint8_t, ColorFlags::Alpha | ColorFlags::Weight>

8-bit linear RGB color with alpha and weight.

Definition at line 352 of file lrgb.hpp.

SmallLrgbW

using ufo::SmallLrgbW = typedef Lrgb<std::uint8_t, ColorFlags::Weight>

8-bit linear RGB color with weight.

Definition at line 347 of file lrgb.hpp.

SmallRgb

using ufo::SmallRgb = typedef Rgb<std::uint8_t>

8-bit sRGB color.

Definition at line 337 of file rgb.hpp.

SmallRgbA

using ufo::SmallRgbA = typedef Rgb<std::uint8_t, ColorFlags::Alpha>

8-bit sRGB color with alpha.

Definition at line 342 of file rgb.hpp.

SmallRgbAW

using ufo::SmallRgbAW = typedef Rgb<std::uint8_t, ColorFlags::Alpha | ColorFlags::Weight>

8-bit sRGB color with alpha and weight.

Definition at line 352 of file rgb.hpp.

SmallRgbW

using ufo::SmallRgbW = typedef Rgb<std::uint8_t, ColorFlags::Weight>

8-bit sRGB color with weight.

Definition at line 347 of file rgb.hpp.

Sphere1

template<std::floating_point T>

using ufo::Sphere1 = typedef Sphere<1, T>

Definition at line 197 of file sphere.hpp.

Sphere1d

using ufo::Sphere1d = typedef Sphere<1, double>

Definition at line 210 of file sphere.hpp.

Sphere1f

using ufo::Sphere1f = typedef Sphere<1, float>

Definition at line 205 of file sphere.hpp.

Sphere2

template<std::floating_point T>

using ufo::Sphere2 = typedef Sphere<2, T>

Definition at line 199 of file sphere.hpp.

Sphere2d

using ufo::Sphere2d = typedef Sphere<2, double>

Definition at line 211 of file sphere.hpp.

Sphere2f

using ufo::Sphere2f = typedef Sphere<2, float>

Definition at line 206 of file sphere.hpp.

Sphere3

template<std::floating_point T>

using ufo::Sphere3 = typedef Sphere<3, T>

Definition at line 201 of file sphere.hpp.

Sphere3d

using ufo::Sphere3d = typedef Sphere<3, double>

Definition at line 212 of file sphere.hpp.

Sphere3f

using ufo::Sphere3f = typedef Sphere<3, float>

Definition at line 207 of file sphere.hpp.

Sphere4

template<std::floating_point T>

using ufo::Sphere4 = typedef Sphere<4, T>

Definition at line 203 of file sphere.hpp.

Sphere4d

using ufo::Sphere4d = typedef Sphere<4, double>

Definition at line 213 of file sphere.hpp.

Sphere4f

using ufo::Sphere4f = typedef Sphere<4, float>

Definition at line 208 of file sphere.hpp.

TraceResult2

using ufo::TraceResult2 = typedef TraceResult<2>

Definition at line 56 of file trace_result.hpp.

TraceResult3

using ufo::TraceResult3 = typedef TraceResult<3>

Definition at line 57 of file trace_result.hpp.

TraceResult4

using ufo::TraceResult4 = typedef TraceResult<4>

Definition at line 58 of file trace_result.hpp.

Transform2d

using ufo::Transform2d = typedef Transform2<double>

Definition at line 387 of file transform.hpp.

Transform2f

using ufo::Transform2f = typedef Transform2<float>

Definition at line 386 of file transform.hpp.

Transform3

template<std::floating_point T = float>

using ufo::Transform3 = typedef Transform<3, T>

Definition at line 384 of file transform.hpp.

Transform3d

using ufo::Transform3d = typedef Transform3<double>

Definition at line 389 of file transform.hpp.

Transform3f

using ufo::Transform3f = typedef Transform3<float>

Definition at line 388 of file transform.hpp.

Triangle1

template<std::floating_point T>

using ufo::Triangle1 = typedef Triangle<1, T>

Definition at line 228 of file triangle.hpp.

Triangle1d

using ufo::Triangle1d = typedef Triangle<1, double>

Definition at line 241 of file triangle.hpp.

Triangle1f

using ufo::Triangle1f = typedef Triangle<1, float>

Definition at line 236 of file triangle.hpp.

Triangle2

template<std::floating_point T>

using ufo::Triangle2 = typedef Triangle<2, T>

Definition at line 230 of file triangle.hpp.

Triangle2d

using ufo::Triangle2d = typedef Triangle<2, double>

Definition at line 242 of file triangle.hpp.

Triangle2f

using ufo::Triangle2f = typedef Triangle<2, float>

Definition at line 237 of file triangle.hpp.

Triangle3

template<std::floating_point T>

using ufo::Triangle3 = typedef Triangle<3, T>

Definition at line 232 of file triangle.hpp.

Triangle3d

using ufo::Triangle3d = typedef Triangle<3, double>

Definition at line 243 of file triangle.hpp.

Triangle3f

using ufo::Triangle3f = typedef Triangle<3, float>

Definition at line 238 of file triangle.hpp.

Triangle4

template<std::floating_point T>

using ufo::Triangle4 = typedef Triangle<4, T>

Definition at line 234 of file triangle.hpp.

Triangle4d

using ufo::Triangle4d = typedef Triangle<4, double>

Definition at line 244 of file triangle.hpp.

Triangle4f

using ufo::Triangle4f = typedef Triangle<4, float>

Definition at line 239 of file triangle.hpp.

Vec1d

using ufo::Vec1d = typedef Vec<1, double>

Definition at line 518 of file vec.hpp.

Vec1f

using ufo::Vec1f = typedef Vec<1, float>

Definition at line 514 of file vec.hpp.

Vec1i

using ufo::Vec1i = typedef Vec<1, int>

Definition at line 506 of file vec.hpp.

Vec1u

using ufo::Vec1u = typedef Vec<1, unsigned>

Definition at line 510 of file vec.hpp.

Vec2b

using ufo::Vec2b = typedef Vec<2, bool>

Definition at line 503 of file vec.hpp.

Vec2d

using ufo::Vec2d = typedef Vec<2, double>

Definition at line 519 of file vec.hpp.

Vec2f

using ufo::Vec2f = typedef Vec<2, float>

Definition at line 515 of file vec.hpp.

Vec2i

using ufo::Vec2i = typedef Vec<2, int>

Definition at line 507 of file vec.hpp.

Vec2u

using ufo::Vec2u = typedef Vec<2, unsigned>

Definition at line 511 of file vec.hpp.

Vec3b

using ufo::Vec3b = typedef Vec<3, bool>

Definition at line 504 of file vec.hpp.

Vec3d

using ufo::Vec3d = typedef Vec<3, double>

Definition at line 520 of file vec.hpp.

Vec3f

using ufo::Vec3f = typedef Vec<3, float>

Definition at line 516 of file vec.hpp.

Vec3i

using ufo::Vec3i = typedef Vec<3, int>

Definition at line 508 of file vec.hpp.

Vec3u

using ufo::Vec3u = typedef Vec<3, unsigned>

Definition at line 512 of file vec.hpp.

Vec4b

using ufo::Vec4b = typedef Vec<4, bool>

Definition at line 505 of file vec.hpp.

Vec4d

using ufo::Vec4d = typedef Vec<4, double>

Definition at line 521 of file vec.hpp.

Vec4f

using ufo::Vec4f = typedef Vec<4, float>

Definition at line 517 of file vec.hpp.

Vec4i

using ufo::Vec4i = typedef Vec<4, int>

Definition at line 509 of file vec.hpp.

Vec4u

using ufo::Vec4u = typedef Vec<4, unsigned>

Definition at line 513 of file vec.hpp.

Enumeration Type Documentation

CostPropagationCriteria

enum class ufo::CostPropagationCriteria

strong

Definition at line 47 of file propagation_criteria.hpp.

CountSamplingMethod

enum class ufo::CountSamplingMethod

strong

Definition at line 47 of file count_sampling_method.hpp.

DistanceInterpolate

enum class ufo::DistanceInterpolate

strong

Definition at line 47 of file interpolate.hpp.

DownSamplingMethod

enum class ufo::DownSamplingMethod

strong

Definition at line 76 of file integrator.hpp.

FileType

enum class ufo::FileType

strong

Enumerates all file formats supported by the UFO I/O subsystem.

Used as a discriminator by format-dispatch routines to select the correct reader / writer without inspecting the file extension more than once.

Enumerator	Extension(s)	Description
UNKNOWN	—	Unrecognised or missing extension.
UFO	.ufo	Native UFOMap binary format.
XYZ	.xyz	ASCII XYZ point cloud (x y z per line).
XYZI	.xyzi	ASCII XYZ + intensity.
XYZN	.xyzn	ASCII XYZ + surface normal (nx ny nz).
XYZRGB	.xyzrgb	ASCII XYZ + RGB colour (r g b).
PTS	.pts	Leica PTX/PTS point cloud.
PLY	.ply	Stanford Triangle Format (polygon/point mesh).
PCD	.pcd	PCL Point Cloud Data format.
OBJ	.obj	Wavefront OBJ mesh/point format.
JPEG	.jpeg, .jpg	JPEG compressed image.
PNG	.png	PNG lossless compressed image.
QTP	.qtp	UFO quantised-tree point-cloud format.

See also

fileType()

Enumerator
UNKNOWN	Unrecognised or missing file extension.
UFO	Native UFOMap binary format (.ufo).
XYZ	ASCII XYZ point cloud (.xyz).
XYZI	ASCII XYZ + intensity (.xyzi).
XYZN	ASCII XYZ + surface normal (.xyzn).
XYZRGB	ASCII XYZ + RGB colour (.xyzrgb).
PTS	Leica PTS point cloud (.pts).
PLY	Stanford PLY mesh / point cloud (.ply).
PCD	PCL Point Cloud Data (.pcd).
OBJ	Wavefront OBJ (.obj).
JPEG	JPEG compressed image (.jpeg, .jpg).
PNG	PNG lossless image (.png).
QTP	UFO quantised-tree point-cloud format (.qtp).

Definition at line 74 of file file_type.hpp.

IODir

enum class ufo::IODir

strong

Definition at line 47 of file dir.hpp.

LabelsPropagationCriteria

enum class ufo::LabelsPropagationCriteria

strong

Definition at line 47 of file propagation_criteria.hpp.

MapType

enum class ufo::MapType : std::uint64_t

strong

Definition at line 58 of file type.hpp.

MapUtility

enum class ufo::MapUtility : std::uint64_t

strong

Definition at line 53 of file utility.hpp.

NearestSearchAlgorithm

enum class ufo::NearestSearchAlgorithm

strong

Definition at line 91 of file tree.hpp.

OccupancyPropagationCriteria

enum class ufo::OccupancyPropagationCriteria

strong

Definition at line 47 of file propagation_criteria.hpp.

OccupancyState

enum class ufo::OccupancyState : std::int8_t

strong

Definition at line 53 of file state.hpp.

ScalarType

enum class ufo::ScalarType : std::uint8_t

strong

Tag identifying the primitive scalar type of a data channel.

Used at runtime to describe the underlying C++ type without requiring template parameters. UNKNOWN is the sentinel for unrecognised types.

Enumerator
INT8	Signed 8-bit integer (std::int8_t).
UINT8	Unsigned 8-bit integer (std::uint8_t).
INT16	Signed 16-bit integer (std::int16_t).
UINT16	Unsigned 16-bit integer (std::uint16_t).
INT32	Signed 32-bit integer (std::int32_t).
UINT32	Unsigned 32-bit integer (std::uint32_t).
INT64	Signed 64-bit integer (std::int64_t).
UINT64	Unsigned 64-bit integer (std::uint64_t).
FLOAT32	32-bit IEEE 754 floating-point (float).
FLOAT64	64-bit IEEE 754 floating-point (double).
UNKNOWN	Unrecognised or unsupported type.

Definition at line 61 of file scalar_type.hpp.

Function Documentation

a()

template<class T , ColorFlags Flags>

constexpr T ufo::a ( Lab< T, Flags >  color )

constexprnoexcept

Returns the un-weighted green–red axis value.

For floating-point weighted colors the raw a field is divided by weight; for all other combinations the raw field is returned as-is.

Definition at line 310 of file lab.hpp.

abs()

template<std::size_t Dim, class T >

constexpr Vec< Dim, T > ufo::abs ( Vec< Dim, T >  v )

constexprnoexcept

Returns the component-wise absolute value of a vector.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]

v

The vector.

Returns

A vector whose each element is abs(v[i]).

Definition at line 1351 of file vec.hpp.

addAlpha()

template<Color C>

constexpr add_alpha_t< C > ufo::addAlpha ( C  color, alpha_type_t< C >  a = init_alpha_v<C>  )

constexprnoexcept

Returns a copy of color with an alpha channel set to a.

If color already carries an alpha channel it is returned unchanged and a is ignored. For weighted floating-point colors the stored alpha field is pre-multiplied by the existing weight.

Definition at line 142 of file alpha.hpp.

all()

template<std::size_t Dim>

constexpr bool ufo::all ( Vec< Dim, bool > const &  v )

constexprnoexcept

Returns true if all components of a bool vector are true.

Template Parameters

Dim	Number of dimensions.

Parameters

[in]

v

The bool vector.

Returns

true iff every element is true.

Definition at line 1548 of file vec.hpp.

all_of() [1/2]

template<ufo::execution::ExecutionPolicy P, std::input_iterator InputIt, class UnaryPred >

bool ufo::all_of	(	P &&	policy,
		InputIt	first,
		InputIt	last,
		UnaryPred	p
	)

Checks if all elements in [first, last) satisfy p using the given execution policy.

Template Parameters

ExecutionPolicy	A UFO execution policy type.
InputIt	An input iterator type.
UnaryPred	A unary predicate type.

Parameters

[in]	policy	The execution policy controlling parallelism.
[in]	first	Iterator to the first element.
[in]	last	Iterator one past the last element.
[in]	p	Predicate to satisfy.

Returns

true if all elements satisfy p, false otherwise.

Definition at line 649 of file algorithm.hpp.

all_of() [2/2]

template<ufo::execution::ExecutionPolicy P, std::ranges::input_range Range, class UnaryPred >

bool ufo::all_of	(	P &&	policy,
		Range &&	r,
		UnaryPred	p
	)

Checks if all elements in range r satisfy p using the given execution policy.

Template Parameters

ExecutionPolicy	A UFO execution policy type.
Range	A range type.
UnaryPred	A unary predicate type.

Parameters

[in]	policy	The execution policy controlling parallelism.
[in]	r	The range of elements.
[in]	p	Predicate to satisfy.

Returns

true if all elements satisfy p, false otherwise.

Definition at line 668 of file algorithm.hpp.

alpha() [1/2]

template<Color C>

constexpr alpha_type_t< C > ufo::alpha ( C  color )

constexprnoexcept

Returns the un-weighted alpha of color.

If color has no alpha channel the default alpha is returned (1 for floating-point, std::numeric_limits<value_type>::max() for integral types). For weighted floating-point colors the stored field is divided by the weight.

Definition at line 105 of file alpha.hpp.

alpha() [2/2]

template<typename Target , Color C>

constexpr Target ufo::alpha ( C  color )

constexprnoexcept

Returns the alpha of color converted to Target.

If color has no alpha channel the default alpha for the equivalent color with Target channels is returned. Integer <-> float conversions normalise/denormalise through [0, 1].

Definition at line 124 of file alpha.hpp.

alphaBlend()

template<Color C>
requires ColorWithAlpha<C> && FloatingPointColor<C>

constexpr C ufo::alphaBlend ( C  fg, C  bg  )

constexprnoexcept

Blends fg over bg using standard Porter-Duff "over" compositing.

Both colors must satisfy ColorWithAlpha and FloatingPointColor. Returns a transparent default-initialised color if the result alpha is zero.

Definition at line 229 of file alpha.hpp.

angleAxis()

template<std::floating_point T>

constexpr Quat< T > ufo::angleAxis ( T  angle, Vec< 3, T > const &  a  )

constexprnoexcept

Constructs a unit quaternion from an angle-axis representation.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]	angle	Rotation angle in radians.
[in]	a	Unit rotation axis (must already be normalised).

Returns

Quat<T>(cos(angle/2), a * sin(angle/2)).

Definition at line 886 of file quat.hpp.

any()

template<std::size_t Dim>

constexpr bool ufo::any ( Vec< Dim, bool > const &  v )

constexprnoexcept

Returns true if at least one component of a bool vector is true.

Template Parameters

Dim	Number of dimensions.

Parameters

[in]

v

The bool vector.

Returns

true iff at least one element is true.

Definition at line 1560 of file vec.hpp.

any_of() [1/2]

template<ufo::execution::ExecutionPolicy P, std::input_iterator InputIt, class UnaryPred >

bool ufo::any_of	(	P &&	policy,
		InputIt	first,
		InputIt	last,
		UnaryPred	p
	)

Checks if any element in [first, last) satisfies p using the given execution policy.

Template Parameters

ExecutionPolicy	A UFO execution policy type.
InputIt	An input iterator type.
UnaryPred	A unary predicate type.

Parameters

[in]	policy	The execution policy controlling parallelism.
[in]	first	Iterator to the first element.
[in]	last	Iterator one past the last element.
[in]	p	Predicate to satisfy.

Returns

true if any element satisfies p, false otherwise.

Definition at line 602 of file algorithm.hpp.

any_of() [2/2]

template<ufo::execution::ExecutionPolicy P, std::ranges::input_range Range, class UnaryPred >

bool ufo::any_of	(	P &&	policy,
		Range &&	r,
		UnaryPred	p
	)

Checks if any element in range r satisfies p using the given execution policy.

Template Parameters

ExecutionPolicy	A UFO execution policy type.
Range	A range type.
UnaryPred	A unary predicate type.

Parameters

[in]	policy	The execution policy controlling parallelism.
[in]	r	The range of elements.
[in]	p	Predicate to satisfy.

Returns

true if any element satisfies p, false otherwise.

Definition at line 630 of file algorithm.hpp.

axis()

template<std::floating_point T>

Vec< 3, T > ufo::axis ( Quat< T > const &  q )

noexcept

Extracts the unit rotation axis from a unit quaternion.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]

q

Unit quaternion.

Returns

Normalised rotation axis; returns (0, 0, 1) for the identity quaternion.

Definition at line 869 of file quat.hpp.

b()

template<class T , ColorFlags Flags>

constexpr T ufo::b ( Lab< T, Flags >  color )

constexprnoexcept

Returns the un-weighted blue–yellow axis value.

For floating-point weighted colors the raw b field is divided by weight; for all other combinations the raw field is returned as-is.

Definition at line 326 of file lab.hpp.

begin() [1/2]

template<class... Ts>

constexpr auto ufo::begin ( SoA< Ts... > &  c )

constexpr

Definition at line 905 of file structure_of_arrays.hpp.

begin() [2/2]

template<class... Ts>

constexpr auto ufo::begin ( SoA< Ts... > const &  c )

constexpr

Definition at line 911 of file structure_of_arrays.hpp.

blue() [1/2]

template<class T , ColorFlags Flags>

constexpr T ufo::blue ( Lrgb< T, Flags >  color )

constexprnoexcept

Returns the un-weighted blue channel value.

For floating-point weighted colors the raw blue field is divided by weight; for all other combinations the raw field is returned as-is.

Definition at line 325 of file lrgb.hpp.

blue() [2/2]

template<class T , ColorFlags Flags>

constexpr T ufo::blue ( Rgb< T, Flags >  color )

constexprnoexcept

Returns the un-weighted blue channel value.

For floating-point weighted colors the raw blue field is divided by weight; for all other combinations the raw field is returned as-is.

Definition at line 325 of file rgb.hpp.

ceil()

template<std::size_t Dim, std::floating_point T>

constexpr Vec< Dim, T > ufo::ceil ( Vec< Dim, T >  v )

constexprnoexcept

Returns the component-wise ceiling of a floating-point vector.

Template Parameters

Dim	Number of dimensions.
T	Floating-point element type.

Parameters

[in]

v

The vector.

Returns

A vector whose each element is ceil(v[i]).

Definition at line 1390 of file vec.hpp.

chroma()

template<class T , ColorFlags Flags>

constexpr T ufo::chroma ( Lch< T, Flags >  color )

constexprnoexcept

Returns the un-weighted chroma value.

For floating-point weighted colors the raw chroma field is divided by weight; for all other combinations the raw field is returned as-is.

Definition at line 310 of file lch.hpp.

clamp()

template<std::size_t Dim, class T >

constexpr Vec< Dim, T > ufo::clamp ( Vec< Dim, T >  v, Vec< Dim, T > const &  lo, Vec< Dim, T > const &  hi  )

constexprnoexcept

Clamps each component of a vector to the range [lo[i], hi[i]].

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	v	The vector to clamp.
[in]	lo	Per-component lower bounds.
[in]	hi	Per-component upper bounds.

Returns

A vector whose each element is clamp(v[i], lo[i], hi[i]).

Definition at line 1367 of file vec.hpp.

cloudProperties()

CloudProperties ufo::cloudProperties

(

std::filesystem::path const &

file

)

Definition at line 13 of file io.cpp.

cloudPropertiesOBJ()

CloudProperties ufo::cloudPropertiesOBJ

(

std::filesystem::path const &

file

)

Definition at line 12 of file obj.cpp.

cloudPropertiesPCD()

CloudProperties ufo::cloudPropertiesPCD

(

std::filesystem::path const &

file

)

Definition at line 47 of file pcd.cpp.

cloudPropertiesPLY()

CloudProperties ufo::cloudPropertiesPLY

(

std::filesystem::path const &

file

)

Definition at line 290 of file ply.cpp.

cloudPropertiesPTS()

CloudProperties ufo::cloudPropertiesPTS

(

std::filesystem::path const &

file

)

Definition at line 12 of file pts.cpp.

cloudPropertiesUFO()

CloudProperties ufo::cloudPropertiesUFO

(

std::filesystem::path const &

file

)

Definition at line 12 of file ufo.cpp.

cloudPropertiesXYZ()

CloudProperties ufo::cloudPropertiesXYZ

(

std::filesystem::path const &

file

)

Definition at line 9 of file xyz.cpp.

cloudPropertiesXYZI()

CloudProperties ufo::cloudPropertiesXYZI

(

std::filesystem::path const &

file

)

Definition at line 9 of file xyzi.cpp.

cloudPropertiesXYZN()

CloudProperties ufo::cloudPropertiesXYZN

(

std::filesystem::path const &

file

)

Definition at line 9 of file xyzn.cpp.

cloudPropertiesXYZRGB()

CloudProperties ufo::cloudPropertiesXYZRGB

(

std::filesystem::path const &

file

)

Definition at line 9 of file xyzrgb.cpp.

computeRay() [1/3]

std::vector< OctCode > ufo::computeRay ( OctKey  origin, OctKey  goal, float  max_distance = std::numeric_limits<float>::max(), std::size_t  early_stop = 0, float  early_stop_distance = 0.0f  )

inline

Definition at line 270 of file ray_caster.hpp.

computeRay() [2/3]

void ufo::computeRay ( std::unordered_map< OctCode, IntegrationGrid< OctCode > > &  misses, std::unordered_map< OctCode, IntegrationGrid< OctCode > > const &  hits, Vec3f  origin, Vec3f  goal, OctCode  c_origin, Vec3f  voxel_border, float  grid_size, float  max_distance, unsigned  inflate_unknown, bool  ray_passthrough_hits  )

inline

Definition at line 143 of file ray_caster.hpp.

computeRay() [3/3]

void ufo::computeRay ( std::unordered_map< OctCode, IntegrationGrid< OctCode > > &  misses, Vec3f  origin, Vec3f  goal, OctCode  c_origin, Vec3f  voxel_border, float  grid_size, float  max_distance, unsigned  inflate_unknown  )

inline

Definition at line 66 of file ray_caster.hpp.

computeRaySimple() [1/5]

template<class Map >

void ufo::computeRaySimple	(	Map const &	map,
		std::unordered_map< OctCode, Grid > &	grids,
		Vec3f	origin,
		Vec3f	goal,
		depth_t	depth,
		float	step_size,
		float	max_distance = std::numeric_limits<float>::max(),
		float	early_stop_distance = 0.0f
	)

Definition at line 242 of file ray_caster.hpp.

computeRaySimple() [2/5]

std::vector< OctCode > ufo::computeRaySimple ( OctKey  origin, OctKey  goal, float  step_size_factor = 1.0f, float  max_distance = std::numeric_limits<float>::max(), std::size_t  early_stop = 0, float  early_stop_distance = 0.0f  )

inline

Definition at line 319 of file ray_caster.hpp.

computeRaySimple() [3/5]

std::vector< QuadCode > ufo::computeRaySimple ( QuadKey  origin, QuadKey  goal, float  step_size_factor = 1.0f, float  max_distance = std::numeric_limits<float>::max(), std::size_t  early_step = 0, float  early_stop_distance = 0.0f  )

inline

Definition at line 361 of file ray_caster.hpp.

computeRaySimple() [4/5]

std::vector< Vec2f > ufo::computeRaySimple ( Vec2f  origin, Vec2f  goal, float  step_size, float  max_distance = std::numeric_limits<float>::max(), std::size_t  early_stop = 0, float  early_stop_distance = 0.0f  )

inline

Definition at line 395 of file ray_caster.hpp.

computeRaySimple() [5/5]

std::vector< Vec3f > ufo::computeRaySimple ( Vec3f  origin, Vec3f  goal, float  step_size, float  max_distance = std::numeric_limits<float>::max(), std::size_t  early_stop = 0, float  early_stop_distance = 0.0f  )

inline

Definition at line 369 of file ray_caster.hpp.

conjugate()

template<std::floating_point T>

constexpr Quat< T > ufo::conjugate ( Quat< T > const &  q )

constexprnoexcept

Returns the quaternion conjugate (w, -x, -y, -z).

Template Parameters

T	Floating-point scalar type.

Parameters

[in]

q

Input quaternion.

Returns

{q.w, -q.x, -q.y, -q.z}.

Definition at line 695 of file quat.hpp.

contains() [1/2]

template<class A , class B >

constexpr bool ufo::contains ( A const &  a, B const &  b  )

constexpr

Checks if a shape contains another shape.

Template Parameters

A	The type of the shape to check.
B	The type of the shape to check against.

Parameters

[in]	a	The shape to check.
[in]	b	The shape to check against.

Return values

true	if a contains b.
false	if a does not contain b.

Note

This function is equivalent to inside(b, a).

Definition at line 63 of file contains.hpp.

contains() [2/2]

bool ufo::contains	(	std::string const &	s,
		std::string const &	sub
	)

Checks if a string contains a substring.

Parameters

s	Input string
sub	Substring

Returns

true if s contains sub

Definition at line 87 of file string.cpp.

convert() [1/3]

template<class To , class From >

Image< To > ufo::convert

(

Image< From > const &

image

)

Converts an image from one pixel type to another, returning the result.

Template Parameters

To	Destination pixel type.
From	Source pixel type (deduced).

Parameters

[in]

image

The source image.

Returns

A new Image<To> with the converted pixel data.

If From and To are the same type, the image is returned by copy directly. Otherwise, each pixel is converted element-wise using convert<To>(pixel).

Definition at line 687 of file image.hpp.

convert() [2/3]

template<class From , class To >

void ufo::convert	(	Image< From > const &	src,
		Image< To > &	dest
	)

Converts an image from one pixel type to another (in-place output).

Template Parameters

From	Source pixel type.
To	Destination pixel type.

Parameters

[in]	src	The source image.
[out]	dest	The destination image. Resized to match src dimensions.

If From and To are the same type, the image is copied directly. Otherwise, each pixel is converted element-wise using convert<To>(pixel).

Definition at line 665 of file image.hpp.

convert() [3/3]

template<class To , std::size_t Dim, class U >

constexpr To ufo::convert ( Vec< Dim, U > const &  v )

constexprnoexcept

Converts a vector to a different Vec type, truncating or zero-padding dimensions.

Template Parameters

To	Target Vec type (e.g., Vec3f).
Dim	Source number of dimensions.
U	Source element type.

Parameters

[in]

v

The source vector.

Returns

A new vector of type To, copying the overlapping dimensions.

Todo:

Ensure To is Vec

Definition at line 1059 of file vec.hpp.

corners()

template<class Geometry >

constexpr auto ufo::corners ( Geometry const &  g )

constexpr

Returns the corners of the minimum spanning axis-aligned bounding box of a geometry.

Template Parameters

Geometry

The type of the geometry.

Parameters

[in]

g

The geometry.

Returns

The corners of the minimum spanning axis-aligned bounding box.

Definition at line 86 of file fun.hpp.

count_if() [1/2]

template<ufo::execution::ExecutionPolicy P, std::input_iterator InputIt, class UnaryPred >

std::size_t ufo::count_if	(	P &&	policy,
		InputIt	first,
		InputIt	last,
		UnaryPred	p
	)

Counts elements in [first, last) satisfying p using the given execution policy.

Template Parameters

ExecutionPolicy	A UFO execution policy type.
InputIt	An input iterator type.
UnaryPred	A unary predicate type.

Parameters

[in]	policy	The execution policy controlling parallelism.
[in]	first	Iterator to the first element.
[in]	last	Iterator one past the last element.
[in]	p	Predicate to satisfy.

Returns

Number of elements satisfying p.

Definition at line 753 of file algorithm.hpp.

count_if() [2/2]

template<ufo::execution::ExecutionPolicy P, std::ranges::input_range Range, class UnaryPred >

std::size_t ufo::count_if	(	P &&	policy,
		Range &&	r,
		UnaryPred	p
	)

Counts elements in range r satisfying p using the given execution policy.

Template Parameters

ExecutionPolicy	A UFO execution policy type.
Range	A range type.
UnaryPred	A unary predicate type.

Parameters

[in]	policy	The execution policy controlling parallelism.
[in]	r	The range of elements.
[in]	p	Predicate to satisfy.

Returns

Number of elements satisfying p.

Definition at line 781 of file algorithm.hpp.

createArray()

template<std::size_t N, class T >

constexpr std::array< T, N > ufo::createArray ( T const &  value )

constexpr

Creates a std::array of size N, filled with the given value.

Template Parameters

N	The size of the array
T	The type of the array elements

Parameters

value

The value to fill the array with

Returns

std::array<T, N> filled with value

Example:

auto arr = ufo::createArray<5>(42); // arr = {42, 42, 42, 42, 42}

Definition at line 91 of file create_array.hpp.

cross() [1/2]

template<std::floating_point T>

constexpr Quat< T > ufo::cross ( Quat< T > const &  q1, Quat< T > const &  q2  )

constexprnoexcept

Computes the Hamilton cross product of two quaternions.

Identical to the quaternion Hamilton product q1 * q2.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]	q1	First quaternion.
[in]	q2	Second quaternion.

Returns

Hamilton product q1 ⊗ q2.

Definition at line 721 of file quat.hpp.

cross() [2/2]

template<class T >

constexpr Vec< 3, T > ufo::cross ( Vec< 3, T > const &  a, Vec< 3, T > const &  b  )

constexprnoexcept

Computes the cross product of two 3D vectors.

Template Parameters

T	Element type.

Parameters

[in]	a	First vector.
[in]	b	Second vector.

Returns

A vector perpendicular to both a and b with magnitude |a||b|sin(θ).

Definition at line 1179 of file vec.hpp.

disjoint()

template<class A , class B >

constexpr bool ufo::disjoint ( A const &  a, B const &  b  )

constexpr

Checks if two shapes are disjoint.

Template Parameters

A	The type of the first shape.
B	The type of the second shape.

Parameters

[in]	a	The first shape.
[in]	b	The second shape.

Return values

true	if a and b are disjoint.
false	if a and b are not disjoint.

Note

This function is equivalent to !intersects(a, b).

Definition at line 62 of file disjoint.hpp.

distance() [1/2]

template<class A , class B >

constexpr auto ufo::distance ( A const &  a, B const &  b  )

constexpr

Computes the minimum distance between two shapes.

Template Parameters

A	The type of the first shape.
B	The type of the second shape.

Parameters

[in]	a	The first shape.
[in]	b	The second shape.

Returns

The minimum distance between a and b.

Definition at line 61 of file distance.hpp.

distance() [2/2]

template<std::size_t Dim, class T >
requires std::floating_point<T>

constexpr T ufo::distance ( Vec< Dim, T > const &  a, Vec< Dim, T > const &  b  )

constexprnoexcept

Computes the Euclidean distance between two points.

Template Parameters

Dim	Number of dimensions.
T	Floating-point element type.

Parameters

[in]	a	First point.
[in]	b	Second point.

Returns

length(a - b).

Definition at line 1116 of file vec.hpp.

distanceSquared() [1/2]

template<class A , class B >

constexpr auto ufo::distanceSquared ( A const &  a, B const &  b  )

constexpr

Computes the minimum squared distance between two shapes.

Template Parameters

A	The type of the first shape.
B	The type of the second shape.

Parameters

[in]	a	The first shape.
[in]	b	The second shape.

Returns

The minimum squared distance between a and b.

Note

The squared distance is generally faster to compute than the distance. Therefore, if the relative distance is what is important then it is recommended to use this function.

Definition at line 80 of file distance.hpp.

distanceSquared() [2/2]

template<std::size_t Dim, class T >

constexpr T ufo::distanceSquared ( Vec< Dim, T > const &  a, Vec< Dim, T > const &  b  )

constexprnoexcept

Computes the squared Euclidean distance between two points.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	a	First point.
[in]	b	Second point.

Returns

dot(a - b, a - b).

Avoids the square root of distance(), making it cheaper for comparisons.

Definition at line 1132 of file vec.hpp.

dot()

template<std::size_t Dim, class T >

constexpr T ufo::dot ( Vec< Dim, T > const &  a, Vec< Dim, T > const &  b  )

constexprnoexcept

Computes the dot (inner) product of two vectors.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	a	First vector.
[in]	b	Second vector.

Returns

The scalar dot product sum(a[i] * b[i]).

Definition at line 1079 of file vec.hpp.

eigenVectors() [1/2]

template<std::floating_point T>

constexpr std::array< Vec< 3, T >, 3 > ufo::eigenVectors ( Mat< 3, 3, T > const &  m )

constexprnoexcept

Computes the eigenvectors of a real symmetric 3×3 matrix.

Each returned vector is normalized. The ordering matches eigen_values, so result[i] is the eigenvector for eigen_values[i].

Note

The computation is undefined if the covariance is degenerate (e.g. all points collinear), which may produce a zero denominator.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]

m

A real symmetric 3×3 matrix (upper triangle is read).

Returns

Array of three unit eigenvectors ordered to match eigen_values.

Definition at line 1297 of file mat.hpp.

eigenVectors() [2/2]

template<std::floating_point T>

constexpr std::array< Vec< 3, T >, 3 > ufo::eigenVectors ( Mat< 3, 3, T > const &  m, Vec< 3, T > const &  eigen_values  )

constexprnoexcept

Computes the eigenvectors of a real symmetric 3×3 matrix.

Each returned vector is normalized. The ordering matches eigen_values, so result[i] is the eigenvector for eigen_values[i].

Note

The computation is undefined if the covariance is degenerate (e.g. all points collinear), which may produce a zero denominator.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]	m	A real symmetric 3×3 matrix (upper triangle is read).
[in]	eigen_values	Pre-computed eigenvalues, e.g. from eigenValues(m).

Returns

Array of three unit eigenvectors ordered to match eigen_values.

Definition at line 1318 of file mat.hpp.

end() [1/2]

template<class... Ts>

constexpr auto ufo::end ( SoA< Ts... > &  c )

constexpr

Definition at line 917 of file structure_of_arrays.hpp.

end() [2/2]

template<class... Ts>

constexpr auto ufo::end ( SoA< Ts... > const &  c )

constexpr

Definition at line 923 of file structure_of_arrays.hpp.

endsWith()

bool ufo::endsWith	(	std::string const &	s,
		std::string const &	suffix
	)

Checks if a string ends with a given suffix.

Parameters

s	Input string
suffix	Suffix string

Returns

true if s ends with suffix

Definition at line 81 of file string.cpp.

equal()

template<std::size_t Dim, class T >

constexpr Vec< Dim, bool > ufo::equal ( Vec< Dim, T > const &  v1, Vec< Dim, T > const &  v2  )

constexprnoexcept

Returns a bool vector indicating component-wise equality.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	v1	First vector.
[in]	v2	Second vector.

Returns

A Vec<Dim, bool> where element i is v1[i] == v2[i].

Definition at line 1448 of file vec.hpp.

erase()

template<class... Ts, class U >

constexpr SoA< Ts... >::size_type ufo::erase ( SoA< Ts... > &  c, U const &  value  )

constexpr

Definition at line 935 of file structure_of_arrays.hpp.

erase_if() [1/3]

template<typename Key , typename T , class Pred >

RangeMap< Key, T >::size_type ufo::erase_if	(	RangeMap< Key, T > &	range_map,
		Pred	pred
	)

Definition at line 1204 of file range_map.hpp.

erase_if() [2/3]

template<typename Key , class Pred >

RangeSet< Key >::size_type ufo::erase_if	(	RangeSet< Key > &	range_set,
		Pred	pred
	)

Definition at line 792 of file range_set.hpp.

erase_if() [3/3]

template<class... Ts, class Pred >

constexpr SoA< Ts... >::size_type ufo::erase_if ( SoA< Ts... > &  c, Pred  pred  )

constexpr

Definition at line 944 of file structure_of_arrays.hpp.

eulerAngles()

template<std::floating_point T>

Vec< 3, T > ufo::eulerAngles ( Quat< T > const &  q )

noexcept

Returns the Euler angles (pitch, yaw, roll) in radians.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]

q

Unit quaternion.

Returns

Vec<3, T>{pitch(q), yaw(q), roll(q)}.

Definition at line 943 of file quat.hpp.

fileType()

FileType ufo::fileType

(

std::filesystem::path const &

file

)

Infers the FileType from the extension of file (case-insensitive).

The extension is extracted via std::filesystem::path::extension(), converted to lowercase, and looked up in a static map of known extensions. Both .jpeg and .jpg map to FileType::JPEG.

Parameters

file	Path whose extension determines the returned type.

Returns

The matching FileType, or FileType::UNKNOWN if the extension is not recognised.

Definition at line 31 of file file_type.cpp.

filterDistance()

template<std::size_t Dim, class T , class... Rest>

PointCloud< Dim, T, Rest... > ufo::filterDistance	(	PointCloud< Dim, T, Rest... >	pc,
		Vec< Dim, T > const &	origin,
		T const &	min_distance,
		T const &	max_distance,
		bool	filter_nan = true
	)

Returns a copy of pc with all points outside the given distance range removed.

Points are kept if and only if:

min_distance <= distance(origin, point) <= max_distance

Distance comparisons are performed on squared distances to avoid sqrt. If filter_nan is true, any point with a NaN coordinate is also removed.

Template Parameters

Dim	Spatial dimensionality.
T	Scalar type.
Rest	Additional per-point attribute types (filtered together with positions).

Parameters

pc	The source point cloud (taken by value to allow move-from).
origin	The reference point from which distances are measured.
min_distance	Minimum allowed distance (inclusive). Use T(0) for no lower bound.
max_distance	Maximum allowed distance (inclusive). Use std::numeric_limits<T>::max() for no upper bound.
filter_nan	If true, points with any NaN coordinate are removed. Defaults to true.

Returns

A new point cloud containing only points within the distance range.

Definition at line 211 of file point_cloud.hpp.

filterDistanceInPlace()

template<std::size_t Dim, class T , class... Rest>

void ufo::filterDistanceInPlace	(	PointCloud< Dim, T, Rest... > &	pc,
		Vec< Dim, T > const &	origin,
		T const &	min_distance,
		T const &	max_distance,
		bool	filter_nan = true
	)

Removes in-place all points from pc that fall outside the given distance range.

Points are kept if and only if:

min_distance <= distance(origin, point) <= max_distance

Comparisons are done on squared distances to avoid sqrt. If filter_nan is true, any point with a NaN coordinate is also erased.

If the parameters describe a no-op filter (min_distance <= 0, max_distance >= std::numeric_limits<T>::max(), and filter_nan is false), the function returns immediately without touching the cloud.

All per-point attribute channels (positions and Rest...) are erased together, preserving the SoA layout invariant.

Template Parameters

Dim	Spatial dimensionality.
T	Scalar type.
Rest	Additional per-point attribute types.

Parameters

pc	The point cloud to filter in-place.
origin	The reference point from which distances are measured.
min_distance	Minimum allowed distance (inclusive).
max_distance	Maximum allowed distance (inclusive).
filter_nan	If true, points with any NaN coordinate are removed. Defaults to true.

Definition at line 250 of file point_cloud.hpp.

find_if() [1/2]

template<ufo::execution::ExecutionPolicy P, std::random_access_iterator RandomIt, class UnaryPred >

RandomIt ufo::find_if	(	P &&	policy,
		RandomIt	first,
		RandomIt	last,
		UnaryPred	p
	)

Finds the first element in [first, last) satisfying p using the given execution policy.

Template Parameters

ExecutionPolicy	A UFO execution policy type.
RandomIt	A random-access iterator type.
UnaryPred	A unary predicate type.

Parameters

[in]	policy	The execution policy controlling parallelism.
[in]	first	Iterator to the first element.
[in]	last	Iterator one past the last element.
[in]	p	Predicate to satisfy.

Returns

Iterator to the first element that satisfies p, or last if no such element is found.

Definition at line 695 of file algorithm.hpp.

find_if() [2/2]

template<ufo::execution::ExecutionPolicy P, std::ranges::random_access_range Range, class UnaryPred >

auto ufo::find_if	(	P &&	policy,
		Range &&	r,
		UnaryPred	p
	)

Finds the first element in range r satisfying p using the given execution policy.

Template Parameters

ExecutionPolicy	A UFO execution policy type.
Range	A random-access range type.
UnaryPred	A unary predicate type.

Parameters

[in]	policy	The execution policy controlling parallelism.
[in]	r	The range to search.
[in]	p	Predicate to satisfy.

Returns

Iterator to the first element that satisfies p, or std::ranges::end(r) if no such element is found.

Definition at line 728 of file algorithm.hpp.

floor()

template<std::size_t Dim, std::floating_point T>

constexpr Vec< Dim, T > ufo::floor ( Vec< Dim, T >  v )

constexprnoexcept

Returns the component-wise floor of a floating-point vector.

Template Parameters

Dim	Number of dimensions.
T	Floating-point element type.

Parameters

[in]

v

The vector.

Returns

A vector whose each element is floor(v[i]).

Definition at line 1404 of file vec.hpp.

for_each() [1/6]

template<std::integral Index, class UnaryFunc , class Proj = std::identity>

constexpr UnaryFunc ufo::for_each ( Index  first, Index  last, UnaryFunc  f, Proj  proj = {}  )

constexpr

Applies f to each integer index in [first, last) sequentially.

Template Parameters

Index	An integral type used as the loop index.
UnaryFunc	A callable with signature compatible with void(Index).

Parameters

[in]	first	First index in the half-open range (inclusive).
[in]	last	One past the last index (exclusive).
[in]	f	Function object to invoke for each index.

Returns

The (possibly moved) function object f after all invocations.

A convenience overload that avoids manually constructing an iterator range when iterating over a contiguous index space (e.g., element indices of a flat array).

Definition at line 80 of file algorithm.hpp.

for_each() [2/6]

template<std::input_iterator InputIt, class UnaryFunc , class Proj = std::identity>

constexpr UnaryFunc ufo::for_each ( InputIt  first, InputIt  last, UnaryFunc  f, Proj  proj = {}  )

constexpr

Applies f to each element in [first, last) sequentially.

Template Parameters

InputIt	An input iterator type (must not be an integral type).
UnaryFunc	A callable with signature compatible with void(decltype(*first)).

Parameters

[in]	first	Iterator to the first element.
[in]	last	Iterator one past the last element.
[in]	f	Function object to invoke for each dereferenced element.

Returns

The (possibly moved) function object f after all invocations.

A thin wrapper around std::for_each for non-integral iterator types.

Definition at line 153 of file algorithm.hpp.

for_each() [3/6]

template<std::ranges::input_range Range, class UnaryFunc , class Proj = std::identity>
requires (!ufo::execution::ExecutionPolicy<std::remove_cvref_t<Range>>)

constexpr std::ranges::for_each_result< std::ranges::iterator_t< Range >, UnaryFunc > ufo::for_each ( Range &&  r, UnaryFunc  f, Proj  proj = {}  )

constexpr

Applies f to each element in the range r sequentially.

Template Parameters

Range	A range type.
UnaryFunc	A callable with signature compatible with void(std::ranges::range_reference_t<Range>).

Parameters

[in]	r	The range of elements to iterate over.
[in]	f	Function object to invoke for each element.

Returns

The (possibly moved) function object f after all invocations.

Definition at line 231 of file algorithm.hpp.

for_each() [4/6]

template<ufo::execution::ExecutionPolicy T, std::integral Index, class UnaryFunc , class Proj = std::identity>

void ufo::for_each	(	T &&	policy,
		Index	first,
		Index	last,
		UnaryFunc	f,
		Proj	proj = {}
	)

Applies f to each integer index in [first, last) using the given execution policy.

Template Parameters

ExecutionPolicy	A UFO execution policy type (see execution.hpp).
Index	An integral type used as the loop index.
UnaryFunc	A callable with signature compatible with void(Index).

Parameters

[in]	policy	The execution policy controlling parallelism.
[in]	first	First index in the half-open range (inclusive).
[in]	last	One past the last index (exclusive).
[in]	f	Function object to invoke for each index.

Dispatches to the appropriate parallel backend at compile time:

• STL: wraps the range in an IndexIterator and forwards to std::for_each with the translated STL execution policy.
• GCD (UFO_PAR_GCD): uses dispatch_apply on the global concurrent queue.
• TBB (UFO_PAR_TBB): uses oneapi::tbb::parallel_for.
• OMP: uses an #pragma omp parallel for loop.

Definition at line 108 of file algorithm.hpp.

for_each() [5/6]

template<ufo::execution::ExecutionPolicy T, std::random_access_iterator RandomIt, class UnaryFunc , class Proj = std::identity>

void ufo::for_each	(	T &&	policy,
		RandomIt	first,
		RandomIt	last,
		UnaryFunc	f,
		Proj	proj = {}
	)

Applies f to each element in [first, last) using the given execution policy.

Template Parameters

ExecutionPolicy	A UFO execution policy type (see execution.hpp).
RandomIt	A random-access iterator type (must not be integral).
UnaryFunc	A callable with signature compatible with void(decltype(*first)).

Parameters

[in]	policy	The execution policy controlling parallelism.
[in]	first	Iterator to the first element.
[in]	last	Iterator one past the last element.
[in]	f	Function object to invoke for each dereferenced element.

Dispatches to the appropriate parallel backend at compile time:

• STL: forwards directly to std::for_each with the translated STL policy.
• GCD (UFO_PAR_GCD): uses dispatch_apply; iterators must support random access (first[i]).
• TBB (UFO_PAR_TBB): uses oneapi::tbb::parallel_for over an index range mapped back to iterator offsets.
• OMP: uses an #pragma omp parallel for loop.

Definition at line 183 of file algorithm.hpp.

for_each() [6/6]

template<ufo::execution::ExecutionPolicy T, std::ranges::random_access_range Range, class UnaryFunc , class Proj = std::identity>

void ufo::for_each	(	T &&	policy,
		Range &&	r,
		UnaryFunc	f,
		Proj	proj = {}
	)

Applies f to each element in the range r using the given execution policy.

Template Parameters

ExecutionPolicy	A UFO execution policy type.
Range	A random-access range type.
UnaryFunc	A callable with signature compatible with void(std::ranges::range_reference_t<Range>).

Parameters

[in]	policy	The execution policy controlling parallelism.
[in]	r	The range of elements to iterate over.
[in]	f	Function object to invoke for each element.

Definition at line 248 of file algorithm.hpp.

get() [1/4]

template<std::size_t I, std::size_t Rows, std::size_t Cols, class T >
requires (I < Rows)

constexpr Vec< Cols, T > && ufo::get ( Mat< Rows, Cols, T > &&  m )

constexprnoexcept

Structured-binding accessor — rvalue reference to row I.

Template Parameters

I	Row index (must satisfy I < Rows).
Rows	Number of rows in the matrix.
Cols	Number of columns in the matrix.
T	Element type.

Parameters

[in]

m

The matrix (rvalue).

Returns

Row I as Vec<Cols, T>&&.

Definition at line 1618 of file mat.hpp.

get() [2/4]

template<std::size_t I, std::size_t Rows, std::size_t Cols, class T >
requires (I < Rows)

constexpr Vec< Cols, T > const & ufo::get ( Mat< Rows, Cols, T > const &  m )

constexprnoexcept

Structured-binding accessor — const lvalue reference to row I.

Template Parameters

I	Row index (must satisfy I < Rows).
Rows	Number of rows in the matrix.
Cols	Number of columns in the matrix.
T	Element type.

Parameters

[in]

m

The matrix.

Returns

A const reference to row I as Vec<Cols, T> const&.

Definition at line 1602 of file mat.hpp.

get() [3/4]

template<std::size_t I, std::size_t Dim, class T >
requires (I < Dim)

constexpr T && ufo::get ( Vec< Dim, T > &&  v )

constexprnoexcept

Returns an rvalue reference to the I-th element for structured bindings.

Template Parameters

I	Zero-based compile-time index (must be less than Dim).
Dim	Number of dimensions.
T	Element type.

Parameters

[in]

v

The vector (rvalue).

Returns

Rvalue reference to v[I].

Definition at line 1759 of file vec.hpp.

get() [4/4]

template<std::size_t I, std::size_t Dim, class T >
requires (I < Dim)

constexpr T const & ufo::get ( Vec< Dim, T > const &  v )

constexprnoexcept

Returns a const reference to the I-th element for structured bindings.

Template Parameters

I	Zero-based compile-time index (must be less than Dim).
Dim	Number of dimensions.
T	Element type.

Parameters

[in]

v

The vector.

Returns

Const lvalue reference to v[I].

Definition at line 1744 of file vec.hpp.

gray()

template<class T , ColorFlags Flags>

constexpr T ufo::gray ( Gray< T, Flags >  color )

constexprnoexcept

Returns the un-weighted gray channel value.

For floating-point weighted colors the raw gray field is divided by weight; for all other combinations the raw field is returned as-is.

Definition at line 226 of file gray.hpp.

greater()

template<std::size_t Dim, class T >

constexpr Vec< Dim, bool > ufo::greater ( Vec< Dim, T > const &  v1, Vec< Dim, T > const &  v2  )

constexprnoexcept

Returns a bool vector indicating component-wise greater-than.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	v1	First vector.
[in]	v2	Second vector.

Returns

A Vec<Dim, bool> where element i is v1[i] > v2[i].

Definition at line 1516 of file vec.hpp.

greaterEqual()

template<std::size_t Dim, class T >

constexpr Vec< Dim, bool > ufo::greaterEqual ( Vec< Dim, T > const &  v1, Vec< Dim, T > const &  v2  )

constexprnoexcept

Returns a bool vector indicating component-wise greater-than-or-equal.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	v1	First vector.
[in]	v2	Second vector.

Returns

A Vec<Dim, bool> where element i is v1[i] >= v2[i].

Definition at line 1533 of file vec.hpp.

green() [1/2]

template<class T , ColorFlags Flags>

constexpr T ufo::green ( Lrgb< T, Flags >  color )

constexprnoexcept

Returns the un-weighted green channel value.

For floating-point weighted colors the raw green field is divided by weight; for all other combinations the raw field is returned as-is.

Definition at line 309 of file lrgb.hpp.

green() [2/2]

template<class T , ColorFlags Flags>

constexpr T ufo::green ( Rgb< T, Flags >  color )

constexprnoexcept

Returns the un-weighted green channel value.

For floating-point weighted colors the raw green field is divided by weight; for all other combinations the raw field is returned as-is.

Definition at line 309 of file rgb.hpp.

hue()

template<class T , ColorFlags Flags>

constexpr T ufo::hue ( Lch< T, Flags >  color )

constexprnoexcept

Returns the un-weighted hue angle value.

For floating-point weighted colors the raw hue field is divided by weight; for all other combinations the raw field is returned as-is.

Definition at line 326 of file lch.hpp.

identity()

template<std::size_t N, class T = float>

constexpr Mat< N, N, T > ufo::identity ( )

constexprnoexcept

Returns an N × N identity matrix.

Template Parameters

N	Matrix dimension.
T	Element type (default: float).

Returns

An identity matrix of shape N × N.

Definition at line 1216 of file mat.hpp.

imageProperties()

ImageProperties ufo::imageProperties

(

std::filesystem::path const &

file

)

Definition at line 36 of file io.cpp.

imagePropertiesJPEG()

ImageProperties ufo::imagePropertiesJPEG

(

std::filesystem::path const &

file

)

Definition at line 134 of file jpeg.cpp.

imagePropertiesPNG()

ImageProperties ufo::imagePropertiesPNG

(

std::filesystem::path const &

file

)

Reads the metadata of a PNG file without decoding pixel data.

Opens file and parses only the IHDR chunk to extract image dimensions, bit depth, and channel configuration.

Parameters

file	Path to the PNG file.

Returns

An ImageProperties struct describing the image layout.

Exceptions

std::runtime_error

If the file cannot be opened or the IHDR chunk cannot be parsed.

Definition at line 147 of file png.cpp.

imagePropertiesQTP()

ImageProperties ufo::imagePropertiesQTP

(

std::filesystem::path const &

file

)

Definition at line 134 of file qtp.cpp.

infinitePerspective()

template<std::floating_point T>

Mat< 4, 4, T > ufo::infinitePerspective	(	T	fovy,
		T	aspect,
		T	near
	)

Builds a right-handed perspective projection matrix with an infinite far plane.

Useful for rendering techniques that require an unbounded depth range (e.g., shadow volumes, skyboxes). The far plane is pushed to infinity so depth buffer precision is concentrated near the camera.

Template Parameters

T	Floating-point element type.

Parameters

[in]	fovy	Vertical field of view in radians.
[in]	aspect	Aspect ratio (viewport width / viewport height).
[in]	near	Near clipping distance (must be positive).

Returns

A Mat<4, 4, T> representing the infinite perspective projection.

Definition at line 1509 of file mat.hpp.

inside()

template<class A , class B >

constexpr bool ufo::inside ( A const &  a, B const &  b  )

constexpr

Checks if a shape is inside another shape.

Template Parameters

A	The type of the shape to check.
B	The type of the shape to check against.

Parameters

[in]	a	The shape to check.
[in]	b	The shape to check against.

Return values

true	if a is inside b.
false	if a is not inside b.

Note

This function is equivalent to contains(b, a).

Definition at line 62 of file inside.hpp.

intersectionPoint()

template<std::size_t Dim, std::floating_point T>

constexpr Vec< Dim, T > ufo::intersectionPoint ( Line< Dim, T > const &  a, Line< Dim, T > const &  b  )

constexpr

Computes the intersection point of two lines.

Template Parameters

Dim	The dimensionality.
T	The numeric type.

Parameters

[in]	a	The first line.
[in]	b	The second line.

Returns

The intersection point.

Definition at line 191 of file line.hpp.

intersects()

template<class A , class B >

constexpr bool ufo::intersects ( A const &  a, B const &  b  )

constexpr

Checks if two shapes intersect.

Template Parameters

A	The type of the first shape.
B	The type of the second shape.

Parameters

[in]	a	The first shape.
[in]	b	The second shape.

Return values

true	if a and b intersect.
false	if a and b do not intersect.

Note

This function is equivalent to !disjoint(a, b).

Definition at line 63 of file intersects.hpp.

inverse() [1/2]

template<InvertibleMatrix M>

constexpr M ufo::inverse ( M const &  m )

constexprnoexcept

Computes the inverse of a square floating-point matrix.

Closed-form implementations are provided for 2×2, 3×3, and 4×4 matrices. Division by the determinant is performed without a prior singularity check; use Mat::safe_inverse() when the matrix may be singular. Requesting any other size triggers a static_assert at compile time.

Template Parameters

M	A square floating-point matrix satisfying InvertibleMatrix.

Parameters

[in]

m

The matrix to invert.

Returns

The inverse of m.

Definition at line 1097 of file mat.hpp.

inverse() [2/2]

template<std::floating_point T>

constexpr Quat< T > ufo::inverse ( Quat< T > const &  q )

constexprnoexcept

Returns the multiplicative inverse conjugate(q) / normSquared(q).

Template Parameters

T	Floating-point scalar type.

Parameters

[in]

q

Input quaternion (must be non-zero).

Returns

The inverse quaternion such that q * inverse(q) = identity.

Definition at line 707 of file quat.hpp.

isfinite()

template<std::size_t Dim, std::floating_point T>

constexpr bool ufo::isfinite ( Vec< Dim, T > const &  v )

constexprnoexcept

Returns true if all components of a floating-point vector are finite.

Template Parameters

Dim	Number of dimensions.
T	Floating-point element type.

Parameters

[in]

v

The vector.

Returns

true iff every element satisfies std::isfinite.

Definition at line 1610 of file vec.hpp.

isinf()

template<std::floating_point T>

Vec< 4, bool > ufo::isinf ( Quat< T > const &  q )

noexcept

Returns a bool vector indicating which components are infinite.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]

q

Input quaternion.

Returns

Vec<4, bool> where element i is true iff component i is ±∞.

Definition at line 1022 of file quat.hpp.

isnan()

template<std::size_t Dim, std::floating_point T>

constexpr bool ufo::isnan ( Vec< Dim, T > const &  v )

constexprnoexcept

Returns true if any component of a floating-point vector is NaN.

Template Parameters

Dim	Number of dimensions.
T	Floating-point element type.

Parameters

[in]

v

The vector.

Returns

true iff at least one element satisfies std::isnan.

Definition at line 1597 of file vec.hpp.

isnormal()

template<std::size_t Dim, std::floating_point T>

constexpr bool ufo::isnormal ( Vec< Dim, T > const &  v )

constexprnoexcept

Returns true if all components of a floating-point vector are normal.

Template Parameters

Dim	Number of dimensions.
T	Floating-point element type.

Parameters

[in]

v

The vector.

Returns

true iff every element satisfies std::isnormal (not zero, subnormal, NaN, or inf).

Definition at line 1624 of file vec.hpp.

isNormalized()

template<std::size_t Dim, class T >

constexpr bool ufo::isNormalized ( Vec< Dim, T > const &  v )

constexprnoexcept

Checks whether a vector has unit length.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]

v

The vector to check.

Returns

true if |dot(v,v) - 1| <= epsilon * 8 for floating-point types, or dot(v,v) == 1 for integral types.

Definition at line 1162 of file vec.hpp.

join()

std::string ufo::join	(	std::vector< std::string > const &	strings,
		char	delimiter
	)

Joins a vector of strings into a single string with a delimiter.

Parameters

strings	Vector of strings
delimiter	Delimiter character

Returns

Joined string

Definition at line 62 of file string.cpp.

ldexp()

template<std::size_t Dim, std::floating_point T>

constexpr Vec< Dim, T > ufo::ldexp ( Vec< Dim, T >  v, int  exp  )

constexprnoexcept

Multiplies each component of a floating-point vector by 2^exp.

Template Parameters

Dim	Number of dimensions.
T	Floating-point element type.

Parameters

[in]	v	The vector.
[in]	exp	The exponent.

Returns

A vector whose element i is std::ldexp(v[i], exp).

Definition at line 1707 of file vec.hpp.

length()

template<std::size_t Dim, std::floating_point T>

constexpr T ufo::length ( Vec< Dim, T > const &  v )

constexprnoexcept

Computes the Euclidean length (magnitude) of a vector.

Template Parameters

Dim	Number of dimensions.
T	Floating-point element type.

Parameters

[in]

v

The vector.

Returns

sqrt(dot(v, v)).

Definition at line 1101 of file vec.hpp.

lerp() [1/2]

template<std::floating_point T>

constexpr Quat< T > ufo::lerp ( Quat< T > const &  x, Quat< T > const &  y, T  a  )

constexprnoexcept

Normalised linear interpolation (NLERP) between two quaternions.

Cheaper than slerp but does not maintain constant angular velocity. a must be in [0, 1] (asserted in debug builds).

Template Parameters

T	Floating-point scalar type.

Parameters

[in]	x	Start quaternion.
[in]	y	End quaternion.
[in]	a	Interpolation factor in [0, 1].

Returns

x * (1 - a) + y * a (component-wise, not normalised).

Definition at line 770 of file quat.hpp.

lerp() [2/2]

template<std::size_t Dim, std::floating_point T>

constexpr Vec< Dim, T > ufo::lerp ( Vec< Dim, T >  a, Vec< Dim, T > const &  b, T  t  )

constexprnoexcept

Linearly interpolates between two vectors component-wise.

Template Parameters

Dim	Number of dimensions.
T	Floating-point element type.

Parameters

[in]	a	Start vector (t == 0).
[in]	b	End vector (t == 1).
[in]	t	Interpolation parameter.

Returns

A vector whose element i is std::lerp(a[i], b[i], t).

Definition at line 1639 of file vec.hpp.

less()

template<std::size_t Dim, class T >

constexpr Vec< Dim, bool > ufo::less ( Vec< Dim, T > const &  v1, Vec< Dim, T > const &  v2  )

constexprnoexcept

Returns a bool vector indicating component-wise less-than.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	v1	First vector.
[in]	v2	Second vector.

Returns

A Vec<Dim, bool> where element i is v1[i] < v2[i].

Definition at line 1482 of file vec.hpp.

lessEqual()

template<std::size_t Dim, class T >

constexpr Vec< Dim, bool > ufo::lessEqual ( Vec< Dim, T > const &  v1, Vec< Dim, T > const &  v2  )

constexprnoexcept

Returns a bool vector indicating component-wise less-than-or-equal.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	v1	First vector.
[in]	v2	Second vector.

Returns

A Vec<Dim, bool> where element i is v1[i] <= v2[i].

Definition at line 1499 of file vec.hpp.

lightness() [1/2]

template<class T , ColorFlags Flags>

constexpr T ufo::lightness ( Lab< T, Flags >  color )

constexprnoexcept

Returns the un-weighted lightness value.

For floating-point weighted colors the raw lightness field is divided by weight; for all other combinations the raw field is returned as-is.

Definition at line 294 of file lab.hpp.

lightness() [2/2]

template<class T , ColorFlags Flags>

constexpr T ufo::lightness ( Lch< T, Flags >  color )

constexprnoexcept

Returns the un-weighted lightness value.

For floating-point weighted colors the raw lightness field is divided by weight; for all other combinations the raw field is returned as-is.

Definition at line 294 of file lch.hpp.

lookAt()

template<std::floating_point T>

Mat< 4, 4, T > ufo::lookAt	(	Vec< 3, T > const &	eye,
		Vec< 3, T > const &	target,
		Vec< 3, T > const &	up
	)

Builds a view matrix (OpenCV convention).

Computes a right-handed look-at view transform (+X Right, +Y Down, +Z Forward): places the camera at eye and looks toward target.

Template Parameters

T	Floating-point element type.

Parameters

[in]	eye	Camera position in world space.
[in]	target	Point in world space the camera looks at.
[in]	up	World-up direction (need not be orthogonal to the view direction).

Returns

A Mat<4, 4, T> view matrix.

Definition at line 1471 of file mat.hpp.

ltrim()

void ufo::ltrim

(

std::string &

s

)

Removes leading whitespace from the string (in-place).

Parameters

s	Input string (modified)

Definition at line 106 of file string.cpp.

ltrimCopy()

std::string ufo::ltrimCopy

(

std::string

s

)

Returns a copy of the string with leading whitespace removed.

Parameters

s	Input string (copy)

Returns

String with leading whitespace removed

Definition at line 126 of file string.cpp.

mapTypes()

std::vector< std::string > ufo::mapTypes ( MapType  mt )

inline

Definition at line 111 of file type.hpp.

max() [1/3]

template<class Geometry >

constexpr Vec< Geometry::dimension(), typename Geometry::value_type > ufo::max ( Geometry const &  g )

constexpr

Returns the maximum coordinate of the minimum spanning axis-aligned bounding box of a geometry.

Template Parameters

Geometry

The type of the geometry.

Parameters

[in]

g

The geometry.

Returns

The maximum coordinate of the minimum spanning axis-aligned bounding box.

Definition at line 72 of file fun.hpp.

max() [2/3]

template<std::size_t Dim, class T >

constexpr T ufo::max ( Vec< Dim, T > const &  v )

constexprnoexcept

Returns the largest element in a vector.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]

v

The vector.

Returns

The maximum element value.

Definition at line 1270 of file vec.hpp.

max() [3/3]

template<std::size_t Dim, class T >

constexpr Vec< Dim, T > ufo::max ( Vec< Dim, T >  v1, Vec< Dim, T > const &  v2  )

constexprnoexcept

Returns the component-wise maximum of two vectors.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	v1	First vector.
[in]	v2	Second vector.

Returns

A vector whose each element is max(v1[i], v2[i]).

Definition at line 1256 of file vec.hpp.

maxIndex()

template<std::size_t Dim, class T >

constexpr std::size_t ufo::maxIndex ( Vec< Dim, T > const &  v )

constexprnoexcept

Returns the index of the largest element in a vector.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]

v

The vector.

Returns

The zero-based index of the maximum element.

Definition at line 1296 of file vec.hpp.

merge()

template<class... Args>
requires (0 < sizeof...(Args)) && (detail::is_soa_v<remove_cvref_t<Args>> || ...) && (requires { detail::wrap_data(std::declval<Args>()); } && ...)

constexpr auto ufo::merge ( Args &&...  args )

constexpr

Definition at line 968 of file structure_of_arrays.hpp.

min() [1/3]

template<class Geometry >

constexpr Vec< Geometry::dimension(), typename Geometry::value_type > ufo::min ( Geometry const &  g )

constexpr

Returns the minimum coordinate of the minimum spanning axis-aligned bounding box of a geometry.

Template Parameters

Geometry

The type of the geometry.

Parameters

[in]

g

The geometry.

Returns

The minimum coordinate of the minimum spanning axis-aligned bounding box.

Definition at line 58 of file fun.hpp.

min() [2/3]

template<std::size_t Dim, class T >

constexpr T ufo::min ( Vec< Dim, T > const &  v )

constexprnoexcept

Returns the smallest element in a vector.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]

v

The vector.

Returns

The minimum element value.

Definition at line 1242 of file vec.hpp.

min() [3/3]

template<std::size_t Dim, class T >

constexpr Vec< Dim, T > ufo::min ( Vec< Dim, T >  v1, Vec< Dim, T > const &  v2  )

constexprnoexcept

Returns the component-wise minimum of two vectors.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	v1	First vector.
[in]	v2	Second vector.

Returns

A vector whose each element is min(v1[i], v2[i]).

Definition at line 1228 of file vec.hpp.

minIndex()

template<std::size_t Dim, class T >

constexpr std::size_t ufo::minIndex ( Vec< Dim, T > const &  v )

constexprnoexcept

Returns the index of the smallest element in a vector.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]

v

The vector.

Returns

The zero-based index of the minimum element.

Definition at line 1283 of file vec.hpp.

mix() [1/2]

template<std::size_t Dim, class T >

constexpr Vec< Dim, T > ufo::mix ( Vec< Dim, T > const &  x, Vec< Dim, T > const &  y, Vec< Dim, bool > const &  a  )

constexprnoexcept

Selects between two vectors component-wise using a bool mask.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	x	Value selected when a[i] is false.
[in]	y	Value selected when a[i] is true.
[in]	a	Per-component bool selector.

Returns

A vector whose element i is a[i] ? y[i] : x[i].

Definition at line 1673 of file vec.hpp.

mix() [2/2]

template<std::size_t Dim, class T , class U >

constexpr Vec< Dim, T > ufo::mix ( Vec< Dim, T > const &  x, Vec< Dim, T > const &  y, Vec< Dim, U > const &  a  )

constexprnoexcept

Mixes two vectors using per-component scalar weights.

Template Parameters

Dim	Number of dimensions.
T	Result element type.
U	Weight element type.

Parameters

[in]	x	First vector (weight 1 - a[i]).
[in]	y	Second vector (weight a[i]).
[in]	a	Per-component blend weights.

Returns

x * (1 - a) + y * a cast back to Vec<Dim, T>.

Definition at line 1657 of file vec.hpp.

none()

template<std::size_t Dim>

constexpr bool ufo::none ( Vec< Dim, bool > const &  v )

constexprnoexcept

Returns true if no component of a bool vector is true.

Template Parameters

Dim	Number of dimensions.

Parameters

[in]

v

The bool vector.

Returns

true iff every element is false.

Definition at line 1584 of file vec.hpp.

norm()

template<std::floating_point T>

constexpr T ufo::norm ( Quat< T > const &  q )

constexprnoexcept

Returns the Euclidean norm sqrt(w² + x² + y² + z²).

Template Parameters

T	Floating-point scalar type.

Parameters

[in]

q

Input quaternion.

Returns

sqrt(normSquared(q)).

Definition at line 667 of file quat.hpp.

normalize() [1/2]

template<std::floating_point T>

constexpr Quat< T > ufo::normalize ( Quat< T > const &  q )

constexprnoexcept

Returns a unit quaternion in the same direction as q.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]

q

Input quaternion.

Returns

q / norm(q), or the identity quaternion (1, 0, 0, 0) if norm(q) ≤ 0.

Definition at line 679 of file quat.hpp.

normalize() [2/2]

template<std::size_t Dim, std::floating_point T>

constexpr Vec< Dim, T > ufo::normalize ( Vec< Dim, T > const &  v )

constexprnoexcept

Returns a unit-length vector in the same direction as v.

Template Parameters

Dim	Number of dimensions.
T	Floating-point element type.

Parameters

[in]

v

The vector to normalize.

Returns

v / length(v).

Undefined behaviour if v is the zero vector.

Definition at line 1148 of file vec.hpp.

normSquared()

template<std::floating_point T>

constexpr T ufo::normSquared ( Quat< T > const &  q )

constexprnoexcept

Returns the squared norm (dot product with itself).

Template Parameters

T	Floating-point scalar type.

Parameters

[in]

q

Input quaternion.

Returns

dot(q, q).

Definition at line 655 of file quat.hpp.

notEqual()

template<std::size_t Dim, class T >

constexpr Vec< Dim, bool > ufo::notEqual ( Vec< Dim, T > const &  v1, Vec< Dim, T > const &  v2  )

constexprnoexcept

Returns a bool vector indicating component-wise inequality.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	v1	First vector.
[in]	v2	Second vector.

Returns

A Vec<Dim, bool> where element i is v1[i] != v2[i].

Definition at line 1465 of file vec.hpp.

ones()

template<std::size_t R, std::size_t C, class T = float>

constexpr Mat< R, C, T > ufo::ones ( )

constexprnoexcept

Returns an R × C matrix with all elements set to one.

Template Parameters

R	Number of rows.
C	Number of columns.
T	Element type (default: float).

Returns

An all-ones matrix of shape R × C.

Definition at line 1229 of file mat.hpp.

operator!=() [1/10]

template<std::size_t Dim>

bool ufo::operator!=	(	DistanceInfo< Dim > const &	lhs,
		DistanceInfo< Dim > const &	rhs
	)

Definition at line 67 of file info.hpp.

operator!=() [2/10]

constexpr bool ufo::operator!= ( OccupancyState  lhs, OccupancyState  rhs  )

inlineconstexpr

Definition at line 60 of file state.hpp.

operator!=() [3/10]

template<typename Key , typename T >

bool ufo::operator!=	(	RangeMap< Key, T > const &	lhs,
		RangeMap< Key, T > const &	rhs
	)

Definition at line 1163 of file range_map.hpp.

operator!=() [4/10]

template<typename Key >

bool ufo::operator!=	(	RangeSet< Key > const &	lhs,
		RangeSet< Key > const &	rhs
	)

Definition at line 751 of file range_set.hpp.

operator!=() [5/10]

template<class Derived , std::size_t Dim, class... Blocks>

bool ufo::operator!=	(	Tree< Derived, Dim, Blocks... > const &	lhs,
		Tree< Derived, Dim, Blocks... > const &	rhs
	)

Definition at line 3863 of file tree.hpp.

operator!=() [6/10]

template<std::size_t Dim, class T >

constexpr bool ufo::operator!= ( TreeCoord< Dim, T > const &  lhs, TreeCoord< Dim, T > const &  rhs  )

constexpr

Definition at line 148 of file coord.hpp.

operator!=() [7/10]

template<std::size_t Dim>

constexpr bool ufo::operator!= ( TreeKey< Dim > const &  lhs, TreeKey< Dim > const &  rhs  )

constexprnoexcept

Definition at line 214 of file key.hpp.

operator!=() [8/10]

template<std::size_t Dim, class T >

bool ufo::operator!=	(	TreeMap< Dim, T > const &	lhs,
		TreeMap< Dim, T > const &	rhs
	)

Definition at line 1253 of file tree_map.hpp.

operator!=() [9/10]

template<std::size_t Dim>

constexpr bool ufo::operator!= ( TreeNode< Dim > const &  lhs, TreeNode< Dim > const &  rhs  )

constexprnoexcept

Definition at line 91 of file node.hpp.

operator!=() [10/10]

template<std::size_t Dim>

bool ufo::operator!=	(	TreeSet< Dim > const &	lhs,
		TreeSet< Dim > const &	rhs
	)

Definition at line 1101 of file tree_set.hpp.

operator%() [1/3]

template<std::size_t Dim, std::integral T>

constexpr Vec< Dim, T > ufo::operator% ( T  lhs, Vec< Dim, T >  rhs  )

constexprnoexcept

Computes the remainder of scalar lhs divided by every component of rhs (integral types only).

Template Parameters

Dim	Number of dimensions.
T	Integral element type.

Parameters

[in]	lhs	Scalar value.
[in]	rhs	Right-hand side vector.

Returns

A vector whose element i is lhs % rhs[i].

Definition at line 946 of file vec.hpp.

operator%() [2/3]

template<std::size_t Dim, std::integral T>

constexpr Vec< Dim, T > ufo::operator% ( Vec< Dim, T >  lhs, T  rhs  )

constexprnoexcept

Computes the remainder of every component of lhs divided by scalar rhs (integral types only).

Template Parameters

Dim	Number of dimensions.
T	Integral element type.

Parameters

[in]	lhs	Left-hand side vector.
[in]	rhs	Scalar value.

Returns

A vector whose element i is lhs[i] % rhs.

Definition at line 795 of file vec.hpp.

operator%() [3/3]

template<std::size_t Dim, std::integral T>

constexpr Vec< Dim, T > ufo::operator% ( Vec< Dim, T >  lhs, Vec< Dim, T > const &  rhs  )

constexprnoexcept

Component-wise modulo of two integral vectors.

Template Parameters

Dim	Number of dimensions.
T	Integral element type.

Parameters

[in]	lhs	Left-hand side vector.
[in]	rhs	Right-hand side vector.

Returns

A vector whose element i is lhs[i] % rhs[i].

Definition at line 602 of file vec.hpp.

operator&() [1/6]

template<std::size_t N>

constexpr BitSet< N > ufo::operator& ( BitSet< N >  lhs, BitSet< N >  rhs  )

constexprnoexcept

Definition at line 241 of file bit_set.hpp.

operator&() [2/6]

constexpr MapType ufo::operator& ( MapType  a, MapType  b  )

constexprnoexcept

Definition at line 83 of file type.hpp.

operator&() [3/6]

constexpr MapUtility ufo::operator& ( MapUtility  a, MapUtility  b  )

constexprnoexcept

Definition at line 66 of file utility.hpp.

operator&() [4/6]

template<std::size_t Dim, std::integral T>

constexpr Vec< Dim, T > ufo::operator& ( T  lhs, Vec< Dim, T >  rhs  )

constexprnoexcept

Bitwise ANDs scalar lhs with every component of rhs (integral types only).

Template Parameters

Dim	Number of dimensions.
T	Integral element type.

Parameters

[in]	lhs	Scalar value.
[in]	rhs	Right-hand side vector.

Returns

A vector whose element i is lhs & rhs[i].

Definition at line 961 of file vec.hpp.

operator&() [5/6]

template<std::size_t Dim, std::integral T>

constexpr Vec< Dim, T > ufo::operator& ( Vec< Dim, T >  lhs, T  rhs  )

constexprnoexcept

Bitwise ANDs every component of lhs with scalar rhs (integral types only).

Template Parameters

Dim	Number of dimensions.
T	Integral element type.

Parameters

[in]	lhs	Left-hand side vector.
[in]	rhs	Scalar value.

Returns

A vector whose element i is lhs[i] & rhs.

Definition at line 810 of file vec.hpp.

operator&() [6/6]

template<std::size_t Dim, std::integral T>

constexpr Vec< Dim, T > ufo::operator& ( Vec< Dim, T >  lhs, Vec< Dim, T > const &  rhs  )

constexprnoexcept

Component-wise bitwise AND of two integral vectors.

Template Parameters

Dim	Number of dimensions.
T	Integral element type.

Parameters

[in]	lhs	Left-hand side vector.
[in]	rhs	Right-hand side vector.

Returns

A vector whose element i is lhs[i] & rhs[i].

Definition at line 618 of file vec.hpp.

operator&&()

template<std::size_t Dim>

constexpr Vec< Dim, bool > ufo::operator&& ( Vec< Dim, bool >  lhs, Vec< Dim, bool > const &  rhs  )

constexprnoexcept

Component-wise logical AND of two bool vectors.

Template Parameters

Dim	Number of dimensions.

Parameters

[in]	lhs	Left-hand side bool vector.
[in]	rhs	Right-hand side bool vector.

Returns

A Vec<Dim, bool> where element i is lhs[i] && rhs[i].

Definition at line 697 of file vec.hpp.

operator*() [1/15]

template<std::size_t Rows, std::size_t Cols, class T >

constexpr Mat< Rows, Cols, T > ufo::operator* ( Mat< Rows, Cols, T >  lhs, T  rhs  )

constexprnoexcept

Multiplies every element of lhs by scalar rhs.

Template Parameters

Rows	Number of rows.
Cols	Number of columns.
T	Element type.

Parameters

[in]	lhs	Left-hand side matrix.
[in]	rhs	Scalar value.

Returns

A matrix whose element [r][c] is lhs[r][c] * rhs.

Definition at line 863 of file mat.hpp.

operator*() [2/15]

template<std::floating_point T>

constexpr Vec< 3, T > ufo::operator* ( Quat< T > const &  q, Vec< 3, T > const &  v  )

constexprnoexcept

Rotates a 3-D column vector by the quaternion (q * v).

Uses the optimised sandwich formula ‘v’ = v + 2w(qvec × v) + 2(qvec × (qvec × v)). Assumesq` is a unit quaternion.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]	q	Unit rotation quaternion.
[in]	v	Input vector.

Returns

Rotated vector.

Definition at line 518 of file quat.hpp.

operator*() [3/15]

template<std::floating_point T>

constexpr Vec< 4, T > ufo::operator* ( Quat< T > const &  q, Vec< 4, T > const &  v  )

constexprnoexcept

Rotates the XYZ part of a homogeneous Vec<4> by q, preserving the W component.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]	q	Unit rotation quaternion.
[in]	v	Homogeneous 4-vector; v[3] is passed through unchanged.

Returns

Rotated 4-vector with the same v[3].

Definition at line 549 of file quat.hpp.

operator*() [4/15]

template<std::floating_point T>

constexpr Quat< T > ufo::operator* ( Quat< T >  lhs, Quat< T > const &  rhs  )

constexprnoexcept

Hamilton (quaternion) product.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]	lhs	Left-hand side.
[in]	rhs	Right-hand side.

Returns

The Hamilton product lhs * rhs.

Definition at line 502 of file quat.hpp.

operator*() [5/15]

template<std::floating_point T>

constexpr Quat< T > ufo::operator* ( Quat< T >  lhs, T  s  )

constexprnoexcept

Scales all components of q by scalar s.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]	lhs	Quaternion.
[in]	s	Scalar multiplier.

Returns

q * s component-wise.

Definition at line 577 of file quat.hpp.

operator*() [6/15]

template<std::size_t Rows, std::size_t Cols, class T >

constexpr Mat< Rows, Cols, T > ufo::operator* ( T  lhs, Mat< Rows, Cols, T >  rhs  )

constexprnoexcept

Multiplies scalar lhs by every element of rhs.

Template Parameters

Rows	Number of rows.
Cols	Number of columns.
T	Element type.

Parameters

[in]	lhs	Scalar value.
[in]	rhs	Right-hand side matrix.

Returns

A matrix whose element [r][c] is lhs * rhs[r][c].

Definition at line 933 of file mat.hpp.

operator*() [7/15]

template<std::size_t Dim, class T >

constexpr Vec< Dim, T > ufo::operator* ( T  lhs, Vec< Dim, T >  rhs  )

constexprnoexcept

Multiplies scalar lhs by every component of rhs.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	lhs	Scalar value.
[in]	rhs	Right-hand side vector.

Returns

A vector whose element i is lhs * rhs[i].

Definition at line 915 of file vec.hpp.

operator*() [8/15]

template<std::floating_point T>

constexpr Quat< T > ufo::operator* ( T  s, Quat< T >  rhs  )

constexprnoexcept

Scales all components of q by scalar s.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]	s	Scalar multiplier.
[in]	rhs	Quaternion.

Returns

s * q component-wise.

Definition at line 591 of file quat.hpp.

operator*() [9/15]

template<std::floating_point T>

constexpr Quat< T > ufo::operator* ( Transform< 3, T > const &  t, Quat< T > const &  q  )

constexpr

(3D only) Applies the rotation component of a transform to a quaternion.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]	t	3D transform.
[in]	q	Input quaternion.

Returns

Rotated quaternion.

Definition at line 436 of file transform.hpp.

operator*() [10/15]

template<std::size_t Dim, std::floating_point T>

constexpr Vec< Dim, T > ufo::operator* ( Transform< Dim, T > const &  t, Vec< Dim, T > const &  v  )

constexpr

Applies a transform to a vector: result = R * v + t.

Template Parameters

Dim	Spatial dimension.
T	Floating-point scalar type.

Parameters

[in]	t	Transform.
[in]	v	Input vector.

Returns

Transformed vector.

Definition at line 422 of file transform.hpp.

operator*() [11/15]

template<std::floating_point T>

constexpr Vec< 3, T > ufo::operator* ( Vec< 3, T > const &  v, Quat< T > const &  q  )

constexprnoexcept

Rotates a 3-D column vector by the inverse quaternion (v * q).

Equivalent to inverse(q) * v. Assumes q is a unit quaternion.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]	v	Input vector.
[in]	q	Unit rotation quaternion.

Returns

Vector rotated by the inverse rotation.

Definition at line 535 of file quat.hpp.

operator*() [12/15]

template<std::floating_point T>

constexpr Vec< 4, T > ufo::operator* ( Vec< 4, T > const &  v, Quat< T > const &  q  )

constexprnoexcept

Rotates the XYZ part of v by the inverse of q, preserving the W component.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]	v	Homogeneous 4-vector; v[3] is passed through unchanged.
[in]	q	Unit rotation quaternion.

Returns

Inversely-rotated 4-vector with the same v[3].

Definition at line 563 of file quat.hpp.

operator*() [13/15]

template<std::size_t Dim, class T >

constexpr Vec< Dim, T > ufo::operator* ( Vec< Dim, T >  lhs, T  rhs  )

constexprnoexcept

Multiplies every component of lhs by scalar rhs.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	lhs	Left-hand side vector.
[in]	rhs	Scalar value.

Returns

A vector whose element i is lhs[i] * rhs.

Definition at line 764 of file vec.hpp.

operator*() [14/15]

template<std::size_t Dim, class T >

constexpr Vec< Dim, T > ufo::operator* ( Vec< Dim, T >  lhs, Vec< Dim, T > const &  rhs  )

constexprnoexcept

Component-wise multiplication of two vectors.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	lhs	Left-hand side vector.
[in]	rhs	Right-hand side vector.

Returns

A vector whose element i is lhs[i] * rhs[i].

Definition at line 570 of file vec.hpp.

operator*() [15/15]

template<std::size_t Rows, std::size_t Cols, class T >

constexpr Vec< Cols, T > ufo::operator* ( Vec< Rows, T > const &  v, Mat< Rows, Cols, T > const &  m  )

constexprnoexcept

Multiplies a row vector by a matrix (v * M).

Template Parameters

Rows	Number of rows in m (equals the dimension of v).
Cols	Number of columns in m.
T	Element type.

Parameters

[in]	v	Row vector.
[in]	m	Right-hand side matrix.

Returns

A Vec<Cols, T> where element c is sum(v[r] * m[r][c]).

Definition at line 995 of file mat.hpp.

operator+() [1/7]

template<std::size_t Dim>

constexpr TreeKey< Dim > ufo::operator+ ( std::uint32_t  v, TreeKey< Dim >  key  )

constexprnoexcept

Definition at line 298 of file key.hpp.

operator+() [2/7]

template<std::size_t Rows, std::size_t Cols, class T >

constexpr Mat< Rows, Cols, T > ufo::operator+ ( T  lhs, Mat< Rows, Cols, T >  rhs  )

constexprnoexcept

Adds scalar lhs to every element of rhs.

Template Parameters

Rows	Number of rows.
Cols	Number of columns.
T	Element type.

Parameters

[in]	lhs	Scalar value.
[in]	rhs	Right-hand side matrix.

Returns

A matrix whose element [r][c] is lhs + rhs[r][c].

Definition at line 897 of file mat.hpp.

operator+() [3/7]

template<std::size_t Dim, class T >

constexpr Vec< Dim, T > ufo::operator+ ( T  lhs, Vec< Dim, T >  rhs  )

constexprnoexcept

Adds scalar lhs to every component of rhs.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	lhs	Scalar value.
[in]	rhs	Right-hand side vector.

Returns

A vector whose element i is lhs + rhs[i].

Definition at line 885 of file vec.hpp.

operator+() [4/7]

Timer ufo::operator+	(	Timer	lhs,
		Timer	rhs
	)

Note

This will stop both lhs and rhs (if running or paused) to add another sample.

Parameters

rhs

Returns

Timer&

Definition at line 69 of file timer.cpp.

operator+() [5/7]

template<std::size_t Dim>

constexpr TreeKey< Dim > ufo::operator+ ( TreeKey< Dim >  key, std::uint32_t  v  )

constexprnoexcept

Definition at line 283 of file key.hpp.

operator+() [6/7]

template<std::size_t Dim>

constexpr TreeKey< Dim > ufo::operator+ ( TreeKey< Dim >  key, Vec< Dim, std::uint32_t > const &  v  )

constexprnoexcept

Definition at line 290 of file key.hpp.

operator+() [7/7]

template<std::size_t Dim>

constexpr TreeKey< Dim > ufo::operator+ ( Vec< Dim, std::uint32_t > const &  v, TreeKey< Dim >  key  )

constexprnoexcept

Definition at line 305 of file key.hpp.

operator-() [1/13]

template<std::size_t Rows, std::size_t Cols, class T >

constexpr Mat< Rows, Cols, T > ufo::operator- ( Mat< Rows, Cols, T >  lhs, Mat< Rows, Cols, T > const &  rhs  )

constexprnoexcept

Element-wise subtraction of two matrices.

Template Parameters

Rows	Number of rows.
Cols	Number of columns.
T	Element type.

Parameters

[in]	lhs	Left-hand side matrix.
[in]	rhs	Right-hand side matrix.

Returns

A matrix whose element [r][c] is lhs[r][c] - rhs[r][c].

Definition at line 806 of file mat.hpp.

operator-() [2/13]

template<std::size_t Rows, std::size_t Cols, class T >

constexpr Mat< Rows, Cols, T > ufo::operator- ( Mat< Rows, Cols, T >  lhs, T  rhs  )

constexprnoexcept

Subtracts scalar rhs from every element of lhs.

Template Parameters

Rows	Number of rows.
Cols	Number of columns.
T	Element type.

Parameters

[in]	lhs	Left-hand side matrix.
[in]	rhs	Scalar value.

Returns

A matrix whose element [r][c] is lhs[r][c] - rhs.

Definition at line 846 of file mat.hpp.

operator-() [3/13]

template<std::floating_point T>

constexpr Quat< T > ufo::operator- ( Quat< T > const &  q )

constexprnoexcept

Unary negation — negates all four components.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]

q

Input quaternion.

Returns

(-q.w, -q.x, -q.y, -q.z).

Definition at line 455 of file quat.hpp.

operator-() [4/13]

template<std::floating_point T>

constexpr Quat< T > ufo::operator- ( Quat< T >  lhs, Quat< T > const &  rhs  )

constexprnoexcept

Component-wise subtraction of two quaternions.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]	lhs	Left-hand side.
[in]	rhs	Right-hand side.

Returns

Component-wise difference.

Definition at line 488 of file quat.hpp.

operator-() [5/13]

template<std::size_t Dim>

constexpr TreeKey< Dim > ufo::operator- ( std::uint32_t  v, TreeKey< Dim >  key  )

constexprnoexcept

Definition at line 328 of file key.hpp.

operator-() [6/13]

template<std::size_t Rows, std::size_t Cols, class T >

constexpr Mat< Rows, Cols, T > ufo::operator- ( T  lhs, Mat< Rows, Cols, T > const &  rhs  )

constexprnoexcept

Subtracts every element of rhs from scalar lhs.

Template Parameters

Rows	Number of rows.
Cols	Number of columns.
T	Element type.

Parameters

[in]	lhs	Scalar value.
[in]	rhs	Right-hand side matrix.

Returns

A matrix whose element [r][c] is lhs - rhs[r][c].

Definition at line 914 of file mat.hpp.

operator-() [7/13]

template<std::size_t Dim, class T >

constexpr Vec< Dim, T > ufo::operator- ( T  lhs, Vec< Dim, T >  rhs  )

constexprnoexcept

Subtracts every component of rhs from scalar lhs.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	lhs	Scalar value.
[in]	rhs	Right-hand side vector.

Returns

A vector whose element i is lhs - rhs[i].

Definition at line 900 of file vec.hpp.

operator-() [8/13]

Timer ufo::operator-	(	Timer	lhs,
		Timer	rhs
	)

Note

This will stop both lhs and rhs (if running or paused) to add another sample.

Parameters

rhs

Returns

Timer&

Definition at line 100 of file timer.cpp.

operator-() [9/13]

template<std::size_t Dim>

constexpr TreeKey< Dim > ufo::operator- ( TreeKey< Dim >  key, std::uint32_t  v  )

constexprnoexcept

Definition at line 313 of file key.hpp.

operator-() [10/13]

template<std::size_t Dim>

constexpr TreeKey< Dim > ufo::operator- ( TreeKey< Dim >  key, Vec< Dim, std::uint32_t > const &  v  )

constexprnoexcept

Definition at line 320 of file key.hpp.

operator-() [11/13]

template<std::size_t Dim>

constexpr TreeKey< Dim > ufo::operator- ( Vec< Dim, std::uint32_t > const &  v, TreeKey< Dim >  key  )

constexprnoexcept

Definition at line 335 of file key.hpp.

operator-() [12/13]

template<std::size_t Dim, class T >

constexpr Vec< Dim, T > ufo::operator- ( Vec< Dim, T >  lhs, T  rhs  )

constexprnoexcept

Subtracts scalar rhs from every component of lhs.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	lhs	Left-hand side vector.
[in]	rhs	Scalar value.

Returns

A vector whose element i is lhs[i] - rhs.

Definition at line 749 of file vec.hpp.

operator-() [13/13]

template<std::size_t Dim, class T >

constexpr Vec< Dim, T > ufo::operator- ( Vec< Dim, T >  lhs, Vec< Dim, T > const &  rhs  )

constexprnoexcept

Component-wise subtraction of two vectors.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	lhs	Left-hand side vector.
[in]	rhs	Right-hand side vector.

Returns

A vector whose element i is lhs[i] - rhs[i].

Definition at line 554 of file vec.hpp.

operator/() [1/6]

template<std::size_t Rows, std::size_t Cols, class T >

constexpr Mat< Rows, Cols, T > ufo::operator/ ( Mat< Rows, Cols, T >  lhs, T  rhs  )

constexprnoexcept

Divides every element of lhs by scalar rhs.

Template Parameters

Rows	Number of rows.
Cols	Number of columns.
T	Element type.

Parameters

[in]	lhs	Left-hand side matrix.
[in]	rhs	Scalar value.

Returns

A matrix whose element [r][c] is lhs[r][c] / rhs.

Definition at line 880 of file mat.hpp.

operator/() [2/6]

template<std::floating_point T>

constexpr Quat< T > ufo::operator/ ( Quat< T >  lhs, T  s  )

constexprnoexcept

Divides all components of q by scalar s.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]	lhs	Quaternion.
[in]	s	Scalar divisor.

Returns

q / s component-wise.

Definition at line 605 of file quat.hpp.

operator/() [3/6]

template<std::size_t Rows, std::size_t Cols, class T >

constexpr Mat< Rows, Cols, T > ufo::operator/ ( T  lhs, Mat< Rows, Cols, T > const &  rhs  )

constexprnoexcept

Divides scalar lhs by every element of rhs.

Template Parameters

Rows	Number of rows.
Cols	Number of columns.
T	Element type.

Parameters

[in]	lhs	Scalar value.
[in]	rhs	Right-hand side matrix.

Returns

A matrix whose element [r][c] is lhs / rhs[r][c].

Definition at line 950 of file mat.hpp.

operator/() [4/6]

template<std::size_t Dim, class T >

constexpr Vec< Dim, T > ufo::operator/ ( T  lhs, Vec< Dim, T >  rhs  )

constexprnoexcept

Divides scalar lhs by every component of rhs.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	lhs	Scalar value.
[in]	rhs	Right-hand side vector.

Returns

A vector whose element i is lhs / rhs[i].

Definition at line 930 of file vec.hpp.

operator/() [5/6]

template<std::size_t Dim, class T >

constexpr Vec< Dim, T > ufo::operator/ ( Vec< Dim, T >  lhs, T  rhs  )

constexprnoexcept

Divides every component of lhs by scalar rhs.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	lhs	Left-hand side vector.
[in]	rhs	Scalar value.

Returns

A vector whose element i is lhs[i] / rhs.

Definition at line 779 of file vec.hpp.

operator/() [6/6]

template<std::size_t Dim, class T >

constexpr Vec< Dim, T > ufo::operator/ ( Vec< Dim, T >  lhs, Vec< Dim, T > const &  rhs  )

constexprnoexcept

Component-wise division of two vectors.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]	lhs	Left-hand side vector.
[in]	rhs	Right-hand side vector.

Returns

A vector whose element i is lhs[i] / rhs[i].

Definition at line 586 of file vec.hpp.

operator<() [1/5]

constexpr bool ufo::operator< ( OccupancyState  lhs, OccupancyState  rhs  )

inlineconstexpr

Definition at line 65 of file state.hpp.

operator<() [2/5]

template<typename Key , typename T >

bool ufo::operator<	(	RangeMap< Key, T > const &	lhs,
		RangeMap< Key, T > const &	rhs
	)

Definition at line 1170 of file range_map.hpp.

operator<() [3/5]

template<typename Key >

bool ufo::operator<	(	RangeSet< Key > const &	lhs,
		RangeSet< Key > const &	rhs
	)

Definition at line 758 of file range_set.hpp.

operator<() [4/5]

template<std::size_t Dim>

constexpr bool ufo::operator< ( TreeKey< Dim > const &  lhs, TreeKey< Dim > const &  rhs  )

constexprnoexcept

Definition at line 221 of file key.hpp.

operator<() [5/5]

template<std::size_t Dim>

constexpr bool ufo::operator< ( TreeNode< Dim > const &  lhs, TreeNode< Dim > const &  rhs  )

constexprnoexcept

Definition at line 97 of file node.hpp.

operator<<() [1/38]

template<class CharT , class Traits , std::size_t N>

std::basic_ostream< CharT, Traits > & ufo::operator<<	(	std::basic_ostream< CharT, Traits > &	os,
		BitSet< N >	x
	)

Definition at line 253 of file bit_set.hpp.

operator<<() [2/38]

std::ostream & ufo::operator<< ( std::ostream &  os, MapHeader const &  header  )

inline

Definition at line 399 of file header.hpp.

operator<<() [3/38]

std::ostream & ufo::operator<< ( std::ostream &  os, MapType  mt  )

inline

Definition at line 126 of file type.hpp.

operator<<() [4/38]

std::ostream & ufo::operator<< ( std::ostream &  os, OrthogonalCamera const &  camera  )

inline

Writes a human-readable summary of camera to os.

Definition at line 154 of file orthogonal.hpp.

operator<<() [5/38]

std::ostream & ufo::operator<< ( std::ostream &  os, OrthogonalIntrinsics const &  intrinsics  )

inline

Writes a human-readable summary of intrinsics to os.

Definition at line 106 of file orthogonal_intrinsics.hpp.

operator<<() [6/38]

std::ostream & ufo::operator<< ( std::ostream &  os, PerspectiveCamera const &  camera  )

inline

Writes a human-readable summary of camera to os.

Definition at line 215 of file perspective.hpp.

operator<<() [7/38]

std::ostream & ufo::operator<< ( std::ostream &  os, PerspectiveIntrinsics const &  intrinsics  )

inline

Writes a human-readable summary of intrinsics to os.

Definition at line 146 of file perspective_intrinsics.hpp.

operator<<() [8/38]

template<typename Key , typename T >

std::ostream & ufo::operator<<	(	std::ostream &	os,
		RangeMap< Key, T > const &	range_map
	)

Definition at line 1218 of file range_map.hpp.

operator<<() [9/38]

template<typename Key >

std::ostream & ufo::operator<<	(	std::ostream &	os,
		RangeSet< Key > const &	range_set
	)

Definition at line 806 of file range_set.hpp.

operator<<() [10/38]

std::ostream & ufo::operator<< ( std::ostream &  os, ScalarType  type  )

inline

Stream-insertion operator for ScalarType.

Definition at line 103 of file scalar_type.hpp.

operator<<() [11/38]

template<std::size_t Dim>

std::ostream & ufo::operator<<	(	std::ostream &	os,
		TreeNode< Dim > const &	node
	)

Definition at line 121 of file node.hpp.

operator<<() [12/38]

template<std::size_t Dim, std::floating_point T>

std::ostream & ufo::operator<<	(	std::ostream &	out,
		AABB< Dim, T > const &	aabb
	)

Output stream operator for AABB.

Parameters

[in]	out	The output stream.
[in]	aabb	The AABB.

Returns

The output stream.

Definition at line 218 of file aabb.hpp.

operator<<() [13/38]

template<std::size_t Dim, std::floating_point T>

std::ostream & ufo::operator<<	(	std::ostream &	out,
		Capsule< Dim, T > const &	capsule
	)

Output stream operator for Capsule.

Definition at line 199 of file capsule.hpp.

operator<<() [14/38]

template<std::size_t Dim, std::floating_point T>

std::ostream & ufo::operator<<	(	std::ostream &	out,
		Cylinder< Dim, T > const &	cylinder
	)

Output stream operator for Cylinder.

Parameters

[in]	out	The output stream.
[in]	cylinder	The cylinder.

Returns

The output stream.

Definition at line 228 of file cylinder.hpp.

operator<<() [15/38]

template<std::size_t Dim>

std::ostream & ufo::operator<<	(	std::ostream &	out,
		DistanceInfo< Dim > const &	info
	)

Definition at line 73 of file info.hpp.

operator<<() [16/38]

template<std::size_t Dim, std::floating_point T>

std::ostream & ufo::operator<<	(	std::ostream &	out,
		Ellipsoid< Dim, T > const &	ellipsoid
	)

Output stream operator for Ellipsoid.

Parameters

[in]	out	The output stream.
[in]	ellipsoid	The ellipsoid.

Returns

The output stream.

Definition at line 210 of file ellipsoid.hpp.

operator<<() [17/38]

template<std::size_t Dim, std::floating_point T>

std::ostream & ufo::operator<<	(	std::ostream &	out,
		Frustum< Dim, T > const &	frustum
	)

Output stream operator for Frustum.

Definition at line 295 of file frustum.hpp.

operator<<() [18/38]

template<class T , ColorFlags Flags>

std::ostream & ufo::operator<< ( std::ostream &  out, Gray< T, Flags > const &  c  )

inline

Writes a human-readable representation of c to out.

Parameters

[out]	out	Output stream.
[in]	c	Color to write.

Returns

out.

Definition at line 282 of file gray.hpp.

operator<<() [19/38]

template<class T , ColorFlags Flags>

std::ostream & ufo::operator<< ( std::ostream &  out, Lab< T, Flags > const &  c  )

inline

Writes a human-readable representation of c to out.

Parameters

[out]	out	Output stream.
[in]	c	Color to write.

Returns

out.

Definition at line 382 of file lab.hpp.

operator<<() [20/38]

template<class T , ColorFlags Flags>

std::ostream & ufo::operator<< ( std::ostream &  out, Lch< T, Flags > const &  c  )

inline

Writes a human-readable representation of c to out.

Parameters

[out]	out	Output stream.
[in]	c	Color to write.

Returns

out.

Definition at line 382 of file lch.hpp.

operator<<() [21/38]

template<std::size_t Dim, std::floating_point T>

std::ostream & ufo::operator<<	(	std::ostream &	out,
		Line< Dim, T > const &	line
	)

Output stream operator for Line.

Definition at line 247 of file line.hpp.

operator<<() [22/38]

template<std::size_t Dim, std::floating_point T>

std::ostream & ufo::operator<<	(	std::ostream &	out,
		LineSegment< Dim, T > const &	ls
	)

Output stream operator for LineSegment.

Definition at line 196 of file line_segment.hpp.

operator<<() [23/38]

template<class T , ColorFlags Flags>

std::ostream & ufo::operator<< ( std::ostream &  out, Lrgb< T, Flags > const &  c  )

inline

Writes a human-readable representation of c to out.

Parameters

[out]	out	Output stream.
[in]	c	Color to write.

Returns

out.

Definition at line 381 of file lrgb.hpp.

operator<<() [24/38]

template<std::floating_point T>

std::ostream & ufo::operator<<	(	std::ostream &	out,
		OBB< 2, T > const &	obb
	)

Output stream operator for 2D OBB.

Definition at line 550 of file obb.hpp.

operator<<() [25/38]

template<std::floating_point T>

std::ostream & ufo::operator<<	(	std::ostream &	out,
		OBB< 3, T > const &	obb
	)

Output stream operator for 3D OBB.

Definition at line 560 of file obb.hpp.

operator<<() [26/38]

template<std::floating_point T>

std::ostream & ufo::operator<<	(	std::ostream &	out,
		OBB< 4, T > const &	obb
	)

Output stream operator for 4D OBB.

Definition at line 570 of file obb.hpp.

operator<<() [27/38]

template<std::size_t Dim, std::floating_point T>

std::ostream & ufo::operator<<	(	std::ostream &	out,
		Plane< Dim, T > const &	plane
	)

Output stream operator for Plane.

Definition at line 200 of file plane.hpp.

operator<<() [28/38]

template<std::size_t Dim, std::floating_point T>

std::ostream & ufo::operator<<	(	std::ostream &	out,
		Ray< Dim, T > const &	ray
	)

Output stream operator for Ray.

Definition at line 186 of file ray.hpp.

operator<<() [29/38]

template<class T , ColorFlags Flags>

std::ostream & ufo::operator<< ( std::ostream &  out, Rgb< T, Flags > const &  c  )

inline

Writes a human-readable representation of c to out.

Parameters

[out]	out	Output stream.
[in]	c	Color to write.

Returns

out.

Definition at line 381 of file rgb.hpp.

operator<<() [30/38]

template<std::size_t Dim, std::floating_point T>

std::ostream & ufo::operator<<	(	std::ostream &	out,
		Sphere< Dim, T > const &	sphere
	)

Output stream operator for Sphere.

Definition at line 191 of file sphere.hpp.

operator<<() [31/38]

template<std::size_t Dim, std::floating_point T>

std::ostream & ufo::operator<<	(	std::ostream &	out,
		Transform< Dim, T > const &	t
	)

Writes a human-readable representation of the transform to an output stream.

2D: "Translation: <t>, Theta: <θ>". 3D: "Translation: <t>, Rotation: <q>".

Template Parameters

Dim	Spatial dimension.
T	Floating-point scalar type.

Parameters

[in]	out	Output stream.
[in]	t	Transform to print.

Returns

Reference to out.

Definition at line 451 of file transform.hpp.

operator<<() [32/38]

template<std::size_t Dim, class T >

std::ostream & ufo::operator<<	(	std::ostream &	out,
		TreeCoord< Dim, T > const &	tc
	)

Definition at line 154 of file coord.hpp.

operator<<() [33/38]

std::ostream & ufo::operator<< ( std::ostream &  out, TreeIndex  index  )

inline

Definition at line 104 of file index.hpp.

operator<<() [34/38]

template<std::size_t Dim>

std::ostream & ufo::operator<<	(	std::ostream &	out,
		TreeKey< Dim > const &	key
	)

Definition at line 186 of file key.hpp.

operator<<() [35/38]

template<std::size_t Dim, std::floating_point T>

std::ostream & ufo::operator<<	(	std::ostream &	out,
		Triangle< Dim, T > const &	triangle
	)

Output stream operator for Triangle.

Definition at line 221 of file triangle.hpp.

operator<<() [36/38]

template<std::size_t Dim, std::integral T>

constexpr Vec< Dim, T > ufo::operator<< ( T  lhs, Vec< Dim, T >  rhs  )

constexprnoexcept

Left-shifts scalar lhs by every component of rhs (integral types only).

Template Parameters

Dim	Number of dimensions.
T	Integral element type.

Parameters

[in]	lhs	Scalar value.
[in]	rhs	Per-component shift amounts.

Returns

A vector whose element i is lhs << rhs[i].

Definition at line 1006 of file vec.hpp.

operator<<() [37/38]

template<std::size_t Dim, std::integral T>

constexpr Vec< Dim, T > ufo::operator<< ( Vec< Dim, T >  lhs, T  rhs  )

constexprnoexcept

Left-shifts every component of lhs by scalar rhs (integral types only).

Template Parameters

Dim	Number of dimensions.
T	Integral element type.

Parameters

[in]	lhs	Left-hand side vector.
[in]	rhs	Shift amount.

Returns

A vector whose element i is lhs[i] << rhs.

Definition at line 855 of file vec.hpp.

operator<<() [38/38]

template<std::size_t Dim, std::integral T>

constexpr Vec< Dim, T > ufo::operator<< ( Vec< Dim, T >  lhs, Vec< Dim, T > const &  rhs  )

constexprnoexcept

Component-wise left shift of an integral vector by a per-element amount.

Template Parameters

Dim	Number of dimensions.
T	Integral element type.

Parameters

[in]	lhs	Left-hand side vector.
[in]	rhs	Per-component shift amounts.

Returns

A vector whose element i is lhs[i] << rhs[i].

Definition at line 666 of file vec.hpp.

operator<=() [1/5]

constexpr bool ufo::operator<= ( OccupancyState  lhs, OccupancyState  rhs  )

inlineconstexpr

Definition at line 70 of file state.hpp.

operator<=() [2/5]

template<typename Key , typename T >

bool ufo::operator<=	(	RangeMap< Key, T > const &	lhs,
		RangeMap< Key, T > const &	rhs
	)

Definition at line 1177 of file range_map.hpp.

operator<=() [3/5]

template<typename Key >

bool ufo::operator<=	(	RangeSet< Key > const &	lhs,
		RangeSet< Key > const &	rhs
	)

Definition at line 765 of file range_set.hpp.

operator<=() [4/5]

template<std::size_t Dim>

constexpr bool ufo::operator<= ( TreeKey< Dim > const &  lhs, TreeKey< Dim > const &  rhs  )

constexprnoexcept

Definition at line 235 of file key.hpp.

operator<=() [5/5]

template<std::size_t Dim>

constexpr bool ufo::operator<= ( TreeNode< Dim > const &  lhs, TreeNode< Dim > const &  rhs  )

constexprnoexcept

Definition at line 103 of file node.hpp.

operator<=>()

template<class... Ts>

constexpr auto ufo::operator<=> ( SoA< Ts... > const &  lhs, SoA< Ts... > const &  rhs  )

constexpr

Definition at line 959 of file structure_of_arrays.hpp.

operator==() [1/12]

template<std::size_t Dim>

bool ufo::operator==	(	DistanceInfo< Dim > const &	lhs,
		DistanceInfo< Dim > const &	rhs
	)

Definition at line 61 of file info.hpp.

operator==() [2/12]

template<std::size_t Dim, std::floating_point T>

bool ufo::operator== ( Line< Dim, T > const &  lhs, Line< Dim, T > const &  rhs  )

noexcept

Equality operator for Line.

Definition at line 226 of file line.hpp.

operator==() [3/12]

constexpr bool ufo::operator== ( OccupancyState  lhs, OccupancyState  rhs  )

inlineconstexpr

Definition at line 55 of file state.hpp.

operator==() [4/12]

template<typename Key , typename T >

bool ufo::operator==	(	RangeMap< Key, T > const &	lhs,
		RangeMap< Key, T > const &	rhs
	)

Definition at line 1156 of file range_map.hpp.

operator==() [5/12]

template<typename Key >

bool ufo::operator==	(	RangeSet< Key > const &	lhs,
		RangeSet< Key > const &	rhs
	)

Definition at line 744 of file range_set.hpp.

operator==() [6/12]

template<class... Ts>

constexpr bool ufo::operator== ( SoA< Ts... > const &  lhs, SoA< Ts... > const &  rhs  )

constexpr

Definition at line 953 of file structure_of_arrays.hpp.

operator==() [7/12]

template<class Derived , std::size_t Dim, class... Blocks>

bool ufo::operator==	(	Tree< Derived, Dim, Blocks... > const &	lhs,
		Tree< Derived, Dim, Blocks... > const &	rhs
	)

Definition at line 3846 of file tree.hpp.

operator==() [8/12]

template<std::size_t Dim, class T >

constexpr bool ufo::operator== ( TreeCoord< Dim, T > const &  lhs, TreeCoord< Dim, T > const &  rhs  )

constexpr

Definition at line 141 of file coord.hpp.

operator==() [9/12]

template<std::size_t Dim>

constexpr bool ufo::operator== ( TreeKey< Dim > const &  lhs, TreeKey< Dim > const &  rhs  )

constexprnoexcept

Definition at line 205 of file key.hpp.

operator==() [10/12]

template<std::size_t Dim, class T >

bool ufo::operator==	(	TreeMap< Dim, T > const &	lhs,
		TreeMap< Dim, T > const &	rhs
	)

Definition at line 1233 of file tree_map.hpp.

operator==() [11/12]

template<std::size_t Dim>

constexpr bool ufo::operator== ( TreeNode< Dim > const &  lhs, TreeNode< Dim > const &  rhs  )

constexprnoexcept

Definition at line 85 of file node.hpp.

operator==() [12/12]

template<std::size_t Dim>

bool ufo::operator==	(	TreeSet< Dim > const &	lhs,
		TreeSet< Dim > const &	rhs
	)

Definition at line 1081 of file tree_set.hpp.

operator>() [1/5]

constexpr bool ufo::operator> ( OccupancyState  lhs, OccupancyState  rhs  )

inlineconstexpr

Definition at line 75 of file state.hpp.

operator>() [2/5]

template<typename Key , typename T >

bool ufo::operator>	(	RangeMap< Key, T > const &	lhs,
		RangeMap< Key, T > const &	rhs
	)

Definition at line 1184 of file range_map.hpp.

operator>() [3/5]

template<typename Key >

bool ufo::operator>	(	RangeSet< Key > const &	lhs,
		RangeSet< Key > const &	rhs
	)

Definition at line 772 of file range_set.hpp.

operator>() [4/5]

template<std::size_t Dim>

constexpr bool ufo::operator> ( TreeKey< Dim > const &  lhs, TreeKey< Dim > const &  rhs  )

constexprnoexcept

Definition at line 249 of file key.hpp.

operator>() [5/5]

template<std::size_t Dim>

constexpr bool ufo::operator> ( TreeNode< Dim > const &  lhs, TreeNode< Dim > const &  rhs  )

constexprnoexcept

Definition at line 109 of file node.hpp.

operator>=() [1/5]

constexpr bool ufo::operator>= ( OccupancyState  lhs, OccupancyState  rhs  )

inlineconstexpr

Definition at line 80 of file state.hpp.

operator>=() [2/5]

template<typename Key , typename T >

bool ufo::operator>=	(	RangeMap< Key, T > const &	lhs,
		RangeMap< Key, T > const &	rhs
	)

Definition at line 1191 of file range_map.hpp.

operator>=() [3/5]

template<typename Key >

bool ufo::operator>=	(	RangeSet< Key > const &	lhs,
		RangeSet< Key > const &	rhs
	)

Definition at line 779 of file range_set.hpp.

operator>=() [4/5]

template<std::size_t Dim>

constexpr bool ufo::operator>= ( TreeKey< Dim > const &  lhs, TreeKey< Dim > const &  rhs  )

constexprnoexcept

Definition at line 263 of file key.hpp.

operator>=() [5/5]

template<std::size_t Dim>

constexpr bool ufo::operator>= ( TreeNode< Dim > const &  lhs, TreeNode< Dim > const &  rhs  )

constexprnoexcept

Definition at line 115 of file node.hpp.

operator>>() [1/5]

template<class CharT , class Traits , std::size_t N>

std::basic_istream< CharT, Traits > & ufo::operator>>	(	std::basic_istream< CharT, Traits > &	is,
		BitSet< N > &	x
	)

Definition at line 266 of file bit_set.hpp.

operator>>() [2/5]

std::istream & ufo::operator>> ( std::istream &  is, MapHeader &  header  )

inline

Definition at line 404 of file header.hpp.

operator>>() [3/5]

template<std::size_t Dim, std::integral T>

constexpr Vec< Dim, T > ufo::operator>> ( T  lhs, Vec< Dim, T >  rhs  )

constexprnoexcept

Right-shifts scalar lhs by every component of rhs (integral types only).

Template Parameters

Dim	Number of dimensions.
T	Integral element type.

Parameters

[in]	lhs	Scalar value.
[in]	rhs	Per-component shift amounts.

Returns

A vector whose element i is lhs >> rhs[i].

Definition at line 1021 of file vec.hpp.

operator>>() [4/5]

template<std::size_t Dim, std::integral T>

constexpr Vec< Dim, T > ufo::operator>> ( Vec< Dim, T >  lhs, T  rhs  )

constexprnoexcept

Right-shifts every component of lhs by scalar rhs (integral types only).

Template Parameters

Dim	Number of dimensions.
T	Integral element type.

Parameters

[in]	lhs	Left-hand side vector.
[in]	rhs	Shift amount.

Returns

A vector whose element i is lhs[i] >> rhs.

Definition at line 870 of file vec.hpp.

operator>>() [5/5]

template<std::size_t Dim, std::integral T>

constexpr Vec< Dim, T > ufo::operator>> ( Vec< Dim, T >  lhs, Vec< Dim, T > const &  rhs  )

constexprnoexcept

Component-wise right shift of an integral vector by a per-element amount.

Template Parameters

Dim	Number of dimensions.
T	Integral element type.

Parameters

[in]	lhs	Left-hand side vector.
[in]	rhs	Per-component shift amounts.

Returns

A vector whose element i is lhs[i] >> rhs[i].

Definition at line 682 of file vec.hpp.

operator^() [1/4]

template<std::size_t N>

constexpr BitSet< N > ufo::operator^ ( BitSet< N >  lhs, BitSet< N >  rhs  )

constexprnoexcept

Definition at line 253 of file bit_set.hpp.

operator^() [2/4]

template<std::size_t Dim, std::integral T>

constexpr Vec< Dim, T > ufo::operator^ ( T  lhs, Vec< Dim, T >  rhs  )

constexprnoexcept

Bitwise XORs scalar lhs with every component of rhs (integral types only).

Template Parameters

Dim	Number of dimensions.
T	Integral element type.

Parameters

[in]	lhs	Scalar value.
[in]	rhs	Right-hand side vector.

Returns

A vector whose element i is lhs ^ rhs[i].

Definition at line 991 of file vec.hpp.

operator^() [3/4]

template<std::size_t Dim, std::integral T>

constexpr Vec< Dim, T > ufo::operator^ ( Vec< Dim, T >  lhs, T  rhs  )

constexprnoexcept

Bitwise XORs every component of lhs with scalar rhs (integral types only).

Template Parameters

Dim	Number of dimensions.
T	Integral element type.

Parameters

[in]	lhs	Left-hand side vector.
[in]	rhs	Scalar value.

Returns

A vector whose element i is lhs[i] ^ rhs.

Definition at line 840 of file vec.hpp.

operator^() [4/4]

template<std::size_t Dim, std::integral T>

constexpr Vec< Dim, T > ufo::operator^ ( Vec< Dim, T >  lhs, Vec< Dim, T > const &  rhs  )

constexprnoexcept

Component-wise bitwise XOR of two integral vectors.

Template Parameters

Dim	Number of dimensions.
T	Integral element type.

Parameters

[in]	lhs	Left-hand side vector.
[in]	rhs	Right-hand side vector.

Returns

A vector whose element i is lhs[i] ^ rhs[i].

Definition at line 650 of file vec.hpp.

operator|() [1/6]

template<std::size_t N>

constexpr BitSet< N > ufo::operator| ( BitSet< N >  lhs, BitSet< N >  rhs  )

constexprnoexcept

Definition at line 247 of file bit_set.hpp.

operator|() [2/6]

constexpr MapType ufo::operator| ( MapType  a, MapType  b  )

constexprnoexcept

Definition at line 78 of file type.hpp.

operator|() [3/6]

constexpr MapUtility ufo::operator| ( MapUtility  a, MapUtility  b  )

constexprnoexcept

Definition at line 61 of file utility.hpp.

operator|() [4/6]

template<std::size_t Dim, std::integral T>

constexpr Vec< Dim, T > ufo::operator| ( T  lhs, Vec< Dim, T >  rhs  )

constexprnoexcept

Bitwise ORs scalar lhs with every component of rhs (integral types only).

Template Parameters

Dim	Number of dimensions.
T	Integral element type.

Parameters

[in]	lhs	Scalar value.
[in]	rhs	Right-hand side vector.

Returns

A vector whose element i is lhs | rhs[i].

Definition at line 976 of file vec.hpp.

operator|() [5/6]

template<std::size_t Dim, std::integral T>

constexpr Vec< Dim, T > ufo::operator| ( Vec< Dim, T >  lhs, T  rhs  )

constexprnoexcept

Bitwise ORs every component of lhs with scalar rhs (integral types only).

Template Parameters

Dim	Number of dimensions.
T	Integral element type.

Parameters

[in]	lhs	Left-hand side vector.
[in]	rhs	Scalar value.

Returns

A vector whose element i is lhs[i] | rhs.

Definition at line 825 of file vec.hpp.

operator|() [6/6]

template<std::size_t Dim, std::integral T>

constexpr Vec< Dim, T > ufo::operator| ( Vec< Dim, T >  lhs, Vec< Dim, T > const &  rhs  )

constexprnoexcept

Component-wise bitwise OR of two integral vectors.

Template Parameters

Dim	Number of dimensions.
T	Integral element type.

Parameters

[in]	lhs	Left-hand side vector.
[in]	rhs	Right-hand side vector.

Returns

A vector whose element i is lhs[i] | rhs[i].

Definition at line 634 of file vec.hpp.

operator||()

template<std::size_t Dim>

constexpr Vec< Dim, bool > ufo::operator|| ( Vec< Dim, bool >  lhs, Vec< Dim, bool > const &  rhs  )

constexprnoexcept

Component-wise logical OR of two bool vectors.

Template Parameters

Dim	Number of dimensions.

Parameters

[in]	lhs	Left-hand side bool vector.
[in]	rhs	Right-hand side bool vector.

Returns

A Vec<Dim, bool> where element i is lhs[i] || rhs[i].

Definition at line 712 of file vec.hpp.

orthogonal()

template<std::floating_point T>

Mat< 4, 4, T > ufo::orthogonal	(	T	left,
		T	right,
		T	bottom,
		T	top,
		T	zNear,
		T	zFar
	)

Builds an orthographic projection matrix (OpenCV convention).

Constructs a right-handed orthographic matrix (+X Right, +Y Down, +Z Forward) with a [0, 1] depth range.

Template Parameters

T	Floating-point element type.

Parameters

[in]	left	Left clipping plane.
[in]	right	Right clipping plane.
[in]	bottom	Bottom clipping plane.
[in]	top	Top clipping plane.
[in]	zNear	Near clipping plane.
[in]	zFar	Far clipping plane.

Returns

A Mat<4, 4, T> representing the orthographic projection.

Definition at line 1385 of file mat.hpp.

perspective() [1/2]

template<std::floating_point T>

Mat< 4, 4, T > ufo::perspective	(	T	fovy,
		T	aspect,
		T	near,
		T	far
	)

Builds a perspective projection matrix (OpenCV convention).

Constructs a right-handed perspective matrix (+X Right, +Y Down, +Z Forward) with a [0, 1] depth range.

Template Parameters

T	Floating-point element type.

Parameters

[in]	fovy	Vertical field of view in radians.
[in]	aspect	Aspect ratio (viewport width / viewport height).
[in]	near	Near clipping distance (must be positive).
[in]	far	Far clipping distance (must be greater than near).

Returns

A Mat<4, 4, T> representing the perspective projection.

Definition at line 1412 of file mat.hpp.

perspective() [2/2]

template<std::floating_point T>

Mat< 4, 4, T > ufo::perspective	(	T	fx,
		T	fy,
		T	cx,
		T	cy,
		T	width,
		T	height,
		T	near,
		T	far
	)

Builds a perspective projection matrix (OpenCV convention).

Constructs a right-handed perspective matrix (+X Right, +Y Down, +Z Forward) from camera intrinsics (focal lengths, principal point, and resolution) with a [0, 1] depth range.

Template Parameters

T	Floating-point element type.

Parameters

[in]	fx	Horizontal focal length.
[in]	fy	Vertical focal length.
[in]	cx	Horizontal principal point (offset from center).
[in]	cy	Vertical principal point (offset from center).
[in]	width	Viewport width.
[in]	height	Viewport height.
[in]	near	Near clipping distance.
[in]	far	Far clipping distance.

Returns

A Mat<4, 4, T> representing the perspective projection.

Definition at line 1444 of file mat.hpp.

pitch()

template<std::floating_point T>

T ufo::pitch ( Quat< T > const &  q )

noexcept

Extracts the pitch angle (rotation about the Y-axis) in radians.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]

q

Unit quaternion.

Returns

Pitch angle in [-π, π].

Definition at line 918 of file quat.hpp.

premultiplyAlpha()

template<Color C>
requires ColorWithAlpha<C> && FloatingPointColor<C>

constexpr C ufo::premultiplyAlpha ( C  color )

constexprnoexcept

Returns a copy of color with each channel multiplied by its alpha value.

Requires ColorWithAlpha and FloatingPointColor.

Definition at line 278 of file alpha.hpp.

product()

template<std::size_t Dim, class T >

constexpr T ufo::product ( Vec< Dim, T > const &  v )

constexprnoexcept

Computes the product of all elements in a vector.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]

v

The vector.

Returns

v[0] * v[1] * ... * v[Dim-1].

Definition at line 1330 of file vec.hpp.

quatLookAt()

template<std::floating_point T>

Quat< T > ufo::quatLookAt	(	Vec< 3, T > const &	direction,
		Vec< 3, T > const &	up
	)

Builds a quaternion that orients an object to look in direction.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]	direction	View direction (need not be normalised).
[in]	up	World-up reference vector.

Returns

Unit quaternion representing the look-at orientation.

Definition at line 983 of file quat.hpp.

rangesDifference()

template<typename Key1 , typename Key2 >

RangeSet< Key1 > ufo::rangesDifference	(	RangeSet< Key1 > const &	a,
		RangeSet< Key2 > const &	b
	)

Creates a new RangeSet containing the ranges in a which are not find in b.

Template Parameters

Key1
Key2

Parameters

a
b

Returns

RangeSet<Key1>

Definition at line 857 of file range_set.hpp.

rangesIncludes()

template<typename Key1 , typename Key2 >

bool ufo::rangesIncludes	(	RangeSet< Key1 > const &	a,
		RangeSet< Key2 > const &	b
	)

Returns true if b is a subsequence of a.

Template Parameters

Key1
Key2

Parameters

a
b

Returns

true

false

Definition at line 827 of file range_set.hpp.

rangesIntersection()

template<typename Key1 , typename Key2 >

RangeSet< Key1 > ufo::rangesIntersection	(	RangeSet< Key1 > const &	a,
		RangeSet< Key2 > const &	b
	)

Definition at line 869 of file range_set.hpp.

rangesSymmetricDifference()

template<typename Key1 , typename Key2 >

RangeSet< Key1 > ufo::rangesSymmetricDifference	(	RangeSet< Key1 > const &	a,
		RangeSet< Key2 > const &	b
	)

Definition at line 888 of file range_set.hpp.

rangesUnion()

template<typename Key1 , typename Key2 >

RangeSet< Key1 > ufo::rangesUnion	(	RangeSet< Key1 > const &	a,
		RangeSet< Key2 > const &	b
	)

Definition at line 905 of file range_set.hpp.

read() [1/2]

template<class T >

bool ufo::read	(	std::filesystem::path const &	file,
		Image< T > &	image
	)

Definition at line 124 of file io.hpp.

read() [2/2]

template<std::size_t Dim, class T , class... Ts>

bool ufo::read	(	std::filesystem::path const &	file,
		PointCloud< Dim, T, Ts... > &	pc
	)

Definition at line 72 of file io.hpp.

readJPEG()

template<ColorType CT, class T , bool Alpha, bool Weight>

bool ufo::readJPEG	(	std::filesystem::path const &	file,
		Image< Color< CT, T, Alpha, Weight > > &	image
	)

Definition at line 69 of file jpeg.hpp.

readOBJ()

template<std::size_t Dim, class T , class... Ts>

bool ufo::readOBJ	(	std::filesystem::path const &	file,
		PointCloud< Dim, T, Ts... > &	pc
	)

Definition at line 63 of file obj.hpp.

readPCD()

template<std::size_t Dim, class T , class... Ts>

bool ufo::readPCD	(	std::filesystem::path const &	file,
		PointCloud< Dim, T, Ts... > &	pc,
		ufo::Transform3f *	viewpoint = nullptr
	)

Definition at line 74 of file pcd.hpp.

readPLY()

template<std::size_t Dim, class T , class... Ts>

bool ufo::readPLY	(	std::filesystem::path const &	file,
		PointCloud< Dim, T, Ts... > &	pc
	)

Definition at line 78 of file ply.hpp.

readPNG()

template<ColorType CT, class T , bool Alpha, bool Weight>

bool ufo::readPNG	(	std::filesystem::path const &	file,
		Image< Color< CT, T, Alpha, Weight > > &	image
	)

Reads a PNG file into an Image of the specified colour type.

Detects the PNG's internal layout (grayscale / RGB, 8- / 16-bit, with or without alpha) and decodes it into a temporary image of the closest matching native colour type, then converts each pixel to Color<CT, T, Alpha, Weight>.

Pixels with a zero alpha component have their colour channels zeroed out before the conversion step (when the source format carries alpha).

Template Parameters

CT	Colour type of the destination image (e.g. ColorType::RGB).
T	Scalar channel type of the destination image (e.g. std::uint8_t).
Alpha	Whether the destination image has an alpha channel.
Weight	Whether the destination image has a weight channel.

Parameters

file	Path to the PNG file to read.
image	Output image; resized and filled with decoded pixel data.

Returns

true on success, false if the file cannot be opened, the PNG format is unrecognised, or decoding fails.

Definition at line 138 of file png.hpp.

readPTS()

template<std::size_t Dim, class T , class... Ts>

bool ufo::readPTS	(	std::filesystem::path const &	file,
		PointCloud< Dim, T, Ts... > &	pc
	)

Definition at line 63 of file pts.hpp.

readQTP()

template<ColorType CT, class T , bool Alpha, bool Weight>

bool ufo::readQTP	(	std::filesystem::path const &	file,
		Image< Color< CT, T, Alpha, Weight > > &	image
	)

Definition at line 271 of file qtp.hpp.

readUFO() [1/2]

template<class... Ts>

bool ufo::readUFO	(	std::filesystem::path const &	file,
		Cloud< Ts... > &	cloud
	)

Definition at line 241 of file ufo.hpp.

readUFO() [2/2]

template<class... Ts>

bool ufo::readUFO ( std::istream &  in, Cloud< Ts... > &  cloud  )

inline

Definition at line 171 of file ufo.hpp.

readXYZ()

template<std::size_t Dim, class T , class... Ts>

bool ufo::readXYZ	(	std::filesystem::path const &	file,
		PointCloud< Dim, T, Ts... > &	pc
	)

Definition at line 61 of file xyz.hpp.

readXYZI()

template<std::size_t Dim, class T , class... Ts>

bool ufo::readXYZI	(	std::filesystem::path const &	file,
		PointCloud< Dim, T, Ts... > &	pc
	)

Definition at line 62 of file xyzi.hpp.

readXYZN()

template<std::size_t Dim, class T , class... Ts>

bool ufo::readXYZN	(	std::filesystem::path const &	file,
		PointCloud< Dim, T, Ts... > &	pc
	)

Definition at line 62 of file xyzn.hpp.

readXYZRGB()

template<std::size_t Dim, class T , class... Ts>

bool ufo::readXYZRGB	(	std::filesystem::path const &	file,
		PointCloud< Dim, T, Ts... > &	pc
	)

Definition at line 62 of file xyzrgb.hpp.

red() [1/2]

template<class T , ColorFlags Flags>

constexpr T ufo::red ( Lrgb< T, Flags >  color )

constexprnoexcept

Returns the un-weighted red channel value.

For floating-point weighted colors the raw red field is divided by weight; for all other combinations the raw field is returned as-is.

Definition at line 293 of file lrgb.hpp.

red() [2/2]

template<class T , ColorFlags Flags>

constexpr T ufo::red ( Rgb< T, Flags >  color )

constexprnoexcept

Returns the un-weighted red channel value.

For floating-point weighted colors the raw red field is divided by weight; for all other combinations the raw field is returned as-is.

Definition at line 293 of file rgb.hpp.

reduce() [1/2]

template<ufo::execution::ExecutionPolicy P, std::input_iterator InputIt, class T >

T ufo::reduce	(	P &&	policy,
		InputIt	first,
		InputIt	last,
		T	init
	)

Reduces the range [first, last) using init and the given execution policy.

Template Parameters

ExecutionPolicy	A UFO execution policy type.
InputIt	An input iterator type.
T	The type of the initial value and result.

Parameters

[in]	policy	The execution policy controlling parallelism.
[in]	first	Iterator to the first element.
[in]	last	Iterator one past the last element.
[in]	init	Initial value for the reduction.

Returns

The reduced value.

Definition at line 549 of file algorithm.hpp.

reduce() [2/2]

template<ufo::execution::ExecutionPolicy P, std::ranges::input_range Range, class T >

T ufo::reduce	(	P &&	policy,
		Range &&	r,
		T	init
	)

Reduces the range r using init and the given execution policy.

Template Parameters

ExecutionPolicy	A UFO execution policy type.
Range	A range type.
T	The type of the initial value and result.

Parameters

[in]	policy	The execution policy controlling parallelism.
[in]	r	The range to reduce.
[in]	init	Initial value for the reduction.

Returns

The reduced value.

Definition at line 577 of file algorithm.hpp.

reflect()

template<std::size_t Dim, std::floating_point T>

constexpr Vec< Dim, T > ufo::reflect ( Vec< Dim, T > const &  v, Vec< Dim, T > const &  n  )

constexprnoexcept

Reflects an incident vector about a surface normal.

Template Parameters

Dim	Number of dimensions.
T	Floating-point element type.

Parameters

[in]	v	The incident vector.
[in]	n	The surface normal (should be normalized).

Returns

v - 2 * dot(v, n) * n.

Definition at line 1194 of file vec.hpp.

refract()

template<std::size_t Dim, std::floating_point T>

constexpr Vec< Dim, T > ufo::refract ( Vec< Dim, T > const &  v, Vec< Dim, T > const &  n, T  eta  )

constexprnoexcept

Computes the refraction vector for an incident ray entering a new medium.

Template Parameters

Dim	Number of dimensions.
T	Floating-point element type.

Parameters

[in]	v	The normalized incident direction.
[in]	n	The normalized surface normal.
[in]	eta	The ratio of indices of refraction (n_incident / n_transmitted).

Returns

The refracted direction, or the zero vector for total internal reflection.

Definition at line 1210 of file vec.hpp.

removeAlpha()

template<Color C>

constexpr remove_alpha_t< C > ufo::removeAlpha ( C  color )

constexprnoexcept

Returns a copy of color with the alpha channel removed.

If color has no alpha channel it is returned unchanged.

Definition at line 188 of file alpha.hpp.

render() [1/4]

template<class ExecutionPolicy , class Tree , class Predicate , std::enable_if_t< pred::is_pred_v< Predicate >, bool > = true, std::enable_if_t< execution::is_execution_policy_v< ExecutionPolicy >, bool > = true>

Image< TraceResult< Tree::dimensions()> > ufo::render	(	ExecutionPolicy &&	policy,
		Tree const &	tree,
		Camera const &	camera,
		Predicate const &	pred
	)

Definition at line 94 of file render.hpp.

render() [2/4]

template<class ExecutionPolicy , class Tree , class NodeType , class Predicate , std::enable_if_t< Tree::template is_node_type_v< NodeType >, bool > = true, std::enable_if_t< pred::is_pred_v< Predicate >, bool > = true, std::enable_if_t< execution::is_execution_policy_v< ExecutionPolicy >, bool > = true>

Image< TraceResult< Tree::dimensions()> > ufo::render	(	ExecutionPolicy &&	policy,
		Tree const &	tree,
		NodeType const &	node,
		Camera const &	camera,
		Predicate const &	pred
	)

Definition at line 107 of file render.hpp.

render() [3/4]

template<class Tree , class Predicate , std::enable_if_t< pred::is_pred_v< Predicate >, bool > = true>

Image< TraceResult< Tree::dimensions()> > ufo::render	(	Tree const &	tree,
		Camera const &	camera,
		Predicate const &	pred
	)

Definition at line 63 of file render.hpp.

render() [4/4]

template<class Tree , class NodeType , class Predicate , std::enable_if_t< Tree::template is_node_type_v< NodeType >, bool > = true, std::enable_if_t< pred::is_pred_v< Predicate >, bool > = true>

Image< TraceResult< Tree::dimensions()> > ufo::render	(	Tree const &	tree,
		NodeType const &	node,
		Camera const &	camera,
		Predicate const &	pred
	)

Definition at line 73 of file render.hpp.

renderGPU() [1/2]

template<class Map , class Predicate = pred::True, std::enable_if_t< pred::is_pred_v< Predicate, Map >, bool > = true>

std::pair< Image< typename Map::Node >, Image< float > > ufo::renderGPU	(	Map const &	map,
		Camera const &	camera,
		Predicate const &	pred = pred::True{},
		bool	only_exists = true
	)

Definition at line 130 of file render.hpp.

renderGPU() [2/2]

template<class NodeType , class Map , class Predicate = pred::True, std::enable_if_t< Map::template is_node_type_v< NodeType >, bool > = true, std::enable_if_t< pred::is_pred_v< Predicate, Map >, bool > = true>

std::pair< Image< typename Map::Node >, Image< float > > ufo::renderGPU	(	NodeType const &	node,
		Map const &	map,
		Camera const &	camera,
		Predicate	pred = pred::True{},
		bool	only_exists = true
	)

Definition at line 140 of file render.hpp.

rotate()

template<std::floating_point T>

Mat< 4, 4, T > ufo::rotate	(	Mat< 4, 4, T > const &	m,
		T	angle,
		Vec< 3, T > const &	v
	)

Applies an axis-angle rotation to a 4×4 matrix.

Computes m * R where R is the 3×3 rotation matrix for the given axis and angle. The last row of m is preserved unchanged.

Template Parameters

T	Floating-point element type.

Parameters

[in]	m	The base 4×4 transformation matrix.
[in]	angle	Rotation angle in radians.
[in]	v	Rotation axis (need not be normalised).

Returns

A new Mat<4, 4, T> with the rotation applied to the upper-left 3×3 block.

Definition at line 1535 of file mat.hpp.

round()

template<std::size_t Dim, std::floating_point T>

constexpr Vec< Dim, T > ufo::round ( Vec< Dim, T >  v )

constexprnoexcept

Returns the component-wise rounding to nearest integer of a floating-point vector.

Template Parameters

Dim	Number of dimensions.
T	Floating-point element type.

Parameters

[in]

v

The vector.

Returns

A vector whose each element is round(v[i]).

Definition at line 1433 of file vec.hpp.

rtrim()

void ufo::rtrim

(

std::string &

s

)

Removes trailing whitespace from the string (in-place).

Parameters

s	Input string (modified)

Definition at line 112 of file string.cpp.

rtrimCopy()

std::string ufo::rtrimCopy

(

std::string

s

)

Returns a copy of the string with trailing whitespace removed.

Parameters

s	Input string (copy)

Returns

String with trailing whitespace removed

Definition at line 132 of file string.cpp.

sign()

template<std::size_t Dim, class T >

constexpr Vec< Dim, T > ufo::sign ( Vec< Dim, T > const &  x )

constexprnoexcept

Returns the component-wise sign of a vector.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]

x

The vector.

Returns

A vector whose element i is sign(x[i]) (−1, 0, or 1).

Definition at line 1691 of file vec.hpp.

size()

template<class... Ts>

constexpr auto ufo::size ( SoA< Ts... > const &  c )

constexpr

Definition at line 929 of file structure_of_arrays.hpp.

slerp() [1/2]

template<std::floating_point T>

Quat< T > ufo::slerp	(	Quat< T > const &	x,
		Quat< T > const &	y,
		T	a
	)

Spherical linear interpolation (SLERP) between two unit quaternions.

Automatically flips the sign of y when the dot product is negative to ensure the shorter arc is taken. Falls back to lerp near-parallel inputs.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]	x	Start unit quaternion.
[in]	y	End unit quaternion.
[in]	a	Interpolation factor in [0, 1].

Returns

Unit quaternion interpolated along the great-circle arc from x to y.

Definition at line 787 of file quat.hpp.

slerp() [2/2]

template<std::floating_point T, std::floating_point S>

Quat< T > ufo::slerp	(	Quat< T > const &	x,
		Quat< T > const &	y,
		T	a,
		S	k
	)

SLERP with k extra full spins (Graphics Gems III, page 96).

Useful for animation retargeting where extra rotations are desired.

Template Parameters

T	Floating-point scalar type.
S	Type of the spin count k (converted to T internally).

Parameters

[in]	x	Start unit quaternion.
[in]	y	End unit quaternion.
[in]	a	Interpolation factor in [0, 1].
[in]	k	Number of extra full spins to add.

Returns

Unit quaternion interpolated along the arc with k additional loops.

Definition at line 819 of file quat.hpp.

some()

template<std::size_t Dim>

constexpr bool ufo::some ( Vec< Dim, bool > const &  v )

constexprnoexcept

Returns true if some but not all components of a bool vector are true.

Template Parameters

Dim	Number of dimensions.

Parameters

[in]

v

The bool vector.

Returns

any(v) && !all(v).

Definition at line 1572 of file vec.hpp.

split()

std::vector< std::string > ufo::split	(	std::string const &	s,
		char	delimiter
	)

Splits a string into a vector of substrings using a delimiter.

Parameters

s	Input string
delimiter	Delimiter character

Returns

Vector of substrings

Author

Daniel Duberg (danie.nosp@m.ldub.nosp@m.erg@g.nosp@m.mail.nosp@m..com)

See also

https://github.com/UnknownFreeOccupied/ufo

Version

1.0

Date

2026-02-22

Copyright

Copyright (c) 2020-2026, Daniel Duberg

BSD 3-Clause License

Copyright (c) 2020-2026, Daniel Duberg All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Definition at line 51 of file string.cpp.

startsWith()

bool ufo::startsWith	(	std::string const &	s,
		std::string const &	prefix
	)

Checks if a string starts with a given prefix.

Parameters

s	Input string
prefix	Prefix string

Returns

true if s starts with prefix

Definition at line 76 of file string.cpp.

sum()

template<std::size_t Dim, class T >

constexpr T ufo::sum ( Vec< Dim, T > const &  v )

constexprnoexcept

Computes the sum of all elements in a vector.

Template Parameters

Dim	Number of dimensions.
T	Element type.

Parameters

[in]

v

The vector.

Returns

v[0] + v[1] + ... + v[Dim-1].

Definition at line 1309 of file vec.hpp.

swap() [1/5]

template<class T >

void ufo::swap ( Image< T > &  lhs, Image< T > &  rhs  )

noexcept

Swaps two images in O(1).

Parameters

lhs	First image.
rhs	Second image.

Definition at line 620 of file image.hpp.

swap() [2/5]

template<typename Key , typename T >

void ufo::swap ( RangeMap< Key, T > &  lhs, RangeMap< Key, T > &  rhs  )

noexcept

Definition at line 1198 of file range_map.hpp.

swap() [3/5]

template<typename Key >

void ufo::swap ( RangeSet< Key > &  lhs, RangeSet< Key > &  rhs  )

noexcept

Definition at line 786 of file range_set.hpp.

swap() [4/5]

template<class... Ts>

void ufo::swap	(	TreeContainer< Ts... > &	lhs,
		TreeContainer< Ts... > &	rhs
	)

Definition at line 656 of file container.hpp.

swap() [5/5]

template<std::size_t Dim>

void ufo::swap ( TreeKey< Dim > &  lhs, TreeKey< Dim > &  rhs  )

noexcept

Definition at line 193 of file key.hpp.

to_string()

constexpr std::string_view ufo::to_string ( MapType  mt )

constexpr

Definition at line 88 of file type.hpp.

tolower()

std::string ufo::tolower

(

std::string

s

)

Converts all characters in the string to lowercase.

Parameters

s	Input string (copy)

Returns

Lowercase version of the input string

Definition at line 92 of file string.cpp.

toString()

constexpr std::string_view ufo::toString ( ScalarType  type )

constexprnoexcept

Returns a human-readable string for a ScalarType value.

Parameters

type	The scalar type to convert.

Returns

A null-terminated std::string_view with a stable lifetime.

Definition at line 81 of file scalar_type.hpp.

toupper()

std::string ufo::toupper

(

std::string

s

)

Converts all characters in the string to uppercase.

Parameters

s	Input string (copy)

Returns

Uppercase version of the input string

Definition at line 99 of file string.cpp.

transform() [1/10]

template<class ExecutionPolicy , std::size_t Dim, class T , class... Rest>
requires execution::is_execution_policy_v<ExecutionPolicy>

PointCloud< Dim, T, Rest... > ufo::transform	(	ExecutionPolicy &&	policy,
		Transform< Dim, T > const &	t,
		PointCloud< Dim, T, Rest... >	pc
	)

Applies a rigid transform to every point position and returns the result, using the given execution policy.

A copy of pc is made, then transformInPlace is called on it. The original cloud is left unchanged.

Template Parameters

ExecutionPolicy	An execution policy type (e.g., execution::seq_t, execution::par_t).
Dim	Spatial dimensionality.
T	Scalar type.
Rest	Additional per-point attribute types.

Parameters

policy	Execution policy controlling parallelism.
t	The rigid transform to apply.
pc	The source point cloud (taken by value to allow move-from).

Returns

A new point cloud with transformed positions.

Definition at line 131 of file point_cloud.hpp.

transform() [2/10]

template<std::input_iterator InputIt, class OutputIt , class UnaryOp , class Proj = std::identity>

constexpr OutputIt ufo::transform ( InputIt  first1, InputIt  last1, OutputIt  d_first, UnaryOp  unary_op, Proj  proj = {}  )

constexpr

Applies unary_op to each element of [first1, last1) and writes the results to [d_first, ...) sequentially.

Template Parameters

InputIt	An input iterator type.
OutputIt	An output iterator type.
UnaryOp	A callable with signature compatible with OutputIt::value_type(InputIt::value_type).

Parameters

[in]	first1	Iterator to the first source element.
[in]	last1	Iterator one past the last source element.
[out]	d_first	Iterator to the first destination element.
[in]	unary_op	Unary transformation to apply to each source element.

Returns

Iterator one past the last written destination element.

Definition at line 275 of file algorithm.hpp.

transform() [3/10]

template<std::input_iterator InputIt1, std::input_iterator InputIt2, class OutputIt , class BinaryOp , class Proj1 = std::identity, class Proj2 = std::identity>

constexpr OutputIt ufo::transform ( InputIt1  first1, InputIt1  last1, InputIt2  first2, OutputIt  d_first, BinaryOp  binary_op, Proj1  proj1 = {}, Proj2  proj2 = {}  )

constexpr

Applies binary_op to corresponding pairs of elements from [first1, last1) and [first2, ...), writing results to [d_first, ...) sequentially.

Template Parameters

InputIt1	An input iterator type for the first source range.
InputIt2	An input iterator type for the second source range.
OutputIt	An output iterator type for the destination range.
BinaryOp	A callable with signature compatible with OutputIt::value_type(InputIt1::value_type, InputIt2::value_type).

Parameters

[in]	first1	Iterator to the first element of the first source range.
[in]	last1	Iterator one past the last element of the first source range.
[in]	first2	Iterator to the first element of the second source range.
[out]	d_first	Iterator to the first destination element.
[in]	binary_op	Binary transformation applied to each pair of source elements.

Returns

Iterator one past the last written destination element.

Definition at line 398 of file algorithm.hpp.

transform() [4/10]

template<std::ranges::input_range Range1, std::input_iterator InputIt2, std::weakly_incrementable OutputIt, class BinaryOp , class Proj1 = std::identity, class Proj2 = std::identity>
requires ( !ufo::execution::ExecutionPolicy<std::remove_cvref_t<Range1>> && std::indirectly_writable< OutputIt, std::indirect_result_t< BinaryOp, std::projected<std::ranges::iterator_t<Range1>, Proj1>, std::projected<InputIt2, Proj2>>>)

constexpr std::ranges::binary_transform_result< std::ranges::iterator_t< Range1 >, InputIt2, OutputIt > ufo::transform ( Range1 &&  r1, InputIt2  first2, OutputIt  d_first, BinaryOp  binary_op, Proj1  proj1 = {}, Proj2  proj2 = {}  )

constexpr

Applies binary_op to corresponding pairs of elements from range r1 and first2, writing results to d_first sequentially.

Template Parameters

Range1	A source range type.
InputIt2	An input iterator type for the second source range.
OutputIt	An output iterator type for the destination range.
BinaryOp	A callable with signature compatible with OutputIt::value_type(std::ranges::range_reference_t<Range1>, InputIt2::value_type).

Parameters

[in]	r1	The first source range.
[in]	first2	Iterator to the first element of the second source range.
[out]	d_first	Iterator to the first destination element.
[in]	binary_op	Binary transformation applied to each pair of source elements.

Returns

Iterator one past the last written destination element.

Definition at line 481 of file algorithm.hpp.

transform() [5/10]

template<std::ranges::input_range Range1, std::weakly_incrementable OutputIt, class UnaryOp , class Proj = std::identity>
requires ( !ufo::execution::ExecutionPolicy<std::remove_cvref_t<Range1>> && std::indirectly_writable< OutputIt, std::indirect_result_t< UnaryOp, std::projected<std::ranges::iterator_t<Range1>, Proj>>>)

constexpr std::ranges::unary_transform_result< std::ranges::iterator_t< Range1 >, OutputIt > ufo::transform ( Range1 &&  r1, OutputIt  d_first, UnaryOp  unary_op, Proj  proj = {}  )

constexpr

Applies unary_op to each element in range r1 and writes the results to d_first sequentially.

Template Parameters

Range1	A source range type.
OutputIt	An output iterator type.
UnaryOp	A callable with signature compatible with OutputIt::value_type(std::ranges::range_reference_t<Range1>).

Parameters

[in]	r1	The source range.
[out]	d_first	Iterator to the first destination element.
[in]	unary_op	Unary transformation to apply to each source element.

Returns

Iterator one past the last written destination element.

Definition at line 345 of file algorithm.hpp.

transform() [6/10]

template<ufo::execution::ExecutionPolicy T, std::random_access_iterator RandomIt1, std::random_access_iterator RandomIt2, class UnaryOp , class Proj = std::identity>
requires (!std::input_or_output_iterator<UnaryOp>)

RandomIt2 ufo::transform	(	T &&	policy,
		RandomIt1	first1,
		RandomIt1	last1,
		RandomIt2	d_first,
		UnaryOp	unary_op,
		Proj	proj = {}
	)

Applies unary_op to each element of [first1, last1) and writes the results to [d_first, ...) using the given execution policy.

Template Parameters

ExecutionPolicy	A UFO execution policy type (see execution.hpp).
RandomIt1	A random-access iterator type for the source range.
RandomIt2	A random-access iterator type for the destination range.
UnaryOp	A callable with signature compatible with RandomIt2::value_type(RandomIt1::value_type).

Parameters

[in]	policy	The execution policy controlling parallelism.
[in]	first1	Iterator to the first source element.
[in]	last1	Iterator one past the last source element.
[out]	d_first	Iterator to the first destination element.
[in]	unary_op	Unary transformation to apply to each source element.

Returns

Iterator one past the last written destination element.

Definition at line 304 of file algorithm.hpp.

transform() [7/10]

template<ufo::execution::ExecutionPolicy T, std::random_access_iterator RandomIt1, std::random_access_iterator RandomIt2, std::random_access_iterator RandomIt3, class BinaryOp , class Proj1 = std::identity, class Proj2 = std::identity>

RandomIt3 ufo::transform	(	T &&	policy,
		RandomIt1	first1,
		RandomIt1	last1,
		RandomIt2	first2,
		RandomIt3	d_first,
		BinaryOp	binary_op,
		Proj1	proj1 = {},
		Proj2	proj2 = {}
	)

Applies binary_op to corresponding pairs of elements from [first1, last1) and [first2, ...), writing results to [d_first, ...) using the given execution policy.

Template Parameters

ExecutionPolicy	A UFO execution policy type (see execution.hpp).
RandomIt1	A random-access iterator type for the first source range.
RandomIt2	A random-access iterator type for the second source range.
RandomIt3	A random-access iterator type for the destination range.
BinaryOp	A callable with signature compatible with RandomIt3::value_type(RandomIt1::value_type, RandomIt2::value_type).

Parameters

[in]	policy	The execution policy controlling parallelism.
[in]	first1	Iterator to the first element of the first source range.
[in]	last1	Iterator one past the last element of the first source range.
[in]	first2	Iterator to the first element of the second source range.
[out]	d_first	Iterator to the first destination element.
[in]	binary_op	Binary transformation applied to each pair of source elements.

Returns

Iterator one past the last written destination element.

Definition at line 431 of file algorithm.hpp.

transform() [8/10]

template<ufo::execution::ExecutionPolicy T, std::ranges::random_access_range Range1, std::random_access_iterator RandomIt2, class UnaryOp , class Proj = std::identity>
requires ( std::indirectly_writable< RandomIt2, std::indirect_result_t< UnaryOp, std::projected<std::ranges::iterator_t<Range1>, Proj>>>)

RandomIt2 ufo::transform	(	T &&	policy,
		Range1 &&	r1,
		RandomIt2	d_first,
		UnaryOp	unary_op,
		Proj	proj = {}
	)

Applies unary_op to each element in range r1 and writes the results to d_first using the given execution policy.

Template Parameters

ExecutionPolicy	A UFO execution policy type.
Range1	A random-access source range type.
RandomIt2	A random-access destination iterator type.
UnaryOp	A callable with signature compatible with RandomIt2::value_type(std::ranges::range_reference_t<Range1>).

Parameters

[in]	policy	The execution policy controlling parallelism.
[in]	r1	The source range.
[out]	d_first	Iterator to the first destination element.
[in]	unary_op	Unary transformation to apply to each source element.

Returns

Iterator one past the last written destination element.

Definition at line 372 of file algorithm.hpp.

transform() [9/10]

template<ufo::execution::ExecutionPolicy T, std::ranges::random_access_range Range1, std::random_access_iterator RandomIt2, std::random_access_iterator RandomIt3, class BinaryOp , class Proj1 = std::identity, class Proj2 = std::identity>
requires ( std::indirectly_writable< RandomIt3, std::indirect_result_t< BinaryOp, std::projected<std::ranges::iterator_t<Range1>, Proj1>, std::projected<RandomIt2, Proj2>>>)

RandomIt3 ufo::transform	(	T &&	policy,
		Range1 &&	r1,
		RandomIt2	first2,
		RandomIt3	d_first,
		BinaryOp	binary_op,
		Proj1	proj1 = {},
		Proj2	proj2 = {}
	)

Applies binary_op to corresponding pairs of elements from range r1 and first2, writing results to d_first using the given execution policy.

Template Parameters

ExecutionPolicy	A UFO execution policy type.
Range1	A random-access source range type.
RandomIt2	A random-access second source iterator type.
RandomIt3	A random-access destination iterator type.
BinaryOp	A callable with signature compatible with RandomIt3::value_type(std::ranges::range_reference_t<Range1>, RandomIt2::value_type).

Parameters

[in]	policy	The execution policy controlling parallelism.
[in]	r1	The first source range.
[in]	first2	Iterator to the first element of the second source range.
[out]	d_first	Iterator to the first destination element.
[in]	binary_op	Binary transformation applied to each pair of source elements.

Returns

Iterator one past the last written destination element.

Definition at line 523 of file algorithm.hpp.

transform() [10/10]

template<std::size_t Dim, class T , class... Rest>

PointCloud< Dim, T, Rest... > ufo::transform	(	Transform< Dim, T > const &	t,
		PointCloud< Dim, T, Rest... >	pc
	)

Applies a rigid transform to every point position and returns the result.

A copy of pc is made and transformed; the original is left unchanged. Runs sequentially (equivalent to calling the overload with execution::seq).

Template Parameters

Dim	Spatial dimensionality.
T	Scalar type.
Rest	Additional per-point attribute types (passed through unchanged).

Parameters

t	The rigid transform (rotation + translation) to apply.
pc	The source point cloud (taken by value to allow move-from).

Returns

A new point cloud with transformed positions and identical attributes.

Definition at line 105 of file point_cloud.hpp.

transformInPlace() [1/2]

template<class ExecutionPolicy , std::size_t Dim, class T , class... Rest>
requires execution::is_execution_policy_v<ExecutionPolicy>

void ufo::transformInPlace	(	ExecutionPolicy &&	policy,
		Transform< Dim, T > const &	t,
		PointCloud< Dim, T, Rest... > &	pc
	)

Applies a rigid transform to every point position in-place, using the given execution policy.

Only the position channel (channel 0) is modified; all other attribute channels are left unchanged.

Template Parameters

ExecutionPolicy	An execution policy type.
Dim	Spatial dimensionality.
T	Scalar type.
Rest	Additional per-point attribute types.

Parameters

policy	Execution policy controlling parallelism.
t	The rigid transform to apply.
pc	The point cloud to transform in-place.

Definition at line 175 of file point_cloud.hpp.

transformInPlace() [2/2]

template<std::size_t Dim, class T , class... Rest>

void ufo::transformInPlace	(	Transform< Dim, T > const &	t,
		PointCloud< Dim, T, Rest... > &	pc
	)

Applies a rigid transform to every point position in-place.

Only the position channel (channel 0) is modified; all other attribute channels are left unchanged. Runs sequentially.

Template Parameters

Dim	Spatial dimensionality.
T	Scalar type.
Rest	Additional per-point attribute types.

Parameters

t	The rigid transform to apply.
pc	The point cloud to transform in-place.

Definition at line 152 of file point_cloud.hpp.

transpose()

template<std::size_t Rows, std::size_t Cols, class T >

constexpr Mat< Cols, Rows, T > ufo::transpose ( Mat< Rows, Cols, T > const &  m )

constexprnoexcept

Returns the transpose of a matrix.

Produces a new Mat<Cols, Rows, T> where result[c][r] = m[r][c].

Template Parameters

Rows	Number of rows in m (becomes the column count of the result).
Cols	Number of columns in m (becomes the row count of the result).
T	Element type.

Parameters

[in]

m

The matrix to transpose.

Returns

The transposed matrix of shape Cols × Rows.

Definition at line 1184 of file mat.hpp.

trim()

void ufo::trim

(

std::string &

s

)

Removes leading and trailing whitespace from the string (in-place).

Parameters

s	Input string (modified)

Definition at line 120 of file string.cpp.

trimCopy()

std::string ufo::trimCopy

(

std::string

s

)

Returns a copy of the string with leading and trailing whitespace removed.

Parameters

s	Input string (copy)

Returns

String with leading and trailing whitespace removed

Definition at line 138 of file string.cpp.

trunc()

template<std::size_t Dim, std::floating_point T>

constexpr Vec< Dim, T > ufo::trunc ( Vec< Dim, T >  v )

constexprnoexcept

Returns the component-wise truncation toward zero of a floating-point vector.

Template Parameters

Dim	Number of dimensions.
T	Floating-point element type.

Parameters

[in]

v

The vector.

Returns

A vector whose each element is trunc(v[i]).

Definition at line 1418 of file vec.hpp.

unpremultiplyAlpha()

template<Color C>
requires ColorWithAlpha<C> && FloatingPointColor<C>

constexpr C ufo::unpremultiplyAlpha ( C  color )

constexprnoexcept

Returns a copy of color with each channel divided by its alpha value.

Requires ColorWithAlpha and FloatingPointColor. If the alpha value is zero or negative color is returned unchanged.

Definition at line 312 of file alpha.hpp.

view() [1/2]

template<class T , class... Ts>

constexpr auto ufo::view ( SoA< Ts... > &  soa )

constexpr

Definition at line 982 of file structure_of_arrays.hpp.

view() [2/2]

template<class T , class... Ts>

constexpr auto ufo::view ( SoA< Ts... > const &  soa )

constexpr

Definition at line 988 of file structure_of_arrays.hpp.

write() [1/2]

template<class T >

bool ufo::write	(	std::filesystem::path const &	file,
		Image< T > const &	image
	)

Definition at line 147 of file io.hpp.

write() [2/2]

template<std::size_t Dim, class T , class... Ts>

bool ufo::write	(	std::filesystem::path const &	file,
		PointCloud< Dim, T, Ts... > const &	pc
	)

Definition at line 96 of file io.hpp.

writeJPEG()

template<ColorType CT, class T , bool Alpha, bool Weight>

bool ufo::writeJPEG	(	std::filesystem::path const &	file,
		Image< Color< CT, T, Alpha, Weight > > const &	image,
		int	quality = 90
	)

Definition at line 104 of file jpeg.hpp.

writeOBJ()

template<std::size_t Dim, class T , class... Ts>

bool ufo::writeOBJ	(	std::filesystem::path const &	file,
		PointCloud< Dim, T, Ts... > const &	pc
	)

Definition at line 127 of file obj.hpp.

writePCD()

template<std::size_t Dim, class T , class... Ts>

bool ufo::writePCD	(	std::filesystem::path const &	file,
		PointCloud< Dim, T, Ts... > const &	pc,
		bool	ascii = false,
		ufo::Transform3f	viewpoint = ufo::Transform3f()
	)

Definition at line 276 of file pcd.hpp.

writePLY()

template<std::size_t Dim, class T , class... Ts>

bool ufo::writePLY	(	std::filesystem::path const &	file,
		PointCloud< Dim, T, Ts... > const &	pc,
		bool	ascii = false
	)

Definition at line 135 of file ply.hpp.

writePNG()

template<ColorType CT, class T , bool Alpha, bool Weight>

bool ufo::writePNG	(	std::filesystem::path const &	file,
		Image< Color< CT, T, Alpha, Weight > > const &	image
	)

Writes an Image to a PNG file.

Selects the appropriate SPNG colour type and bit depth from the compile-time template parameters. If the image's colour type or scalar type differs from the canonical PNG representation, pixels are converted before writing.

Template Parameters

CT	Colour type of the source image.
T	Scalar channel type of the source image.
Alpha	Whether the source image has an alpha channel.
Weight	Whether the source image has a weight channel (stripped on output).

Parameters

file	Destination path; the file is created or truncated.
image	Source image to encode.

Returns

true on success, false if the file cannot be created or encoding fails.

Definition at line 221 of file png.hpp.

writePTS()

template<std::size_t Dim, class T , class... Ts>

bool ufo::writePTS	(	std::filesystem::path const &	file,
		PointCloud< Dim, T, Ts... > const &	pc
	)

Definition at line 123 of file pts.hpp.

writeQTP()

template<ColorType CT, class T , bool Alpha, bool Weight>

bool ufo::writeQTP	(	std::filesystem::path const &	file,
		Image< Color< CT, T, Alpha, Weight > > const &	image,
		int	quality = 90
	)

Definition at line 287 of file qtp.hpp.

writeUFO() [1/2]

template<class... Ts>

bool ufo::writeUFO	(	std::filesystem::path const &	file,
		Cloud< Ts... > const &	cloud,
		CloudUFOOptions const &	options = CloudUFOOptions()
	)

Definition at line 278 of file ufo.hpp.

writeUFO() [2/2]

template<class... Ts>

bool ufo::writeUFO	(	std::ostream &	out,
		Cloud< Ts... > const &	cloud,
		CloudUFOOptions const &	options = CloudUFOOptions()
	)

Definition at line 251 of file ufo.hpp.

writeXYZ()

template<std::size_t Dim, class T , class... Ts>

bool ufo::writeXYZ	(	std::filesystem::path const &	file,
		PointCloud< Dim, T, Ts... > const &	pc
	)

Definition at line 83 of file xyz.hpp.

writeXYZI()

template<std::size_t Dim, class T , class... Ts>

bool ufo::writeXYZI	(	std::filesystem::path const &	file,
		PointCloud< Dim, T, Ts... > const &	pc
	)

Definition at line 89 of file xyzi.hpp.

writeXYZN()

template<std::size_t Dim, class T , class... Ts>

bool ufo::writeXYZN	(	std::filesystem::path const &	file,
		PointCloud< Dim, T, Ts... > const &	pc
	)

Definition at line 90 of file xyzn.hpp.

writeXYZRGB()

template<std::size_t Dim, class T , class... Ts>

bool ufo::writeXYZRGB	(	std::filesystem::path const &	file,
		PointCloud< Dim, T, Ts... > const &	pc
	)

Definition at line 90 of file xyzrgb.hpp.

yaw()

template<std::floating_point T>

T ufo::yaw ( Quat< T > const &  q )

noexcept

Extracts the yaw angle (rotation about the Z-axis) in radians.

Template Parameters

T	Floating-point scalar type.

Parameters

[in]

q

Unit quaternion.

Returns

Yaw angle clamped to [-π/2, π/2].

Definition at line 931 of file quat.hpp.

zeros()

template<std::size_t R, std::size_t C, class T = float>

constexpr Mat< R, C, T > ufo::zeros ( )

constexprnoexcept

Returns an R × C matrix with all elements set to zero.

Template Parameters

R	Number of rows.
C	Number of columns.
T	Element type (default: float).

Returns

A zero matrix of shape R × C.

Definition at line 1204 of file mat.hpp.

Variable Documentation

contains_constructible_type_v

template<class T , class... Ts>

constexpr bool ufo::contains_constructible_type_v

inlineconstexpr

Initial value:

=
    contains_constructible_type<T, Ts...>::value

Definition at line 200 of file type_traits.hpp.

contains_convertible_type_v

template<class T , class... Ts>

constexpr bool ufo::contains_convertible_type_v

inlineconstexpr

Initial value:

=
    contains_convertible_type<T, Ts...>::value

Definition at line 212 of file type_traits.hpp.

contains_type_v

template<class T , class... Ts>

constexpr bool ufo::contains_type_v = contains_type<T, Ts...>::value

inlineconstexpr

Definition at line 189 of file type_traits.hpp.

dependent_false_v

template<class... T>

constexpr bool ufo::dependent_false_v = dependent_false<T...>::value

inlineconstexpr

Definition at line 64 of file type_traits.hpp.

index_v

template<class T , class... Types>

constexpr std::size_t ufo::index_v = index<T, Types...>::value

inlineconstexpr

Definition at line 260 of file type_traits.hpp.

is_labels_map_v

template<class Map >

constexpr bool ufo::is_labels_map_v = is_labels_map<Map>::value

inlineconstexprprotected

Definition at line 272 of file labels_map.hpp.

is_pair_v

template<class T >

constexpr bool ufo::is_pair_v = is_pair<T>::value

inlineconstexpr

Definition at line 133 of file type_traits.hpp.

is_semantic_set_map_v

template<class Map >

constexpr bool ufo::is_semantic_set_map_v = is_semantic_set_map<Map>::value

inlineconstexprprotected

Definition at line 3229 of file semantic_set_map.hpp.

is_specialization_of_v

template<template< class... > class T, class... Us>

constexpr bool ufo::is_specialization_of_v = is_specialization_of<T, Us...>::value

inlineconstexpr

Definition at line 122 of file type_traits.hpp.

is_string_v

template<class T >

constexpr bool ufo::is_string_v = is_string<T>::value

inlineconstexpr

Definition at line 275 of file type_traits.hpp.

is_tuple_v

template<class T >

constexpr bool ufo::is_tuple_v = is_tuple<T>::value

inlineconstexpr

Definition at line 144 of file type_traits.hpp.

is_unique_v

template<class T , class... Rest>

constexpr bool ufo::is_unique_v = is_unique<T, Rest...>::value

inlineconstexpr

Definition at line 178 of file type_traits.hpp.

KinectV1ErrorFunction

constexpr PolynomialSensorError const ufo::KinectV1ErrorFunction

staticconstexpr

Initial value:

{0.002797f, -0.004249f,
                                                                   0.007311}

Definition at line 83 of file sensor_error.hpp.

KinectV2ErrorFunction

constexpr ExponentialSensorError const ufo::KinectV2ErrorFunction {0.0005877f, 0.9925f}

staticconstexpr

Definition at line 85 of file sensor_error.hpp.

scalar_type_v

template<class T >

constexpr ScalarType ufo::scalar_type_v = detail::scalarTypeOf<T>()

inlineconstexpr

The ScalarType enumerator for T, or ScalarType::UNKNOWN if T is not a recognised scalar type.

Definition at line 151 of file scalar_type.hpp.

ZEDErrorFunction

constexpr ExponentialSensorError const ufo::ZEDErrorFunction {0.007437f, 0.3855f}

staticconstexpr

Definition at line 86 of file sensor_error.hpp.