(v1.0a)

Utilities for reading MATLAB "*.mat" data files. See Tomographer::MAT. More...

#include <cstdint>
#include <cerrno>
#include <complex>
#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
#include <stdexcept>
#include <sstream>
#include <initializer_list>
#include <utility>
#include <matio.h>
#include <Eigen/Core>
#include <tomographer/qit/util.h>
#include <tomographer/tools/fmt.h>

Include dependency graph for ezmatio.h:

Go to the source code of this file.

Classes
class	Tomographer::MAT::Exception
	Base Exception class for errors within our MAT routines. More...

class	Tomographer::MAT::VarError
	Exception relating to a MATLAB variable in the data file. More...

class	Tomographer::MAT::VarReadError
	Error while reading a variable from the MATLAB data file. More...

class	Tomographer::MAT::VarTypeError
	Type mismatch (wrong type requested) in a variable read from the MATLAB data file. More...

class	Tomographer::MAT::VarMatTypeError
	Unknown type of a variable present in the data file. More...

class	Tomographer::MAT::FileOpenError
	Error while opening a MATLAB file. More...

class	Tomographer::MAT::InvalidIndexError
	Invalid index or index list provided to a routine. More...

class	Tomographer::MAT::File
	A MATLAB file open for reading data. More...

class	Tomographer::MAT::DimList
	An array of ints which specifies a list of dimensions. More...

class	Tomographer::MAT::IndexList< IsRowMajor_ >
	A list of indices with an API for linear or subindices access. More...

class	Tomographer::MAT::IndexListIterator< IsRowMajor_, IntType_ >
	Utility to iterate over a multidim array by increasing linear index. More...

struct	Tomographer::MAT::VarValueDecoder< T, Enabled >
	Specializable template which takes care of decoding values. More...

class	Tomographer::MAT::Var
	A MATLAB variable in the MAT file. More...

struct	Tomographer::MAT::MatType< MatTypeId >
	Map matio's constants to C/C++ types. More...

struct	Tomographer::MAT::MatType< MAT_T_DOUBLE >
	Specialization of MatType<int MatTypeId> for MAT_T_DOUBLE. More...

struct	Tomographer::MAT::MatType< MAT_T_SINGLE >
	Specialization of MatType<int MatTypeId> for MAT_T_DOUBLE. More...

struct	Tomographer::MAT::MatType< MAT_T_INT64 >
	Specialization of MatType<int MatTypeId> for MAT_T_INT64. More...

struct	Tomographer::MAT::MatType< MAT_T_INT32 >
	Specialization of MatType<int MatTypeId> for MAT_T_INT32. More...

struct	Tomographer::MAT::MatType< MAT_T_INT16 >
	Specialization of MatType<int MatTypeId> for MAT_T_INT16. More...

struct	Tomographer::MAT::MatType< MAT_T_INT8 >
	Specialization of MatType<int MatTypeId> for MAT_T_INT8. More...

struct	Tomographer::MAT::MatType< MAT_T_UINT64 >
	Specialization of MatType<int MatTypeId> for MAT_T_UINT64. More...

struct	Tomographer::MAT::MatType< MAT_T_UINT32 >
	Specialization of MatType<int MatTypeId> for MAT_T_UINT32. More...

struct	Tomographer::MAT::MatType< MAT_T_UINT16 >
	Specialization of MatType<int MatTypeId> for MAT_T_UINT16. More...

struct	Tomographer::MAT::MatType< MAT_T_UINT8 >
	Specialization of MatType<int MatTypeId> for MAT_T_UINT8. More...

struct	Tomographer::MAT::VarValueDecoder< T, typename std::enable_if<(std::numeric_limits< T >::is_specialized\|\|Tools::is_complex< T >::value)>::type >
	Interface to read out a single value. More...

struct	Tomographer::MAT::VarShape
	Describe shape of variable and whether it is complex. More...

struct	Tomographer::MAT::GetStdVector< T_, IsRowMajor_ >
	Ask for this type in Var::value<typename T>() to get an std::vector of the data. More...

struct	Tomographer::MAT::VarValueDecoder< GetStdVector< T, IsRowMajor > >
	Specialization of VarValueDecoder<T> to obtain an std::vector<> with the matrix data. See GetStdVector. More...

struct	Tomographer::MAT::VarValueDecoder< Eigen::Matrix< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
	Decoder for Eigen::Matrix types. More...

struct	Tomographer::MAT::VarValueDecoder< std::vector< Eigen::Matrix< Scalar, Rows, Cols, Options, MaxRows, MaxCols >, Alloc > >
	Decoder for a std::vector of elements of type Eigen::Matrix. More...

Namespaces
	Tomographer
	Base namespace for the `Tomographer` project.

	Tomographer::MAT
	Utilities and helpers for reading MATLAB .mat files.

Macros
#define	MAT_SWITCH_REAL_TYPE(typ, ...)
	Useful hack to get C++ real scalar type from dynamical MAT type ID. More...

#define	MAT_SWITCH_COMPLEX_TYPE(typ, ...)
	Useful hack to get C++ complex type from dynamical MAT type ID. More...

#define	MAT_SWITCH_TYPE(matvar_ptr, ...)
	Useful hack to get C++ type from dynamical MAT type ID. More...

Functions
template<typename It , typename ValueType = typename std::iterator_traits<It>::value_type>
ValueType	Tomographer::MAT::get_numel (It begin, It end)
	Calculate the product of all dimensions. More...

std::ostream &	Tomographer::MAT::operator<< (std::ostream &out, const DimList &dlist)
	C++ output stream operators for a DimList.

template<bool IsRowMajor>
std::ostream &	Tomographer::MAT::operator<< (std::ostream &str, const IndexList< IsRowMajor > &indexlist)
	C++ output stream operator for IndexList<bool IsRowMajor> .

template<bool IsRowMajor, typename IntType >
std::ostream &	Tomographer::MAT::operator<< (std::ostream &str, const IndexListIterator< IsRowMajor, IntType > &indexlistit)
	C++ output stream operator for IndexListIterator<bool IsRowMajor, typename IntType> .

template<typename T >
VarValueDecoder< T >::RetType	Tomographer::MAT::value (const Var &var)

template<typename T , ENABLED_IF(tomo_internal::has_params_member< VarValueDecoder< T > >::value) >
VarValueDecoder< T >::RetType	Tomographer::MAT::value (const Var &var, const typename VarValueDecoder< T >::Params &params)

std::ostream &	Tomographer::MAT::operator<< (std::ostream &str, const VarShape &varshape)
	C++ output stream operator for VarShape .

Detailed Description

Utilities for reading MATLAB "*.mat" data files. See Tomographer::MAT.

Definition in file ezmatio.h.

Macro Definition Documentation

#define MAT_SWITCH_COMPLEX_TYPE	(	typ,
		...
	)

Value:

do { switch (typ) {                                                      \
    case MAT_T_DOUBLE: { typedef std::complex<typename MatType<MAT_T_DOUBLE>::Type> Type; { __VA_ARGS__; } break; } \
    case MAT_T_SINGLE: { typedef std::complex<typename MatType<MAT_T_SINGLE>::Type> Type; { __VA_ARGS__; } break; } \
    default:                                                            \
      throw VarMatTypeError( streamstr("Uknown/unsupported encoded type from matio: " \
                                       <<(typ)) );                      \
    }                                                                   \
  } while (false)

Useful hack to get C++ complex type from dynamical MAT type ID.

The MAT type ID is checked against MAT_T_DOUBLE and MAT_T_SINGLE only, and the corresponding code executed with the identifier Type defined as the appropriate C++ std::complex<T> type.

Definition at line 1203 of file ezmatio.h.

#define MAT_SWITCH_REAL_TYPE	(	typ,
		...
	)

Value:

do { switch (typ) {                                                   \
    case MAT_T_DOUBLE: { typedef typename MatType<MAT_T_DOUBLE>::Type Type; { __VA_ARGS__; } break; } \
    case MAT_T_SINGLE: { typedef typename MatType<MAT_T_SINGLE>::Type Type; { __VA_ARGS__; } break; } \
    case MAT_T_INT64: { typedef typename MatType<MAT_T_INT64>::Type Type; { __VA_ARGS__; } break; } \
    case MAT_T_INT32: { typedef typename MatType<MAT_T_INT32>::Type Type; { __VA_ARGS__; } break; } \
    case MAT_T_INT16: { typedef typename MatType<MAT_T_INT16>::Type Type; { __VA_ARGS__; } break; } \
    case MAT_T_INT8: { typedef typename MatType<MAT_T_INT8>::Type Type; { __VA_ARGS__; } break; } \
    case MAT_T_UINT64: { typedef typename MatType<MAT_T_UINT64>::Type Type; { __VA_ARGS__; } break; } \
    case MAT_T_UINT32: { typedef typename MatType<MAT_T_UINT32>::Type Type; { __VA_ARGS__; } break; } \
    case MAT_T_UINT16: { typedef typename MatType<MAT_T_UINT16>::Type Type; { __VA_ARGS__; } break; } \
    case MAT_T_UINT8: { typedef typename MatType<MAT_T_UINT8>::Type Type; { __VA_ARGS__; } break; } \
    default:                                                            \
      throw VarMatTypeError( streamstr("Uknown/unsupported encoded type from matio: " \
                                       <<(typ)) );                      \
    }                                                                   \
  } while (false)

Useful hack to get C++ real scalar type from dynamical MAT type ID.

This works like a switch(){ ... } statement, where the typ is checked against MAT_T_DOUBLE, MAT_T_SINGLE, etc. and where the given code (...) is executed with the identifier Type set to the given C++ type.

Definition at line 1179 of file ezmatio.h.

#define MAT_SWITCH_TYPE	(	matvar_ptr,
		...
	)

Value:

do {                                                                  \
    if (!(matvar_ptr)->isComplex) {                                     \
      switch ((matvar_ptr)->data_type) {                                \
      case MAT_T_DOUBLE: { typedef typename MatType<MAT_T_DOUBLE>::Type Type; { __VA_ARGS__; } break; } \
      case MAT_T_SINGLE: { typedef typename MatType<MAT_T_SINGLE>::Type Type; { __VA_ARGS__; } break; } \
      case MAT_T_INT64: { typedef typename MatType<MAT_T_INT64>::Type Type; { __VA_ARGS__; } break; } \
      case MAT_T_INT32: { typedef typename MatType<MAT_T_INT32>::Type Type; { __VA_ARGS__; } break; } \
      case MAT_T_INT16: { typedef typename MatType<MAT_T_INT16>::Type Type; { __VA_ARGS__; } break; } \
      case MAT_T_INT8: { typedef typename MatType<MAT_T_INT8>::Type Type; { __VA_ARGS__; } break; } \
      case MAT_T_UINT64: { typedef typename MatType<MAT_T_UINT64>::Type Type; { __VA_ARGS__; } break; } \
      case MAT_T_UINT32: { typedef typename MatType<MAT_T_UINT32>::Type Type; { __VA_ARGS__; } break; } \
      case MAT_T_UINT16: { typedef typename MatType<MAT_T_UINT16>::Type Type; { __VA_ARGS__; } break; } \
      case MAT_T_UINT8: { typedef typename MatType<MAT_T_UINT8>::Type Type; { __VA_ARGS__; } break; } \
      default:                                                          \
        throw VarMatTypeError( streamstr("Uknown/unsupported encoded type from matio: " \
                                         << (matvar_ptr)->data_type) ); \
      }                                                                 \
    } else {                                                            \
      switch ((matvar_ptr)->data_type) {                                \
      case MAT_T_DOUBLE: { typedef std::complex<typename MatType<MAT_T_DOUBLE>::Type> Type; { __VA_ARGS__; } break; } \
      case MAT_T_SINGLE: { typedef std::complex<typename MatType<MAT_T_SINGLE>::Type> Type; { __VA_ARGS__; } break; } \
      default:                                                          \
        throw VarMatTypeError( streamstr("Uknown/unsupported encoded type from matio: " \
                                         << (matvar_ptr)->data_type) ); \
      }                                                                 \
    }                                                                   \
  } while (false)

Useful hack to get C++ type from dynamical MAT type ID.

If the variable corresponding to matvar_ptr is of complex type, then this macro behaves just like MAT_SWITCH_REAL_TYPE. If it is of complex type, then it behaves just like MAT_SWITCH_COMPLEX_TYPE.

Definition at line 1221 of file ezmatio.h.

(v1.0a)

Classes

Namespaces

Macros

Functions

Detailed Description

Macro Definition Documentation