mat_writer.h

Go to the documentation of this file.

 
#ifndef MAT_WRITER_H
#define MAT_WRITER_H
 
#include <matio.h>
#include <ncorr.h>
#include <opencv2/opencv.hpp>
#include <Eigen/Dense>
#include <string>
#include <vector>
#include <map>
#include "dic_structures.h"
#include "strain_computation.h"
 
namespace cppxdic {
 
class MatWriter {
public:
    static bool writeMatchingFile(const std::string& filename,
                                 const cv::Mat& ref_img,
                                 const cv::Mat& cur_img,
                                 const cv::Mat& ref_roi,
                                 const cv::Mat& cur_roi,
                                 const ncorr::DIC_analysis_output& dic_output,
                                 const std::map<std::string, double>& dispinfo);
    
    static bool writeMatchingFile(const std::string& filename,
                                 const cv::Mat& ref_img,
                                 const cv::Mat& cur_img,
                                 const cv::Mat& ref_roi,
                                 const cv::Mat& cur_roi,
                                 const ncorr::DIC_analysis_output& dic_lagrangian,
                                 const ncorr::DIC_analysis_output& dic_eulerian,
                                 const std::map<std::string, double>& dispinfo);
    
    static bool writeROIMaskFile(const std::string& filename,
                                const cv::Mat& mask);
    
    static bool writeSeedFile(const std::string& filename,
                            int seed_x,
                            int seed_y);
    
    static bool writeTrialInfoFile(const std::string& filename,
                                  double fps,
                                  const std::vector<int>& frame_indices);
    
    static bool writeMultiFrameNcorrFile(const std::string& filename,
                                        const cv::Mat& ref_img,
                                        const std::vector<cv::Mat>& cur_imgs,
                                        const cv::Mat& ref_roi,
                                        const std::vector<cv::Mat>& cur_rois,
                                        const std::vector<ncorr::DIC_analysis_output>& dic_outputs,
                                        const std::map<std::string, double>& dispinfo,
                                        const std::string& type_str = "load",
                                        const std::string& ref_name = "reference");
    
    static bool writeDICResultFile(const std::string& filename,
                                  const ncorr::DIC_analysis_input& dic_input,
                                  const ncorr::DIC_analysis_output& dic_output);
    
    static bool convertBinToMat(const std::string& bin_path,
                                const std::string& mat_path,
                                const ncorr::DIC_analysis_input& dic_input);
    
    static bool writeDIC2DPairResults(const std::string& filename,
                                      const DIC2DPairResults& results);
    
    static bool write3DCombinedResults(const std::string& filename,
                                       const DIC3Dcombined& combined,
                                       const std::string& struct_name = "DIC3Dcombined");
    
    static matvar_t* buildCombinedStructFields(mat_t* matfp,
                                                const DIC3Dcombined& combined,
                                                const std::string& struct_name,
                                                const std::vector<std::string>& extra_fields = {});
    
    static bool write3DPPresults(const std::string& filename,
                                const DIC3DPPresults& ppresults);
    
    static bool writeDeformationGroup(mat_t* matfp,
                                      const std::string& group_name,
                                      const FrameDeformationResult& deform_data);
    
    static matvar_t* buildDeformationStruct(const std::string& group_name,
                                             const FrameDeformationResult& deform_data);
    
    static bool writeDisplacementGroup(mat_t* matfp,
                                       const std::vector<std::vector<Eigen::Vector3d>>& disp_vec,
                                       const std::vector<std::vector<double>>& disp_mgn,
                                       size_t n_frames);
    
    static bool writeFaceArrays(mat_t* matfp,
                               const std::vector<std::vector<Eigen::Vector3d>>& face_centroids,
                               const std::vector<std::vector<double>>& face_corr_comb,
                               const std::vector<std::vector<double>>& face_iso_ind,
                               size_t n_frames);
    
    static bool writeCalibrationGroup(mat_t* matfp,
                                      const CalibrationData& calibration);
    
    static bool writeDistortionGroup(mat_t* matfp,
                                    const DistortionData& distortion);
    
    static matvar_t* buildAllPairsResultsVar(const std::vector<DIC3DpairResults>& all_pairs);
 
    static matvar_t* buildDIC2DinfoVar(const std::vector<DIC2DPairResults>& dic2d_info);
 
private:
    static mat_t* createMatFileHDF5(const std::string& filename);
    
    static mat_t* createMatFileV5(const std::string& filename);
    
    static bool writeMatVariable(mat_t* matfp,
                                const std::string& varname,
                                const cv::Mat& mat);
    
    static bool writeArrayVariable(mat_t* matfp,
                                  const std::string& varname,
                                  const void* data,
                                  const std::vector<size_t>& dims,
                                  matio_types data_type,
                                  matio_classes class_type);
    
    static bool writeStringVariable(mat_t* matfp,
                                   const std::string& varname,
                                   const std::string& str);
    
    static bool writeScalarVariable(mat_t* matfp,
                                   const std::string& varname,
                                   double value);
    
    static matvar_t* createStructVariable(const std::string& struct_name,
                                         const std::vector<std::string>& field_names);
    
    static bool addFieldToStruct(matvar_t* struct_var,
                                const std::string& field_name,
                                matvar_t* field_var,
                                size_t index = 0);
    
    static void convertDispToArrays(const ncorr::Disp2D& disp,
                                   std::vector<double>& u_array,
                                   std::vector<double>& v_array,
                                   cv::Mat& roi_mask);
    
    static matvar_t* formatDispInfo(const std::map<std::string, double>& params);
    
    static matvar_t* formatDisplacements(const ncorr::DIC_analysis_output& dic_output);
    
    static matvar_t* formatDisplacements(const ncorr::DIC_analysis_output& dic_lagrangian,
                                        const ncorr::DIC_analysis_output& dic_eulerian);
    
    static ncorr::ROI2D convertMatToROI2D(const cv::Mat& mask);
    
    static cv::Mat convertROI2DToMat(const ncorr::ROI2D& roi);
    
    static bool writeDicNcorrFile(const std::string& filename,
                                 const cv::Mat& ref_img,
                                 const cv::Mat& cur_img,
                                 const cv::Mat& ref_roi,
                                 const cv::Mat& cur_roi,
                                 matvar_t* dispinfo_var,
                                 matvar_t* displacements_var,
                                 const ncorr::DIC_analysis_output& dic_output);
    
    static matvar_t* createCellArrayFromScalars(
        const std::string& name,
        const std::vector<std::vector<double>>& data,
        size_t n_frames);
    
    static matvar_t* createCellArrayFromVectors(
        const std::string& name,
        const std::vector<std::vector<Eigen::Vector3d>>& data,
        size_t n_frames);
    
    static matvar_t* createCellArrayFromMatrices(
        const std::string& name,
        const std::vector<std::vector<Eigen::Matrix3d>>& data,
        size_t n_frames);
    
    static matvar_t* createCellArray2DFromStrings(
        const std::string& name,
        const std::vector<std::vector<std::string>>& data,
        size_t rows,
        size_t cols);
    
    static matvar_t* createCellArray2DFromVectors(
        const std::string& name,
        const std::vector<std::vector<std::vector<double>>>& data,
        size_t rows,
        size_t cols);
};
 
} // namespace cppxdic
 
#endif // MAT_WRITER_H