mf
Media Framework
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
mf Namespace Reference

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 >
clamp (T value, T minimum, T maximum)
 Clamp value between minimum and maximum value. More...
 
template<typename 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 >
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>
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.

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 
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
funcFunction void(const kernel_placement<Dim, In_elem, Kernel_elem>&, Out_elem&).
in_viewView over which kernel gets applied. In_elem may be const.
out_viewView whose elements get modified by kernel. Must be same shape as in_view.
kernelThe kernel.
bool_image_kernel mf::box_image_kernel ( std::size_t  diameter)
template<typename T >
T mf::clamp ( value,
minimum,
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 ( a,
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 ( x)

Check if x is even.

template<typename T >
bool mf::is_multiple_of ( x,
base 
)

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

template<typename T >
bool mf::is_nonzero_multiple_of ( x,
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 ( x)

Check if x is odd.

template<typename T >
bool mf::is_power_of_two ( 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