TomatoOptions.h
/*!
* \file TomatoOptions.h
* \author Konrad Werys
* \date 2018/08/18
*/
#ifndef Tomato_TomatoOPTIONS_H
#define Tomato_TomatoOPTIONS_H
#include <iostream>
#include <vector>
#include <string>
#include "CmakeConfigForTomato.h"
#include "OxFactoryOfCalculators.h"
#include "OxFactoryOfFitters.h"
#include "OxFactoryOfFunctions.h"
#include "OxFactoryOfSignCalculators.h"
#include "OxFactoryOfStartPointCalculators.h"
#include "TomatoParser.h"
#include "KWUtil.h"
#include "KWUtilYaml.h"
#define YAML_BUFFER_SIZE 65536
namespace Ox {
template<typename MeasureType>
struct TomatoOptions {
// paths
std::vector<std::string> files_magnitude;
std::vector<std::string> files_phase;
std::string dir_magnitude;
std::string dir_phase;
std::string dir_output_map;
std::string dir_output_fitparams;
calculatorsType_t parameter_to_map;
fittersType_t fitting_method;
functionsType_t functions_type;
signCalculatorsType_t sign_calc_method;
startPointCalculatorsType_t start_point_calc_method;
MeasureType fTolerance;
int max_function_evals;
bool use_gradient;
// image
MeasureType mean_cut_off;
int number_of_threads;
// visualisation
bool visualise;
// export
int output_map_series_number;
int output_fitparams_series_number;
// output params
double calculation_time;
/**
* initialise the defaults
* done this way to work around delegating constructors in cpp98
*/
void init(){
dir_magnitude = "";
dir_phase = "";
dir_output_map = "";
dir_output_fitparams = "";
parameter_to_map = T1_MOLLI;
fitting_method = LevMarVnl;
functions_type = FunctionsBasic;
sign_calc_method = NoSign;
start_point_calc_method = Default;
fTolerance = 1e-12;
max_function_evals = 4000;
use_gradient = false;
// image
mean_cut_off = 10;
number_of_threads = 0;
// visualisation
visualise = false;
// export
output_map_series_number = 0;
output_fitparams_series_number = 0;
// output params
calculation_time = 0;
}
/**
* constructor with defaults
*/
TomatoOptions() {
init();
}
/**
* constructor with parser
* @param filePath
*/
TomatoOptions(std::string filePath) {
init();
Ox::TomatoParser<MeasureType> parser;
parser._filePath = filePath;
parser._sequences["files_magnitude"];
parser._sequences["files_phase"];
parser._scalars["dir_magnitude"];
parser._scalars["dir_phase"];
parser._scalars["dir_output_map"];
parser._scalars["dir_output_fitparams"];
parser._scalars["parameter_to_map"];
parser._scalars["fitting_method"];
parser._scalars["functions_type"];
parser._scalars["sign_calc_method"];
parser._scalars["start_point_calc_method"];
parser._scalars["fTolerance"];
parser._scalars["max_function_evals"];
parser._scalars["use_gradient"];
parser._scalars["mean_cut_off"];
parser._scalars["number_of_threads"];
parser._scalars["visualise"];
parser._scalars["output_map_series_number"];
parser._scalars["output_fitparams_series_number"];
parser.parse();
// input
files_magnitude = parser._sequences["files_magnitude"];
files_phase = parser._sequences["files_phase"];
dir_magnitude = parser._scalars["dir_magnitude"];
dir_phase = parser._scalars["dir_phase"];
// output
dir_output_map = parser._scalars["dir_output_map"];
dir_output_fitparams = parser._scalars["dir_output_fitparams"];
if (!parser._scalars["output_map_series_number"].empty())
output_map_series_number = KWUtil::StringToNumber<MeasureType>(parser._scalars["output_map_series_number"]);
if (!parser._scalars["output_fitparams_series_number"].empty())
output_fitparams_series_number = KWUtil::StringToNumber<MeasureType>(parser._scalars["output_fitparams_series_number"]);
// calc options
if (!parser._scalars["parameter_to_map"].empty())
parameter_to_map = (calculatorsType_t) findInArray(lastCalculatorType+1, calculatorsTypeNames, parser._scalars["parameter_to_map"]);
if (!parser._scalars["fitting_method"].empty())
fitting_method = (fittersType_t) findInArray(lastFitterType+1, fittersTypeNames, parser._scalars["fitting_method"]);
if (!parser._scalars["functions_type"].empty())
functions_type = (functionsType_t) findInArray(lastFunctorType+1, functionsTypeNames, parser._scalars["functions_type"]);
if (!parser._scalars["sign_calc_method"].empty())
sign_calc_method = (signCalculatorsType_t) findInArray(lastSignCalculatorType+1, signCalculatorsTypeNames, parser._scalars["sign_calc_method"]);
if (!parser._scalars["start_point_calc_method"].empty())
start_point_calc_method = (startPointCalculatorsType_t) findInArray(lastStartPointCalculatorType+1, startPointCalculatorsTypeNames, parser._scalars["start_point_calc_method"]);
if (!parser._scalars["fTolerance"].empty())
fTolerance = KWUtil::StringToNumber<MeasureType>(parser._scalars["fTolerance"]);
if (!parser._scalars["max_function_evals"].empty())
max_function_evals = KWUtil::StringToNumber<MeasureType>(parser._scalars["max_function_evals"]);
if (!parser._scalars["use_gradient"].empty())
use_gradient = (bool)KWUtil::StringToNumber<MeasureType>(parser._scalars["use_gradient"]);
if (!parser._scalars["mean_cut_off"].empty())
mean_cut_off = KWUtil::StringToNumber<MeasureType>(parser._scalars["mean_cut_off"]);
if (!parser._scalars["number_of_threads"].empty())
number_of_threads = KWUtil::StringToNumber<MeasureType>(parser._scalars["number_of_threads"]);
// visualise
if (!parser._scalars["visualise"].empty())
visualise = (bool)KWUtil::StringToNumber<MeasureType>(parser._scalars["visualise"]);
}
int findInArray(int size, const char *nameArray[], std::string name){
for (int i = 0; i < size; ++i){
std::string nameFromArray(nameArray[i]);
if (nameFromArray.compare(name) == 0){
return i;
}
}
std::string errorMessage = "Option \"" + name + "\" not found";
throw std::runtime_error(errorMessage);
}
void printCurrent() {
printf("\n");
printf("######################################\n");
printf("Tomato CURRENTLY SELECTED options:\n");
printf("######################################\n");
KWUtil::printVector(" files_magnitude: ", files_magnitude);
KWUtil::printVector(" files_phase: ", files_phase);
printf(" dir_magnitude: %s ", dir_magnitude.c_str());
printf("\n dir_phase: %s ", dir_phase.c_str());
printf("\n dir_output_map: %s ", dir_output_map.c_str());
printf("\n dir_output_fitparams: %s ", dir_output_fitparams.c_str());
printf("\n output_map_series_number: %d", output_map_series_number);
printf("\n output_fitparams_series_number: %d", output_fitparams_series_number);
printf("\n");
printf("\n");
Ox::FactoryOfCalculators<double>::disp(parameter_to_map);
Ox::FactoryOfFitters<double>::disp(fitting_method);
Ox::FactoryOfFunctions<double>::disp(functions_type);
Ox::FactoryOfSignCalculators<double>::disp(sign_calc_method);
Ox::FactoryOfStartPointCalculators<double>::disp(start_point_calc_method);
// printf("]\n sign_calc_method: %s [ ", signCalculatorsTypeNames[sign_calc_method]);
// KWUtil::printArray(lastSignCalculatorType+1, signCalculatorsTypeNames);
// printf("]\n start_point_calc_method: %s [ ", startPointCalculatorsTypeNames[start_point_calc_method]);
// KWUtil::printArray(lastStartPointCalculatorType+1, startPointCalculatorsTypeNames);
// printf("]\n");
printf("\n fTolerance: %.2e ", fTolerance);
//printf("xTolerance: %.2e ", xTolerance);
printf("\n max_function_evals: %d ", max_function_evals);
printf("\n use_gradient: %s", use_gradient?"1":"0");
printf("\n mean_cut_off: %.2f ", mean_cut_off);
//printf("fittingCutOff: %.2f ", fittingCutOff);
printf("\n number_of_threads: %d", number_of_threads);
printf("\n visualise: %s", visualise?"1":"0");
printf("\n calculation time: %.2fs", calculation_time);
printf("\n\n");
}
int exportToYaml(){
if (dir_output_map.length() > 0){
std::string filePath = dir_output_map + KWUtil::PathSeparator() + "tomato_output_config.yaml";
exportToYaml(filePath);
}
if (dir_output_fitparams.length() > 0){
std::string filePath = dir_output_fitparams + KWUtil::PathSeparator() + "tomato_output_config.yaml";
exportToYaml(filePath);
}
return 0; // EXIT_SUCCESS
}
int exportToYaml(std::string filePath){
yaml_document_t document;
yaml_emitter_t emitter;
size_t written = 0;
yaml_document_initialize(&document, NULL, NULL, NULL, 1, 1);
yaml_document_add_mapping(&document, (yaml_char_t*)YAML_DEFAULT_MAPPING_TAG, YAML_ANY_MAPPING_STYLE);
int mapping_node_number = (int)(document.nodes.top - document.nodes.start);
KWUtilYaml::addSequence(&document, mapping_node_number, "files_magnitude", files_magnitude);
KWUtilYaml::addSequence(&document, mapping_node_number, "files_phase", files_phase);
KWUtilYaml::addMapping(&document, mapping_node_number, "dir_magnitude", dir_magnitude);
KWUtilYaml::addMapping(&document, mapping_node_number, "dir_phase", dir_phase);
KWUtilYaml::addMapping(&document, mapping_node_number, "dir_output_map", dir_output_map);
KWUtilYaml::addMapping(&document, mapping_node_number, "dir_output_fitparams", dir_output_fitparams);
KWUtilYaml::addMapping(&document, mapping_node_number, "output_map_series_number", KWUtil::NumberToString(output_map_series_number));
KWUtilYaml::addMapping(&document, mapping_node_number, "output_fitparams_series_number", KWUtil::NumberToString(output_fitparams_series_number));
KWUtilYaml::addMapping(&document, mapping_node_number, "parameter_to_map", calculatorsTypeNames[parameter_to_map]);
KWUtilYaml::addMapping(&document, mapping_node_number, "fitting_method", fittersTypeNames[fitting_method]);
KWUtilYaml::addMapping(&document, mapping_node_number, "functions_type", functionsTypeNames[functions_type]);
KWUtilYaml::addMapping(&document, mapping_node_number, "sign_calc_method" , signCalculatorsTypeNames[sign_calc_method]);
KWUtilYaml::addMapping(&document, mapping_node_number, "start_point_calc_method", startPointCalculatorsTypeNames[start_point_calc_method]);
KWUtilYaml::addMapping(&document, mapping_node_number, "fTolerance", KWUtil::NumberToString(fTolerance));
KWUtilYaml::addMapping(&document, mapping_node_number, "max_function_evals", KWUtil::NumberToString(max_function_evals));
KWUtilYaml::addMapping(&document, mapping_node_number, "use_gradient", use_gradient ? "1" : "0");
KWUtilYaml::addMapping(&document, mapping_node_number, "mean_cut_off", KWUtil::NumberToString(mean_cut_off));
KWUtilYaml::addMapping(&document, mapping_node_number, "number_of_threads", KWUtil::NumberToString(number_of_threads));
KWUtilYaml::addMapping(&document, mapping_node_number, "visualise", visualise ? "1" : "0");
KWUtilYaml::addMapping(&document, mapping_node_number, "calculation_time", KWUtil::NumberToString(calculation_time));
std::string tomato_version = "v" + KWUtil::NumberToString(Tomato_VERSION_MAJOR) + "." + KWUtil::NumberToString(Tomato_VERSION_MINOR);
KWUtilYaml::addMapping(&document, mapping_node_number, "tomato_version", tomato_version);
unsigned char buffer[YAML_BUFFER_SIZE+1];
memset(buffer, 0, YAML_BUFFER_SIZE+1);
yaml_emitter_initialize(&emitter);
yaml_emitter_set_output_string(&emitter, buffer, YAML_BUFFER_SIZE, &written);
yaml_emitter_open(&emitter);
yaml_emitter_dump(&emitter, &document);
yaml_emitter_flush(&emitter);
yaml_emitter_close(&emitter);
FILE *file = fopen(filePath.c_str(), "wb");
fprintf(file, "%s", buffer);
fclose(file);
return 0; // EXIT_SUCCESS
}
};
} // namespace Ox
#undef YAML_BUFFER_SIZE
#endif //Tomato_TomatoOPTIONS_H
