utils.h

Go to the documentation of this file.

 
#ifndef UTILS_H
#define UTILS_H
 
#include "config.h"
#include "parameters.h"
#include <string>
#include <string_view>
#include <vector>
#include <opencv2/opencv.hpp>
#include <Eigen/Dense>
 
class Utils {
public:
    // Check data and protocol files (equivalent to dic_check.m)
    static bool dicCheck(const Config& config);
    
    // File system utilities
    static bool fileExists(const std::string& path);
    static bool directoryExists(const std::string& path);
    static std::vector<std::string> findFiles(const std::string& directory, 
                                            const std::string& pattern);
    
    // String utilities
    static std::string formatString(const std::string& format, ...);
    static std::vector<std::string> split(const std::string& str, char delimiter);
 
    // Video import (equivalents of import_vid.m / import_raw_vid.m)
    // maxFrames > 0 limits extraction to the first maxFrames selected frames
    // (e.g. 1 when only the reference frame is needed); 0 means all frames.
    static bool importVid(const Config& config,
                          int trial,
                          int stereopair,
                          std::vector<std::string>& cam1Frames,
                          std::vector<std::string>& cam2Frames,
                          int maxFrames = 0);
 
    static bool importRawVid(const Config& config,
                             int trial,
                             int stereopair,
                             int frameStart,
                             int frameEnd,
                             int frameJump,
                             std::vector<std::string>& cam1Frames,
                             std::vector<std::string>& cam2Frames,
                             int maxFrames = 0);
 
    // ROI/SEED from MAT to JSON
    static bool loadROIFromMat(const Config& config,
                               int trial,
                               int stereopair,
                               std::string& roiJsonPath,
                               std::string& roiMaskImagePath);
 
    static bool loadSeedFromMat(const Config& config,
                                int trial,
                                int stereopair,
                                std::string& seedJsonPath);
    
    // Camera calibration and distortion removal
    struct CameraParameters {
        cv::Mat camera_matrix;      // 3x3 intrinsic matrix [fx 0 cx; 0 fy cy; 0 0 1]
        cv::Mat distortion_coeffs;  // Distortion coefficients [k1 k2 p1 p2 k3...]
        bool is_valid;
        
        CameraParameters() : is_valid(false) {}
    };
    
    static bool loadCameraParameters(const std::string& mat_path, CameraParameters& params);
    
    static void undistortPoints(const std::vector<cv::Point2d>& points_in,
                                const CameraParameters& params,
                                std::vector<cv::Point2d>& points_out);
    
    static cv::Point2d undistortPoint(const cv::Point2d& point_in,
                                      const CameraParameters& params);
    
    static bool DLT11Calibration(const double* P2, const double* P3, size_t N,
                                  std::vector<double>& L);
 
    // Rigid Body Motion (RBM) transformation
    struct RigidTransform {
        Eigen::Matrix3d R;  // Rotation matrix
        Eigen::Vector3d t;  // Translation vector
        bool is_valid;
        
        RigidTransform() : R(Eigen::Matrix3d::Identity()), 
                          t(Eigen::Vector3d::Zero()), 
                          is_valid(false) {}
    };
    
    static bool computeRigidTransform(const std::vector<Eigen::Vector3d>& points_from,
                                      const std::vector<Eigen::Vector3d>& points_to,
                                      RigidTransform& transform);
    
    static std::vector<Eigen::Vector3d> applyRigidTransform(const std::vector<Eigen::Vector3d>& points_in,
                                                             const RigidTransform& transform);
    
    static void setCameraPairs(const std::vector<std::pair<int,int>>& camera_pairs);
 
    static const std::vector<std::pair<int,int>>& cameraPairs();
 
    static void getCamerasForPair(int stereopair, int& cam_first, int& cam_second);
 
    static void getCamerasForPair(int stereopair, const std::vector<std::pair<int,int>>& camera_pairs,
                                  int& cam_first, int& cam_second);
 
    static std::string buildBaseDataPath(const Config& config, bool with_data_or_dic_path = false, bool with_rawdata = false, bool with_speckles = false);
 
    static std::string buildOutputUntilTrialDir(const Config& config, int trial);
 
    static std::string buildOutputUntilPhaseDir(const Config& config, int trial);
 
    
    static std::string buildPath(const Config& config, bool with_data_or_dic_path = false, bool with_rawdata = false, bool with_speckles = false, bool with_material = false, bool with_video = false, bool with_protocol = false, bool with_calib = false);
    
    static std::string buildUntilMaterialDir(const Config& config, bool with_data_or_dic_path, bool with_rawdata, bool with_speckles);
 
    static std::string buildOutputUntilMaterialDir(const Config& config);
 
    static std::string buildProtocolDir(const Config& config, bool with_data_or_dic_path = false, bool with_rawdata = false, bool with_speckles = false, bool with_material = false);
 
 
    static std::string buildVideoDir(const Config& config, bool with_data_or_dic_path = false, bool with_rawdata = false, bool with_speckles = false, bool with_material = false);
 
    static std::string buildCalibDir(const Config& config);
 
    static std::string buildPath(const cppxdic::BaseParameters& parameters, bool with_material = false, bool with_trial = false, bool with_phase = false, bool with_cache = false);
 
    static std::string buildOutputPath(const cppxdic::BaseParameters& parameters);
    
    static std::string buildOutputCachePath(const cppxdic::BaseParameters& parameters);
 
    static std::string likeRoiOrSeedPath(const std::string& path, const std::string_view& prefix, const std::string& reftrial, const std::string& phase, int stereopair, const std::string& extension); 
    static std::string likeRoiPath(const std::string& path, const std::string& reftrial, const std::string& phase, int stereopair, const std::string& extension);
    static std::string likeSeedPath(const std::string& path, const std::string& reftrial, const std::string& phase, int stereopair, const std::string& extension);
 
    static std::string buildRoiFilePath(const cppxdic::BaseParameters& parameters, std::string reftrial, int stereopair, const std::string& extension = ".mat");
 
    static std::string buildSeedFilePath(const cppxdic::BaseParameters& parameters, std::string reftrial, int stereopair, const std::string& extension = ".mat");
 
 
    static std::string buildMatchingFilePath(const cppxdic::BaseParameters& parameters, std::string reftrial, int stereopair, const std::string& extension = ".bin");
 
    static std::string buildDic3DCombinedFilePath(const std::string pathdir, int num_pair, const std::string& ext);
    static std::string buildDic3DPPresultsFilePath(const std::string pathdir, int num_pair, const std::string& fileversion, const std::string& ext);
    static std::string buildVizPath(const std::string pathdir, const std::string filename);
    static std::string buildDic2DPairResultsFilePath(const std::string pathdir, int cam_1, int cam_2, const std::string& extension);
    static std::string buildNcorrFilePath(const std::string pathdir, int cam_1, int cam_2 = -1, const std::string& extension = ".bin");
 
private:
    static bool checkROIReferences(const Config& config);
    static bool checkSeedReferences(const Config& config);
    static bool checkProtocolFiles(const Config& config);
    static bool checkCalibrationFiles(const Config& config);
 
    static std::string buildRoiOrSeedLikeFilePath(const cppxdic::BaseParameters& parameters, std::string reftrial, int stereopair, std::string_view prefix, const std::string& extension = ".mat");
 
};
 
#endif // UTILS_H