experiments.h

Go to the documentation of this file.

//
//    SemanticFastForward_EPIC@ECCVW is free software: you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation, either version 3 of the License, or
//    (at your option) any later version.
//
//    SemanticFastForward_JVCI is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with SemanticFastForward_EPIC@ECCVW.  If not, see <http://www.gnu.org/licenses/>.
//

#ifndef EXPERIMENTS_H
#define EXPERIMENTS_H

#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#include <string.h>
#include <unistd.h>

#include <opencv2/core/core.hpp>

#include "definitions/experiment_struct.h"

#include "executables/execute_commands.h"

#include "headers/file_operations.h"

EXPERIMENT load_experiments_settings ( std::string settingsFilename ){
    EXPERIMENT experiment_settings;


    std::string     video_path;                     
    std::string     output_path;                    
    std::string     video_name;                     
    std::string     original_video_filename;        
    std::string     read_masterframes_filename;     
    std::string     selected_frames_filename;       
    std::string     semantic_costs_filename;        
    std::string     instability_costs_filename;     
    std::string     optical_flow_filename;          
    int             segmentSize = 0;                
    bool            saveMasterFramesInDisk = false; 
    bool            saveVideoInDisk = false;        
    bool            runningParallel = true;         
    cv::FileStorage fs(settingsFilename, cv::FileStorage::READ);
    
    if (!fs.isOpened()){
      return experiment_settings;
    }

    video_path = filter_string(fs["video_path"]);
    video_name = filter_string(fs["video_name"]);
    output_path = filter_string(fs["output_path"]);
    original_video_filename = filter_string(fs["original_video_filename"]);
    selected_frames_filename = filter_string(fs["selected_frames_filename"]);
    read_masterframes_filename = filter_string(fs["read_masterframes_filename"]);
    semantic_costs_filename = filter_string(fs["semantic_costs_filename"]);
    
    segmentSize = fs["segmentSize"];
    
    runningParallel = str2bool(fs["runningParallel"]);
    saveMasterFramesInDisk = str2bool(fs["saveMasterFramesInDisk"]);
    saveVideoInDisk = str2bool(fs["saveVideoInDisk"]);


    char hostname[HOST_NAME_MAX];
    gethostname(hostname, HOST_NAME_MAX);

    experiment_settings.id = getExperimentId();
    experiment_settings.video_filename = video_path + "/" + video_name;
    experiment_settings.output_path = SSTR ( output_path << "/" << video_name.substr(0,video_name.find_last_of('.')) << "_N" << segmentSize << "_"
                                             << hostname << "_ExpID_" << experiment_settings.id);
    experiment_settings.save_video_filename = SSTR ( experiment_settings.output_path << "/StabilizedVideo_" << video_name.substr(0,video_name.find_last_of('.')) << "_N"
                                                     << segmentSize << "_" << hostname << "_ExpID_" << experiment_settings.id << ".avi" );
    experiment_settings.save_master_frames_filename = SSTR ( experiment_settings.output_path << "/MasterFrames_N" << segmentSize << "_"
                                                             << video_name.substr(0,video_name.find_last_of('.')) << ".csv");
    experiment_settings.log_file_name = SSTR ( experiment_settings.output_path << "/Log_" << video_name.substr(0,video_name.find_last_of('.')) << "_N"
                                               << segmentSize << "_" << hostname << "_ExpID_" << experiment_settings.id << ".txt" ) ;
    experiment_settings.read_master_frames_filename = read_masterframes_filename;
    experiment_settings.save_master_frames_in_disk = saveMasterFramesInDisk;
    experiment_settings.save_video_in_disk = saveVideoInDisk;
    experiment_settings.semantic_costs_filename = semantic_costs_filename;
    experiment_settings.instability_costs_filename = instability_costs_filename;
    experiment_settings.selected_frames_filename = selected_frames_filename;
    experiment_settings.original_video_filename = original_video_filename;
    experiment_settings.segment_size = segmentSize;
    experiment_settings.running_parallel = runningParallel;
    experiment_settings.optical_flow_filename = optical_flow_filename;

    return experiment_settings;
}

#endif // EXPERIMENTS_H