step_d_workflow.h

Go to the documentation of this file.

 
#ifndef STEP_D_WORKFLOW_H
#define STEP_D_WORKFLOW_H
 
#include "parameters.h"
#include "image_processor.h"
#include "roi_manager.h"
#include "config.h"
#include "stage_plan.h"
#include <ncorr.h>
#include <opencv2/opencv.hpp>
#include <string>
#include <vector>
 
namespace cppxdic {
 
class StepDWorkflow {
public:
    explicit StepDWorkflow(const Config& config);
    
    std::tuple<std::string, std::vector<int>, bool> execute(const std::string& trial,
                                                            int stereopair,
                                                            const StagePlan& plan = StagePlan{});
 
    static bool updateMaskAndSeedFromOutput(const cv::Mat& input_mask,
                                            const SeedPoint& input_seed,
                                            const ncorr::DIC_analysis_output& dic_output,
                                            cv::Mat& output_mask,
                                            SeedPoint& output_seed);
 
    static void formatDic2DPairResults(const Config& config,
                                       const StepParameters& step_params,
                                       const std::string& output_path,
                                       int cam_1,
                                       int cam_2,
                                       const std::vector<int>& pairOrder,
                                       bool pairForced);
    
private:
    const Config& config_;
    BaseParameters base_params_;
    StepParameters step1_params_;      // Tracking camera 1
    StepParameters step2_params_;      // Tracking camera 2
    StepParameters step1_2_params_;    // Matching between cameras
    ProtocolInfo protocol_info_;
    
    void setupBaseParameters(const std::string& trial, 
                            int stereopair,
                            const std::string& reftrial);
    
    void setupStepParameters();
    
    bool loadProtocol();
    
    std::string determineReferenceTrial(const std::string& trial);
    
    bool importVideoFrames(const std::string& trial,
                          int stereopair,
                          std::vector<cv::Mat>& cam_first_raw,
                          std::vector<cv::Mat>& cam_second_raw,
                          int maxFrames = 0);
    
    void performSaturation(const std::vector<cv::Mat>& cam_first_raw,
                          const std::vector<cv::Mat>& cam_second_raw,
                          std::vector<cv::Mat>& cam_first_satur,
                          std::vector<cv::Mat>& cam_second_satur);
    
    bool initializeROIAndSeed(const std::vector<cv::Mat>& cam_first_satur,
                             cv::Mat& refmask_REF,
                             cv::Mat& refmask_trial,
                             SeedPoint& ref_seed_point,
                             SeedPoint& initial_seed_point_set1);
 
    bool matchingInitialFrame(const std::vector<cv::Mat>& cam_ref,
        const std::vector<cv::Mat>& cam_cur,
        const cv::Mat& refmask_ref,
        const std::string ncorr_matching_path,
        const std::string message,
        const SeedPoint& initial_seed_point_ref,
        cv::Mat& refmask_cur_matched,
        SeedPoint& initial_seed_point_cur);
    
    bool performMatching(const std::vector<cv::Mat>& cam_first_satur,
                        const std::vector<cv::Mat>& cam_second_satur,
                        cv::Mat& refmask_trial,
                        SeedPoint& initial_seed_point_set1,
                        cv::Mat& refmask_trial_matched,
                        SeedPoint& initial_seed_point_set2);
    
    bool performTracking(const int tracking_number,
                         const std::vector<cv::Mat>& cam_frames,
                         const cv::Mat& refmask,
                         const SeedPoint& initial_seed_point);
 
    bool performTracking1(const std::vector<cv::Mat>& cam_first,
                         const cv::Mat& refmask_trial,
                         const SeedPoint& initial_seed_point_set1);
    
    bool performTracking2(const std::vector<cv::Mat>& cam_second,
                         const cv::Mat& refmask_trial_matched,
                         const SeedPoint& initial_seed_point_set2);
    
    void applyImageFiltering(const std::vector<cv::Mat>& cam_first_satur,
                            const std::vector<cv::Mat>& cam_second_satur,
                            const cv::Mat& refmask_trial,
                            std::vector<cv::Mat>& cam_first,
                            std::vector<cv::Mat>& cam_second);
    
    void saveTrialInfo(const std::string& trial, int stereopair, int num_frames);
    
    void formatOutput(const std::string& trial,
                      int stereopair,
                      const std::vector<int>& pairOrder,
                      bool pairForced);
 
    void writeNcorrMatSidecar(const std::string& output_path,
                              const cv::Mat& ref_img,
                              const std::vector<cv::Mat>& cur_imgs,
                              const cv::Mat& roi_mask,
                              const StepParameters& step_params,
                              const ncorr::DIC_analysis_output& dic_output) const;
 
    void writeMatchingDebugPanel(const std::string& stage_name,
                                 const cv::Mat& ref_img,
                                 const cv::Mat& cur_img,
                                 const cv::Mat& mask_before,
                                 const cv::Mat& mask_after,
                                 const SeedPoint& seed_before,
                                 const SeedPoint& seed_after,
                                 const ncorr::DIC_analysis_output& dic_output) const;
    
    ncorr::DIC_analysis_output runNcorrAnalysis(const cv::Mat& ref_img,
                                                const std::vector<cv::Mat>& cur_imgs,
                                                const cv::Mat& roi_mask,
                                                const SeedPoint& seed_point,
                                                const StepParameters& step_params,
                                                const std::string& output_path,
                                                const bool go_parallel,
                                                const bool use_no_update = false);
    
};
 
} // namespace cppxdic
 
#endif // STEP_D_WORKFLOW_H