mat_reader.h

Go to the documentation of this file.

 
#ifndef MAT_READER_H
#define MAT_READER_H
 
#include <matio.h>
#include <opencv2/core.hpp>
#include <string>
#include <vector>
#include <map>
#include <memory>
 
namespace cppxdic {
 
// DLT calibration data (loaded from DLTstruct_cam_<id>.mat)
// Matches MATLAB DLTstructCam struct fields
struct DLTCalibrationData {
    std::vector<double> DLTparams;          // 11 DLT parameters
    std::vector<double> C3Dtrue;            // 3D calibration points (dim0 x dim1 x 3, column-major flattened to row-major)
    size_t C3Dtrue_dim0 = 0;               // First dimension (e.g., 10)
    size_t C3Dtrue_dim1 = 0;               // Second dimension (e.g., 45)
    std::vector<double> imageCentroids;     // 2D image centroids (Nx2, row-major)
    size_t imageCentroids_rows = 0;         // Number of centroid points
    std::vector<uint8_t> columns;           // Column indices used in calibration
    int indCam = 0;                         // Camera index
    std::string filePath;                   // Source file path (for traceability)
};
 
// Protocol file data structure (loaded from MAT file)
struct ProtocolFileData {
    struct TrialEntry {
        int trial_number;
        std::string direction;  // "Ubnf", "Rbnf", etc.
        double force;          // Normal force in N
        double speed;          // Speed in mm/s
        int repetition;        // Repetition number
    };
 
    std::vector<std::string> titles;  // Column names
    std::vector<TrialEntry> trials;   // Trial information
    size_t n_trials;
    size_t n_fields;
};
 
class MatReader {
public:
    // -------- RAII helpers (reusable across the project) --------
    struct MatFileDeleter {
        void operator()(mat_t* f) const noexcept { if (f) Mat_Close(f); }
    };
    struct MatVarDeleter {
        void operator()(matvar_t* v) const noexcept { if (v) Mat_VarFree(v); }
    };
 
    using MatFilePtr = std::unique_ptr<mat_t, MatFileDeleter>;
    using MatVarPtr  = std::unique_ptr<matvar_t, MatVarDeleter>;
 
    // Optional convenience helpers (non-breaking additions)
    static MatFilePtr openMat(const std::string& path);
    static MatVarPtr  readVar(mat_t* matfp, const std::string& name);     // top-level
    static MatVarPtr  readFirstVar(mat_t* matfp);                         // first variable in file
 
    // DLT calibration loading (DLTstruct_cam_<id>.mat)
    static bool loadDLTCalibration(const std::string& mat_path, DLTCalibrationData& calib);
 
    // Protocol loading
    static bool loadProtocol(const std::string& protocol_path, ProtocolFileData& protocol);
    static std::vector<std::string> readCellStrings(matvar_t* cell_var);
 
    static matvar_t* readStructField(mat_t* matfp,
                                    const std::string& struct_name,
                                    const std::string& field_name);
 
    static matvar_t* readNestedField(mat_t* matfp, const std::string& path);
 
    static std::vector<double> readDoubleArray(matvar_t* var);
    
    static std::vector<double> readDouble2DArray(matvar_t* var, size_t& rows, size_t& cols);
    
    static cv::Mat readImage(matvar_t* var);
    
    static double readScalar(matvar_t* var);
    
    static std::string readString(matvar_t* var);
 
    static size_t getCellArraySize(matvar_t* var);
 
    static matvar_t* getCellElement(matvar_t* var, size_t index);
 
    static std::map<std::string, double> readDispInfo(mat_t* matfp);
    
    static bool variableExists(mat_t* matfp, const std::string& var_name);
 
    static cv::Mat readROIMask(const std::string& mat_path,
                              const std::string& var_name = "refmask");
 
    static bool readDIC3Dcombined(const std::string& mat_path,
                                 struct DIC3Dcombined& combined);
    
    static bool readDIC2DPairResults(const std::string& mat_path,
                                    struct DIC2DPairResults& result);
 
    static std::vector<int> readIntArray(matvar_t* var);
 
private:
    // Internal helpers to reduce repetition across all readers
    static matvar_t* getStructField(matvar_t* s, const char* field, size_t index = 0) noexcept;
    static bool readDIC2DPairResultsFromStruct(matvar_t* dic2d_root,
                                               struct DIC2DPairResults& result);
 
    static bool readTopInt(mat_t* matfp, const char* name, int& out) noexcept;
    static bool readTopDouble(mat_t* matfp, const char* name, double& out) noexcept;
    static bool readTopString(mat_t* matfp, const char* name, std::string& out);
 
    static bool readStructInt(matvar_t* s, const char* field, int& out, size_t index = 0) noexcept;
    static bool readStructDouble(matvar_t* s, const char* field, double& out, size_t index = 0) noexcept;
    static bool readStructBool(matvar_t* s, const char* field, bool& out, size_t index = 0) noexcept;
    static bool readStructString(matvar_t* s, const char* field, std::string& out, size_t index = 0);
};
 
} // namespace cppxdic
 
#endif // MAT_READER_H