Namespaces
	flow

Classes
class	camera
	Camera which defines mapping from 3D spatial coordinates to 2D image coordinates. More...

class	depth_camera
	Camera which maps 3D coordinates of point to depth value in addition to the 2D image coordinates. More...

class	depth_image_camera
	Depth camera which handles mapping to integer depth values, base class. More...

class	image_camera
	Camera which handles mapping to image coordinates, base class. More...

class	projection_camera
	Pin-hole camera with projection to a planar image space. More...

class	projection_image_camera
	Pin-hole camera with mapping onto image pixel coordinates. More...

struct	mono_color
	Monochrome color, 8 bit. More...

struct	rgb_color
	RGB color, 8 bit. More...

struct	rgba_color
	RGBA color, 8 bit. More...

struct	ycbcr_color
	YCbCr color, 8 bit. More...

struct	elem_traits< mono_color >

struct	elem_traits< rgb_color >

struct	elem_traits< rgba_color >

struct	elem_traits< ycbcr_color >

class	time_span
	One-dimensional time span. More...

class	vsrs_camera_array
	Reader of camera array format used by VSRS. More...

struct	elem_traits< Eigen::Matrix< Scalar, Rows, Columns > >
	Elem traits specialization for Eigen matrix type. More...

struct	elem_traits_base
	Elem traits base class with the required members. More...

struct	elem_traits
	Default elem traits, using Elem as standard layout scalar type. More...

struct	elem_traits< std::array< T, N > >
	Elem traits specialization for `std::array<T, N>`. More...

struct	elem_traits< std::complex< T > >
	Elem traits specialization for `std::complex<T>`. More...

class	elem_tuple
	Heterogeneous tuple of items. More...

class	elem_tuple< First_elem >

struct	elem_traits< elem_tuple< Elems...> >
	Elem traits specialization of elem_tuple. More...

class	invalid_flow_graph

class	sequencing_error

class	ply_importer_error

struct	angle
	Angle, represented in radiants. More...

struct	bounding_box
	Axis-aligned 3D cuboid bounding box. More...

struct	depth_projection_parameters
	Parameters of Z to depth projection. More...

struct	plane
	Oriented plane in 3D space. More...

class	pose
	Position and orientation in space. More...

class	projection_view_frustum
	View frustum of a perspective camera, without pose. More...

struct	spherical_coordinates
	Spherical coordinates. More...

class	view_frustum
	View frustum of a perspective camera. More...

class	image
	Two-dimensional image with given pixel type. More...

class	masked_image
	Two-dimensional masked image with given pixel type. More...

class	frame_exporter
	Frame exporter, abstract base class. More...

class	frame_importer
	Frame importer, abstract base class. More...

class	ply_exporter
	Exports point cloud into PLY file. More...

class	ply_importer
	Imports point cloud from PLY file. More...

class	seekable_frame_importer
	Seekable frame importer, abstract base class. More...

class	video_exporter
	Frame exporter which writes video file. More...

class	yuv_importer
	Seekable frame importer which reads YUV file. More...

struct	masked_elem
	Nullable wrapper for elem type which adds mask. More...

class	masked_elem< Elem, std::enable_if_t< elem_traits< Elem >::is_nullable > >
	Masked elem specialization where `Elem` is already nullable. More...

struct	elem_traits< masked_elem< Elem > >
	Elem traits specialization for masked elem. More...

class	frame_format
	Format information of type-erased frame of `ndarray_view_generic`. More...

struct	ndarray_generic_properties
	Properties for construction of ndarray_generic and derived container objects. More...

class	ndarray_generic
	Array container with type erased multidimensional frames. More...

class	ndarray_timed_view_generic
	Generic ndarray_timed_view where lower dimension(s) are type-erased. More...

class	ndarray_view_generic
	Generic ndarray_view where lower dimension(s) are type-erased. More...

class	ndarray
	Multidimensional array container. More...

struct	kernel_placement
	Placement of a kernel on an `ndarray_view`. More...

class	ndarray_iterator
	Random access iterator which traverses an `ndarray_view`. More...

class	ndarray_timed_view
	Ndarray view with absolute time indices associated to first dimension. More...

class	ndarray_view
	Mapping between coordinates, indices, and addresses of multi-dimensional data. More...

class	ndcoord
	Vector of n-dimensional coordinates. More...

class	ndspan
	Cuboid n-dimensional span delimited by two `ndcoord` vectors. More...

class	event
	Synchronization primitive representing event that a thread can wait for. More...

class	sticky_event
	Event which is repeatedly received after having been notified once. More...

class	raw_allocator
	Raw allocator, allocates given number of bytes. More...

class	raw_ring_allocator
	Ring allocator, allocates ring buffer memory. More...

class	raw_null_allocator
	Null allocator, allocates virtual memory which is not used. More...

class	camera_range_point_cloud

struct	point_xyz
	Point cloud point with only XYZ coordinates. More...

struct	elem_traits< point_xyz >

struct	point_xyzrgb
	Point cloud point with XYZ coordinates, and RGB color. More...

struct	point_full
	Point cloud point with XYZ coordinates, normal vector, weight, and RGB color. More...

class	point_cloud

class	range_point_cloud

class	ndarray_ring
	Ring wrapper with concrete frame type. More...

class	ndarray_timed_ring
	Timed ring wrapper with concrete frame type. More...

class	ndarray_shared_ring
	Shared ring wrapper with concrete frame type. More...

class	ring
	Ring buffer. More...

class	shared_ring
	Timed ring buffer with changed semantics, for dual-thread use. More...

class	timed_ring
	Ring buffer which adds absolute time index to frames. More...

class	space_object
	Object that has a pose in 3D space relative to a coordinate system, base class. More...

class	stopwatch
	Stop watch which measures total time passed between start() and stop() calls. More...

Typedefs
using	real = float
	Real number type. More...

using	time_unit = std::ptrdiff_t
	Discrete time unit type. More...

using	byte = std::uint8_t
	Single byte type. More...

using	Eigen_scalar = real
	Floating point type used for Eigen objects. More...

template<std::size_t Rows, std::size_t Cols>
using	Eigen_mat = Eigen::Matrix< Eigen_scalar, Rows, Cols >

using	Eigen_vec2 = Eigen_mat< 2, 1 >

using	Eigen_vec3 = Eigen_mat< 3, 1 >

using	Eigen_vec4 = Eigen_mat< 4, 1 >

using	Eigen_mat2 = Eigen_mat< 2, 2 >

using	Eigen_mat3 = Eigen_mat< 3, 3 >

using	Eigen_mat4 = Eigen_mat< 4, 4 >

using	Eigen_translation2 = Eigen::Translation< Eigen_scalar, 2 >

using	Eigen_translation3 = Eigen::Translation< Eigen_scalar, 3 >

using	Eigen_angleaxis = Eigen::AngleAxis< Eigen_scalar >

using	Eigen_affine2 = Eigen::Transform< Eigen_scalar, 2, Eigen::Affine >

using	Eigen_affine3 = Eigen::Transform< Eigen_scalar, 3, Eigen::Affine >

using	Eigen_projective2 = Eigen::Transform< Eigen_scalar, 2, Eigen::Projective >

using	Eigen_projective3 = Eigen::Transform< Eigen_scalar, 3, Eigen::Projective >

using	Eigen_hyperplane2 = Eigen::Hyperplane< Eigen_scalar, 2 >

using	Eigen_hyperplane3 = Eigen::Hyperplane< Eigen_scalar, 3 >

using	Eigen_quaternion = Eigen::Quaternion< Eigen_scalar >

using	bool_image_kernel = ndarray< 2, bool >

using	real_image_kernel = ndarray< 2, real >

template<typename Elem >
using	masked_type = typename detail::masked_type< Elem >::type
	Add mask to type `Elem`, if not already a `masked_type`. More...

template<typename Elem >
using	unmasked_type = typename detail::unmasked_type< Elem >::type
	Remove mask to type `Elem`, if is is a `masked_type`. More...

template<std::size_t Dim>
using	ndsize = ndcoord< Dim, std::size_t >

template<std::size_t Dim>
using	ndptrdiff = ndcoord< Dim, std::ptrdiff_t >

using	timed_frame_array_view = ndarray_timed_view_generic< 1 >

using	frame_array_view = ndarray_view_generic< 1 >

using	frame_view = ndarray_view_generic< 0 >

using	frame_array_properties = ndarray_generic_properties

Enumerations
enum	debug_mode { debug_mode::inactive, debug_mode::cerr, debug_mode::file }

enum	memory_usage_advice { memory_usage_advice::normal, memory_usage_advice::sequential, memory_usage_advice::random }

enum	line_delimitor { line_delimitor::unknown, line_delimitor::LF, line_delimitor::CR, line_delimitor::CRLF }

Functions
Eigen_projective3	homography_transformation (const projection_camera &from, const projection_camera &to)

template<>
rgb_color	color_convert (const ycbcr_color &in)

bool	operator== (const mono_color &a, const mono_color &b)

bool	operator!= (const mono_color &a, const mono_color &b)

bool	operator== (const rgb_color &a, const rgb_color &b)

bool	operator!= (const rgb_color &a, const rgb_color &b)

bool	operator== (const rgba_color &a, const rgba_color &b)

bool	operator!= (const rgba_color &a, const rgba_color &b)

bool	operator== (const ycbcr_color &a, const ycbcr_color &b)

bool	operator!= (const ycbcr_color &a, const ycbcr_color &b)

template<typename Output , typename Input >
Output	color_convert (const Input &)
	Color conversion, specialized for different color formats. More...

template<>
rgba_color	color_convert (const rgb_color &in)

template<>
rgb_color	color_convert (const mono_color &in)

template<>
mono_color	color_convert (const ycbcr_color &in)

template<>
rgba_color	color_convert (const ycbcr_color &in)

template<>
rgb_color	color_convert (const rgba_color &in)

std::ostream &	operator<< (std::ostream &str, const time_span &span)

void	set_debug_mode (debug_mode mode)

void	set_no_debug_filter ()

void	set_debug_filter (const std::set< std::string > &tags)

void	initialize_debug ()

template<typename Elem >
std::enable_if_t< elem_traits < Elem >::is_nullable, bool >	is_null (const Elem &elem)

template<typename Elem >
std::enable_if_t<!elem_traits < Elem >::is_nullable, bool >	is_null (const Elem &elem)

template<std::size_t Index, typename First_elem , typename... Other_elems>
const auto &	get (const elem_tuple< First_elem, Other_elems...> &tup)
	Get element at index `Index` in elem_tuple tup. More...

template<std::size_t Index, typename First_elem , typename... Other_elems>
auto &	get (elem_tuple< First_elem, Other_elems...> &tup)

template<typename... Elems>
elem_tuple< Elems...>	make_elem_tuple (const Elems &...elems)
	Make elem_tuple with elements elems. More...

std::ostream &	operator<< (std::ostream &str, angle a)

std::istream &	operator>> (std::istream &str, angle &a)

angle	operator""_deg (long double deg)

angle	operator""_rad (long double rad)

float	minimal_distance_sq (const bounding_box &a, const bounding_box &b)

float	maximal_distance_sq (const bounding_box &a, const bounding_box &b)

float	minimal_distance_sq (const Eigen::Vector3f &p, const bounding_box &b)

float	maximal_distance_sq (const Eigen::Vector3f &p, const bounding_box &b)

std::ostream &	operator<< (std::ostream &str, const bounding_box &c)

float	maximal_distance (const bounding_box &a, const bounding_box &b)

float	minimal_distance (const bounding_box &a, const bounding_box &b)

float	minimal_distance (const Eigen::Vector3f &p, const bounding_box &b)

float	maximal_distance (const Eigen::Vector3f &p, const bounding_box &b)

float	signed_distance (const Eigen::Vector3f &pt, const plane &pl)

float	distance (const Eigen::Vector3f &pt, const plane &pl)

std::ostream &	operator<< (std::ostream &str, const pose &ps)

std::ostream &	operator<< (std::ostream &str, const spherical_coordinates &c)

template<typename Pixel >
image< Pixel >	to_image (const ndarray_view< 2, Pixel > &vw)
	Create image for given ndarray_view. More...

template<typename Pixel >
masked_image< Pixel >	to_image (const ndarray_view< 2, masked_elem< Pixel >> &vw)

bool_image_kernel	disk_image_kernel (std::size_t diameter)

bool_image_kernel	box_image_kernel (std::size_t diameter)

template<std::size_t Generic_dim, std::size_t Concrete_dim, typename Concrete_elem >
ndarray_timed_view_generic < Generic_dim >	to_generic (const ndarray_timed_view< Concrete_dim, Concrete_elem > &vw)

template<std::size_t Concrete_dim, typename Concrete_elem , std::size_t Generic_dim>
ndarray_timed_view < Concrete_dim, Concrete_elem >	from_generic (const ndarray_timed_view_generic< Generic_dim > &gen_vw, const ndsize< Concrete_dim-Generic_dim > &frame_shape)

template<std::size_t Generic_dim, std::size_t Concrete_dim, typename Concrete_elem >
ndarray_view_generic< Generic_dim >	to_generic (const ndarray_view< Concrete_dim, Concrete_elem > &vw)
	Cast input `ndarray_view` to generic `ndarray_view_generic` with given dimension. More...

template<std::size_t Concrete_dim, typename Concrete_elem , std::size_t Generic_dim>
ndarray_view< Concrete_dim, Concrete_elem >	from_generic (const ndarray_view_generic< Generic_dim > &vw, const ndsize< Concrete_dim-Generic_dim > &frame_shape)
	Cast input `ndarray_view_generic` to concrete `ndarray_view` with given dimension, frame shape and element type. More...

template<std::size_t Dim, typename T >
auto	make_ndarray (const ndarray_view< Dim, T > &vw)

template<std::size_t Dim, typename Elem , typename Kernel_elem >
kernel_placement< Dim, Elem, Kernel_elem >	place_kernel_at (const ndarray_view< Dim, Elem > &view, const ndarray_view< Dim, Kernel_elem > kernel, const ndptrdiff< Dim > &pos)
	Return kernel_placement object for placement of kernel `kernel` over `view` centered at `pos`. More...

template<std::size_t Dim, typename In_elem , typename Out_elem , typename Kernel_elem , typename Function >
void	apply_kernel (Function &&func, const ndarray_view< Dim, In_elem > &in_view, const ndarray_view< Dim, Out_elem > &out_view, const ndarray_view< Dim, Kernel_elem > kernel)
	Place `kernel` over all elements in `in_view`, and call `func` to modify corresponding `out_view` element. More...

template<typename T >
ndarray_view< 2, T >	flip (const ndarray_view< 2, T > &vw)

template<typename Output_view , typename Input_view >
Output_view	ndarray_view_cast (const Input_view &view)

template<typename Output_view , typename Input_view >
Output_view	ndarray_view_reinterpret_cast (const Input_view &in_view)

template<std::size_t Dim, typename T , typename Unary >
ndcoord< Dim, T >	transform (const ndcoord< Dim, T > &a, Unary fct)

template<std::size_t Dim, typename T , typename Binary >
ndcoord< Dim, T >	transform (const ndcoord< Dim, T > &a, const ndcoord< Dim, T > &b, Binary fct)

template<std::size_t Dim, typename T >
std::ostream &	operator<< (std::ostream &str, const ndcoord< Dim, T > &coord)

template<typename T >
std::ostream &	operator<< (std::ostream &str, const ndcoord< 0, T > &coord)

template<typename T , typename... Components>
auto	make_ndcoord (Components...c)

template<typename... Components>
auto	make_ndsize (Components...c)

template<typename... Components>
auto	make_ndptrdiff (Components...c)

template<std::size_t Dim1, std::size_t Dim2, typename T >
ndcoord< Dim1+Dim2, T >	ndcoord_cat (const ndcoord< Dim1, T > &coord1, const ndcoord< Dim2, T > &coord2)

template<std::size_t Dim1, typename T , typename Int >
ndcoord< Dim1+1, T >	ndcoord_cat (const ndcoord< Dim1, T > &coord1, Int c2)

template<std::size_t Dim2, typename T , typename Int >
ndcoord< 1+Dim2, T >	ndcoord_cat (Int c1, const ndcoord< Dim2, T > &coord2)

template<typename T >
ndcoord< 2, T >	flip (const ndcoord< 2, T > &coord)

template<std::size_t Dim, typename T >
ndspan< Dim, T >	make_ndspan (const ndcoord< Dim, T > &start, const ndcoord< Dim, T > &end)

template<std::size_t Dim, typename T >
std::ostream &	operator<< (std::ostream &str, const ndspan< Dim, T > &span)

template<std::size_t Dim, typename T >
ndspan< Dim, T >	span_intersection (const ndspan< Dim, T > &a, const ndspan< Dim, T > &b)

std::size_t	system_page_size ()
	Get page size of operating system, in bytes. More...

template<typename T >
std::size_t	round_up_to_fit_system_page_size (std::size_t n)
	Round `n` up so that `T[n]` has a size that is a multiple of the system page size. More...

std::size_t	raw_round_up_to_fit_system_page_size (std::size_t len)
	Round number of bytes `len` up to a multiple of the system page size. More...

void	set_memory_usage_advice (void *ptr, std::size_t, memory_usage_advice)
	Provide hint to operating system on how memory at `ptr` will be accessed. More...

Eigen_affine3	pose_transformation (const space_object &from, const space_object &to)

line_delimitor	detect_line_delimitor (std::istream &, std::size_t max_offset=512)
	Detects line delimitor used in given file. More...

void	read_line (std::istream &str, std::string &line, line_delimitor ld)

void	skip_line (std::istream &str, line_delimitor ld)

void	write_line (std::ostream &str, const std::string &line, line_delimitor ld)

void	end_line (std::ostream &str, line_delimitor ld)

void	flip_endianness (byte *data, std::size_t sz)

std::size_t	file_size (const std::string &filename)

std::size_t	file_size (std::ifstream &stream)

template<typename T >
void	flip_endianness (T &t)

bool	file_exists (const std::string &filename)
	Check if a file at `filename` exists. More...

template<typename Numeric >
Numeric	sq (Numeric n)
	Compute square of a number. More...

template<typename T >
T *	advance_raw_ptr (T *ptr, std::ptrdiff_t diff) noexcept
	Advance a pointer `ptr` of any type by `diff` bytes. More...

template<typename T >
T	clamp (T value, T minimum, T maximum)
	Clamp `value` between `minimum` and `maximum` value. More...

template<typename T >
T	gcd (T a, T b)
	Compute greatest common divisor of `a` and `b`. More...

template<typename T >
bool	is_power_of_two (T x)
	Check if `x` is a power of 2. More...

template<typename T >
bool	is_multiple_of (T x, T base)
	Check if `x` is a multiple of `base`, including zero. More...

template<typename T >
bool	is_nonzero_multiple_of (T x, T base)
	Check if `x` is a non-zero multiple of `base`. More...

template<typename T >
bool	is_odd (T x)
	Check if `x` is odd. More...

template<typename T >
bool	is_even (T x)
	Check if `x` is even. More...

std::vector< std::string >	explode (char separator, const std::string &str)

std::string	implode (char separator, const std::vector< std::string > &vec)

std::string	to_lower (const std::string &s_orig)

std::string	to_upper (const std::string &s_orig)

std::string	file_name_extension (const std::string &filename)

std::string	replace_file_name_extension (const std::string &filename, const std::string &ext)

std::string	remove_file_name_extension (const std::string &filename)

template<typename T >
std::string	to_string (const T &)

template<typename T >
T	from_string (const std::string &)

template<typename It >
std::string	to_string (It begin, It end, const std::string &separator=", ")

template<typename T >
std::vector< T >	explode_from_string (char separator, const std::string &)

template<typename T >
std::string	implode_to_string (char separator, const std::vector< T > &)

Variables
template<typename T , typename Tuple >
constexpr std::ptrdiff_t	elem_tuple_index = -1
	Index of first element of type `T` in elem_tuple type `Tuple`. More...

template<typename T , typename First_elem , typename... Other_elems>
constexpr std::ptrdiff_t	elem_tuple_index< T, elem_tuple< First_elem, Other_elems...> > = 1 + elem_tuple_index<T, elem_tuple<Other_elems...>>

template<typename T , typename... Other_elems>
constexpr std::ptrdiff_t	elem_tuple_index< T, elem_tuple< T, Other_elems...> > = 0

template<std::size_t Index, typename Tuple >
constexpr std::ptrdiff_t	elem_tuple_offset = -1
	Offset in bytes of element at index `Index` in elem_tuple type `Tuple`. More...

template<std::size_t Index, typename First_elem , typename... Other_elems>
constexpr std::ptrdiff_t	elem_tuple_offset< Index, elem_tuple< First_elem, Other_elems...> >

constexpr real	pi = 3.14159265358979323846264338327950288

constexpr real	half_pi = pi / 2.0

constexpr real	quarter_pi = pi / 4.0

constexpr real	two_pi = pi * 2.0

constexpr real	four_pi = pi * 4.0

constexpr real	radiant_per_degree = pi / 180.0

constexpr real	degree_per_radiant = 180.0 / pi

const line_delimitor	default_line_delimitor = line_delimitor::LF

const bool	host_has_iec559_float

const bool	host_is_little_endian = check_host_little_endian_()

Typedef Documentation

using mf::bool_image_kernel = typedef ndarray<2, bool>

using mf::byte = typedef std::uint8_t

Single byte type.

using mf::Eigen_affine2 = typedef Eigen::Transform<Eigen_scalar, 2, Eigen::Affine>

using mf::Eigen_affine3 = typedef Eigen::Transform<Eigen_scalar, 3, Eigen::Affine>

using mf::Eigen_angleaxis = typedef Eigen::AngleAxis<Eigen_scalar>

using mf::Eigen_hyperplane2 = typedef Eigen::Hyperplane<Eigen_scalar, 2>

using mf::Eigen_hyperplane3 = typedef Eigen::Hyperplane<Eigen_scalar, 3>

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

using mf::Eigen_mat = typedef Eigen::Matrix<Eigen_scalar, Rows, Cols>

using mf::Eigen_mat2 = typedef Eigen_mat<2, 2>

using mf::Eigen_mat3 = typedef Eigen_mat<3, 3>

using mf::Eigen_mat4 = typedef Eigen_mat<4, 4>

using mf::Eigen_projective2 = typedef Eigen::Transform<Eigen_scalar, 2, Eigen::Projective>

using mf::Eigen_projective3 = typedef Eigen::Transform<Eigen_scalar, 3, Eigen::Projective>

using mf::Eigen_quaternion = typedef Eigen::Quaternion<Eigen_scalar>

using mf::Eigen_scalar = typedef real

Floating point type used for Eigen objects.

using mf::Eigen_translation2 = typedef Eigen::Translation<Eigen_scalar, 2>

using mf::Eigen_translation3 = typedef Eigen::Translation<Eigen_scalar, 3>

using mf::Eigen_vec2 = typedef Eigen_mat<2, 1>

using mf::Eigen_vec3 = typedef Eigen_mat<3, 1>

using mf::Eigen_vec4 = typedef Eigen_mat<4, 1>

using mf::frame_array_properties = typedef ndarray_generic_properties

using mf::frame_array_view = typedef ndarray_view_generic<1>

using mf::frame_view = typedef ndarray_view_generic<0>

template<typename Elem >

using mf::masked_type = typedef typename detail::masked_type<Elem>::type

Add mask to type Elem, if not already a masked_type.

template<std::size_t Dim>

using mf::ndptrdiff = typedef ndcoord<Dim, std::ptrdiff_t>

template<std::size_t Dim>

using mf::ndsize = typedef ndcoord<Dim, std::size_t>

using mf::real = typedef float

Real number type.

using mf::real_image_kernel = typedef ndarray<2, real>

using mf::time_unit = typedef std::ptrdiff_t

Discrete time unit type.

using mf::timed_frame_array_view = typedef ndarray_timed_view_generic<1>

template<typename Elem >

using mf::unmasked_type = typedef typename detail::unmasked_type<Elem>::type

Remove mask to type Elem, if is is a masked_type.

Enumeration Type Documentation

enum mf::debug_mode

strong

Enumerator
inactive
cerr
file

enum mf::line_delimitor

strong

Enumerator
unknown
LF
CR
CRLF

enum mf::memory_usage_advice

strong

Enumerator
normal
sequential
random

Function Documentation

template<typename T >

T * mf::advance_raw_ptr	(	T *	ptr,
		std::ptrdiff_t	diff
	)

inlinenoexcept

Advance a pointer ptr of any type by diff bytes.

Pointer may be void* or any other pointer type. Does not verify alignment.

template<std::size_t Dim, typename In_elem , typename Out_elem , typename Kernel_elem , typename Function >

void mf::apply_kernel	(	Function &&	func,
		const ndarray_view< Dim, In_elem > &	in_view,
		const ndarray_view< Dim, Out_elem > &	out_view,
		const ndarray_view< Dim, Kernel_elem >	kernel
	)

Place kernel over all elements in in_view, and call func to modify corresponding out_view element.

Parameters

func	Function `void(const kernel_placement<Dim, In_elem, Kernel_elem>&, Out_elem&)`.
in_view	View over which kernel gets applied. `In_elem` may be const.
out_view	View whose elements get modified by kernel. Must be same shape as `in_view`.
kernel	The kernel.

bool_image_kernel mf::box_image_kernel ( std::size_t diameter )

template<typename T >

T mf::clamp	(	T	value,
		T	minimum,
		T	maximum
	)

inline

Clamp value between minimum and maximum value.

template<>

rgb_color mf::color_convert ( const ycbcr_color & in )

template<typename Output , typename Input >

Output mf::color_convert ( const Input & )

Color conversion, specialized for different color formats.

template<>

rgba_color mf::color_convert ( const rgb_color & in )

inline

template<>

rgb_color mf::color_convert ( const mono_color & in )

inline

template<>

mono_color mf::color_convert ( const ycbcr_color & in )

inline

template<>

rgba_color mf::color_convert ( const ycbcr_color & in )

inline

template<>

rgb_color mf::color_convert ( const rgba_color & in )

inline

line_delimitor mf::detect_line_delimitor	(	std::istream &	,
		std::size_t	max_offset = `512`
	)

Detects line delimitor used in given file.

Reads up to max_offset characters into file until line delimitor is found. Reads from current stream position, and rewinds to that starting position afterwards. Throws exception if no line ending detected.

bool_image_kernel mf::disk_image_kernel ( std::size_t diameter )

float mf::distance	(	const Eigen::Vector3f &	pt,
		const plane &	pl
	)

void mf::end_line	(	std::ostream &	str,
		line_delimitor	ld
	)

std::vector< std::string > mf::explode	(	char	separator,
		const std::string &	str
	)

template<typename T >

std::vector< T > mf::explode_from_string	(	char	separator,
		const std::string &	str
	)

bool mf::file_exists ( const std::string & filepath )

Check if a file at filename exists.

std::string mf::file_name_extension ( const std::string & filename )

std::size_t mf::file_size ( const std::string & filename )

std::size_t mf::file_size ( std::ifstream & stream )

template<typename T >

ndarray_view<2, T> mf::flip ( const ndarray_view< 2, T > & vw )

template<typename T >

ndcoord<2, T> mf::flip ( const ndcoord< 2, T > & coord )

template<typename T >

void mf::flip_endianness ( T & t )

void mf::flip_endianness	(	byte *	data,
		std::size_t	sz
	)

template<std::size_t Concrete_dim, typename Concrete_elem , std::size_t Generic_dim>

ndarray_timed_view<Concrete_dim, Concrete_elem> mf::from_generic	(	const ndarray_timed_view_generic< Generic_dim > &	gen_vw,
		const ndsize< Concrete_dim-Generic_dim > &	frame_shape
	)

template<std::size_t Concrete_dim, typename Concrete_elem , std::size_t Generic_dim>

ndarray_view< Concrete_dim, Concrete_elem > mf::from_generic	(	const ndarray_view_generic< Generic_dim > &	vw,
		const ndsize< Concrete_dim-Generic_dim > &	frame_shape
	)

Cast input ndarray_view_generic to concrete ndarray_view with given dimension, frame shape and element type.

template<typename T >

T mf::from_string ( const std::string & s )

template<typename T >

T mf::gcd	(	T	a,
		T	b
	)

Compute greatest common divisor of a and b.

template<std::size_t Index, typename First_elem , typename... Other_elems>

const auto & mf::get ( const elem_tuple< First_elem, Other_elems...> & tup )

Get element at index Index in elem_tuple tup.

Get first element of type T in elem_tuple tup.

template<std::size_t Index, typename First_elem , typename... Other_elems>

auto & mf::get ( elem_tuple< First_elem, Other_elems...> & tup )

Eigen_projective3 mf::homography_transformation	(	const projection_camera &	from,
		const projection_camera &	to
	)

std::string mf::implode	(	char	separator,
		const std::vector< std::string > &	vec
	)

template<typename T >

std::string mf::implode_to_string	(	char	separator,
		const std::vector< T > &	vec
	)

void mf::initialize_debug ( )

template<typename T >

bool mf::is_even ( T x )

Check if x is even.

template<typename T >

bool mf::is_multiple_of	(	T	x,
		T	base
	)

Check if x is a multiple of base, including zero.

template<typename T >

bool mf::is_nonzero_multiple_of	(	T	x,
		T	base
	)

Check if x is a non-zero multiple of base.

template<typename Elem >

std::enable_if_t<elem_traits<Elem>::is_nullable, bool> mf::is_null ( const Elem & elem )

template<typename Elem >

std::enable_if_t<! elem_traits<Elem>::is_nullable, bool> mf::is_null ( const Elem & elem )

template<typename T >

bool mf::is_odd ( T x )

Check if x is odd.

template<typename T >

bool mf::is_power_of_two ( T x )

Check if x is a power of 2.

template<typename... Elems>

elem_tuple<Elems...> mf::make_elem_tuple ( const Elems &... elems )

Make elem_tuple with elements elems.

template<std::size_t Dim, typename T >

auto mf::make_ndarray ( const ndarray_view< Dim, T > & vw )

template<typename T , typename... Components>

auto mf::make_ndcoord ( Components... c )

template<typename... Components>

auto mf::make_ndptrdiff ( Components... c )

template<typename... Components>

auto mf::make_ndsize ( Components... c )

template<std::size_t Dim, typename T >

ndspan<Dim, T> mf::make_ndspan	(	const ndcoord< Dim, T > &	start,
		const ndcoord< Dim, T > &	end
	)

float mf::maximal_distance	(	const bounding_box &	a,
		const bounding_box &	b
	)

inline

float mf::maximal_distance	(	const Eigen::Vector3f &	p,
		const bounding_box &	b
	)

inline

float mf::maximal_distance_sq	(	const bounding_box &	a,
		const bounding_box &	b
	)

float mf::maximal_distance_sq	(	const Eigen::Vector3f &	p,
		const bounding_box &	b
	)

float mf::minimal_distance	(	const bounding_box &	a,
		const bounding_box &	b
	)

inline

float mf::minimal_distance	(	const Eigen::Vector3f &	p,
		const bounding_box &	b
	)

inline

float mf::minimal_distance_sq	(	const bounding_box &	a,
		const bounding_box &	b
	)

float mf::minimal_distance_sq	(	const Eigen::Vector3f &	p,
		const bounding_box &	b
	)

template<typename Output_view , typename Input_view >

Output_view mf::ndarray_view_cast ( const Input_view & view )

template<typename Output_view , typename Input_view >

Output_view mf::ndarray_view_reinterpret_cast ( const Input_view & in_view )

template<std::size_t Dim1, std::size_t Dim2, typename T >

ndcoord<Dim1 + Dim2, T> mf::ndcoord_cat	(	const ndcoord< Dim1, T > &	coord1,
		const ndcoord< Dim2, T > &	coord2
	)

template<std::size_t Dim1, typename T , typename Int >

ndcoord<Dim1 + 1, T> mf::ndcoord_cat	(	const ndcoord< Dim1, T > &	coord1,
		Int	c2
	)

template<std::size_t Dim2, typename T , typename Int >

ndcoord<1 + Dim2, T> mf::ndcoord_cat	(	Int	c1,
		const ndcoord< Dim2, T > &	coord2
	)

bool mf::operator!=	(	const mono_color &	a,
		const mono_color &	b
	)

bool mf::operator!=	(	const rgb_color &	a,
		const rgb_color &	b
	)

bool mf::operator!=	(	const rgba_color &	a,
		const rgba_color &	b
	)

bool mf::operator!=	(	const ycbcr_color &	a,
		const ycbcr_color &	b
	)

angle mf::operator""_deg ( long double deg )

inline

angle mf::operator""_rad ( long double rad )

inline

std::ostream & mf::operator<<	(	std::ostream &	str,
		angle	a
	)

std::ostream & mf::operator<<	(	std::ostream &	str,
		const pose &	ps
	)

std::ostream & mf::operator<<	(	std::ostream &	str,
		const spherical_coordinates &	c
	)

template<std::size_t Dim, typename T >

std::ostream& mf::operator<<	(	std::ostream &	str,
		const ndspan< Dim, T > &	span
	)

std::ostream& mf::operator<<	(	std::ostream &	str,
		const time_span &	span
	)

inline

template<std::size_t Dim, typename T >

std::ostream& mf::operator<<	(	std::ostream &	str,
		const ndcoord< Dim, T > &	coord
	)

template<typename T >

std::ostream& mf::operator<<	(	std::ostream &	str,
		const ndcoord< 0, T > &	coord
	)

std::ostream& mf::operator<<	(	std::ostream &	str,
		const bounding_box &	c
	)

bool mf::operator==	(	const mono_color &	a,
		const mono_color &	b
	)

bool mf::operator==	(	const rgb_color &	a,
		const rgb_color &	b
	)

bool mf::operator==	(	const rgba_color &	a,
		const rgba_color &	b
	)

bool mf::operator==	(	const ycbcr_color &	a,
		const ycbcr_color &	b
	)

std::istream & mf::operator>>	(	std::istream &	str,
		angle &	a
	)

template<std::size_t Dim, typename Elem , typename Kernel_elem >

kernel_placement< Dim, Elem, Kernel_elem > mf::place_kernel_at	(	const ndarray_view< Dim, Elem > &	view,
		const ndarray_view< Dim, Kernel_elem >	kernel,
		const ndptrdiff< Dim > &	pos
	)

Return kernel_placement object for placement of kernel kernel over view centered at pos.

Kernel shape must be odd in all axis. When pos is near limits of view span, the sections get truncated.

Eigen_affine3 mf::pose_transformation	(	const space_object &	from,
		const space_object &	to
	)

inline

std::size_t mf::raw_round_up_to_fit_system_page_size ( std::size_t len )

inline

Round number of bytes len up to a multiple of the system page size.

void mf::read_line	(	std::istream &	str,
		std::string &	line,
		line_delimitor	ld
	)

std::string mf::remove_file_name_extension ( const std::string & filename )

std::string mf::replace_file_name_extension	(	const std::string &	filename,
		const std::string &	ext
	)

template<typename T >

std::size_t mf::round_up_to_fit_system_page_size ( std::size_t n )

Round n up so that T[n] has a size that is a multiple of the system page size.

void mf::set_debug_filter ( const std::set< std::string > & tags )

void mf::set_debug_mode ( debug_mode mode )

void mf::set_memory_usage_advice	(	void *	ptr,
		std::size_t	,
		memory_usage_advice
	)

Provide hint to operating system on how memory at ptr will be accessed.

void mf::set_no_debug_filter ( )

float mf::signed_distance	(	const Eigen::Vector3f &	pt,
		const plane &	pl
	)

void mf::skip_line	(	std::istream &	str,
		line_delimitor	ld
	)

template<std::size_t Dim, typename T >

ndspan< Dim, T > mf::span_intersection	(	const ndspan< Dim, T > &	a,
		const ndspan< Dim, T > &	b
	)

template<typename Numeric >

Numeric mf::sq ( Numeric n )

Compute square of a number.

std::size_t mf::system_page_size ( )

Get page size of operating system, in bytes.

template<std::size_t Generic_dim, std::size_t Concrete_dim, typename Concrete_elem >

ndarray_timed_view_generic<Generic_dim> mf::to_generic ( const ndarray_timed_view< Concrete_dim, Concrete_elem > & vw )

template<std::size_t Generic_dim, std::size_t Concrete_dim, typename Concrete_elem >

ndarray_view_generic< Generic_dim > mf::to_generic ( const ndarray_view< Concrete_dim, Concrete_elem > & vw )

Cast input ndarray_view to generic ndarray_view_generic with given dimension.

Generic_dim is dimension of generic ndarray, i.e. Dim of ndarray_view_generic<Dim>. Concrete_dim is dimension of the typed ndarray, i.e. Dim of ndarray_view<Dim>. Always Concrete_dim >= Generic_dim. Dimension of frame is Concrete_dim - Generic_dim.

template<typename Pixel >

image<Pixel> mf::to_image ( const ndarray_view< 2, Pixel > & vw )

Create image for given ndarray_view.

template<typename Pixel >

masked_image<Pixel> mf::to_image ( const ndarray_view< 2, masked_elem< Pixel >> & vw )

std::string mf::to_lower ( const std::string & s_orig )

template<typename T >

std::string mf::to_string ( const T & t )

template<typename It >

std::string mf::to_string	(	It	begin,
		It	end,
		const std::string &	separator = `", "`
	)

std::string mf::to_upper ( const std::string & s_orig )

template<std::size_t Dim, typename T , typename Unary >

ndcoord<Dim, T> mf::transform	(	const ndcoord< Dim, T > &	a,
		Unary	fct
	)

template<std::size_t Dim, typename T , typename Binary >

ndcoord<Dim, T> mf::transform	(	const ndcoord< Dim, T > &	a,
		const ndcoord< Dim, T > &	b,
		Binary	fct
	)

void mf::write_line	(	std::ostream &	str,
		const std::string &	line,
		line_delimitor	ld
	)

Variable Documentation

const line_delimitor mf::default_line_delimitor = line_delimitor::LF

constexpr real mf::degree_per_radiant = 180.0 / pi

template<typename T , typename Tuple >

constexpr std::ptrdiff_t mf::elem_tuple_index = -1

Index of first element of type T in elem_tuple type Tuple.

template<typename T , typename First_elem , typename... Other_elems>

constexpr std::ptrdiff_t mf::elem_tuple_index< T, elem_tuple< First_elem, Other_elems...> > = 1 + elem_tuple_index<T, elem_tuple<Other_elems...>>

template<typename T , typename... Other_elems>

constexpr std::ptrdiff_t mf::elem_tuple_index< T, elem_tuple< T, Other_elems...> > = 0

template<std::size_t Index, typename Tuple >

constexpr std::ptrdiff_t mf::elem_tuple_offset = -1

Offset in bytes of element at index Index in elem_tuple type Tuple.

template<std::size_t Index, typename First_elem , typename... Other_elems>

constexpr std::ptrdiff_t mf::elem_tuple_offset< Index, elem_tuple< First_elem, Other_elems...> >

Initial value:

=

detail::elem_tuple_accessor<Index, elem_tuple<First_elem, Other_elems...>>::offset()

constexpr real mf::four_pi = pi * 4.0

constexpr real mf::half_pi = pi / 2.0

const bool mf::host_has_iec559_float

Initial value:

=

std::numeric_limits<float>::is_iec559 && std::numeric_limits<double>::is_iec559

const bool mf::host_is_little_endian = check_host_little_endian_()

constexpr real mf::pi = 3.14159265358979323846264338327950288

constexpr real mf::quarter_pi = pi / 4.0

constexpr real mf::radiant_per_degree = pi / 180.0

constexpr real mf::two_pi = pi * 2.0

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation