Skip to content
Snippets Groups Projects
mains.cpp 8.97 KiB
Newer Older
  • Learn to ignore specific revisions
  • #include "stdafx.h"
    
    #include "mains.h"
    
    #include "entrypoint.h"
    #include "parameter.h"
    
    #include "print.h"
    #include "operation.h"
    #include "dtw.h"
    #include "lcss.h"
    #include "pdtw.h"
    #include "help.h"
    #include "calcul.h"
    #include "draw.h"
    
    using namespace std;
    
    
    void mains::main_entry(vtr<string> const &args)
    
    	vector<string> scripts;
    	for (size_t i = 0; i < args.size() - 1; i++)
    	{
    		if (args[i] == "-script")
    		{
    
    			scripts = parser::readFileByLine(args[i + 1]);
    
    	auto params = parameter::setParameters(args);
    
    	if (scripts.size() > 0)
    	{
    
    		for (size_t i = 0; i < scripts.size(); i++)	//secondary switches applyed to all script lines ...for more robust behaviour
    
    			auto argsAll = help::split(scripts[i], " \t");
    			parameter::applyParameter(argsAll, args);
    			params = parameter::setParameters(argsAll);
    			result = main_logic(params);
    
    		result = main_logic(params);
    
    result_operation mains::main_logic(parameter const &params)
    {	
    
    	//INPUT DATA PARSING
    	input_data data;
    	result_time times;
    
    	auto begin = chrono::steady_clock::now();
    	try {
    
    		data.files.input = parser::getAllFileNames(params.inPath); //file path of all input files
    		data.files.query = parser::getAllFileNames(params.inQuery); //file path of all input files
    		data.files.keyInput = parser::getAllFileNames(params.inKeyInput); //file path of all input files
    		data.files.keyQuery = parser::getAllFileNames(params.inKeyQuery); //file path of all input files
    
    		data.input = parser::readData<double>(data.files.input);				//parsing
    
    		if (data.input.size() < 1)
    			throw runtime_error("problem occured when loading input data");
    		
    		if (params.distance == 4)
    
    			data.keyInput = parser::readData<int>(data.files.keyInput);
    
    
    		if (params.isQuery())
    		{
    
    			data.query = parser::readData<double>(data.files.query);				//parsing
    
    			if (data.query.size() < 1)
    				throw runtime_error("problem occured when loading query data");
    
    
    			if (params.distance == 4)
    
    				data.keyInput = parser::readData<int>(data.files.keyQuery);
    
    
    		times.parsing = chrono::duration_cast<chrono::milliseconds>(chrono::steady_clock::now() - begin).count();
    
    		if (params.isClusters())	//parsing clusters file 
    		{
    
    			auto clusterTmp = parser::parseClusters(data.files.query, params.inClusterPath);
    			data.clusters = parser::parseClusters(data.files.input, params.inClusterPath);
    
    
    			int clusterSize = (int)data.clusters.ids.size();
    			for (size_t i = 0; i < clusterTmp.ids.size(); i++)
    				data.clusters.ids[(int)i + clusterSize + 1] = clusterTmp.ids.at((int)i + 1);
    		}
    	}
    
    	catch (const std::exception &e)
    
    	{
    		cout << e.what() << endl;
    		exit(0);
    	}
    
    	if (params.isDebugInfo())
    	{
    
    		cout << print::vector(data.files.query);
    		cout << print::vector(data.files.input);
    
    		cout << print::input(data.query, 30) << endl; // print for debug comment or delete if not needed
    		cout << print::input(data.input, 30) << endl; // print for debug comment or delete if not needed
    		cout << print::inputStats(data.input, 30);
    		cout << print::inputStats(data.query, 30);
    
    	}
    
    	begin = chrono::steady_clock::now();
    	preprocesing(data, params);
    	times.preprocesing = chrono::duration_cast<chrono::milliseconds>(chrono::steady_clock::now() - begin).count();
    	
    	if (params.isDebugInfo()) {
    
    		cout << print::input(data.input, 30) << endl; // print for debug comment or delete if not needed
    		cout << print::input(data.query, 30) << endl; // print for debug comment or delete if not needed
    
    	}
    
    	//RUN METHOD
    	begin = chrono::steady_clock::now();
    
    	result_operation result;
    	if (params.operation < 2 || params.operation == 3 || params.operation == 5)
    	{
    		auto single = data.convert_inputDataSingle();
    		result = operation::main(single, params);
    	}
    	else
    		result = operation::main(data, params);
    
    	times.opeartion = chrono::duration_cast<chrono::milliseconds>(chrono::steady_clock::now() - begin).count();
    
    
    	//PRINT REUSULT
    
    	mains::printResult(data, result, times, params);
    
    	return result;
    
    result_operation mains::extern_logic(vtr3<double> const &input, vtr<string> const &args)
    
    {
    	//cout << print::printVector(args);
    	auto params = parameter::setParameters(args);
    
    	//INPUT DATA PARSING
    	input_data data;
    	result_time times;
    	auto begin = chrono::steady_clock::now();
    
    	data.input = input;
    
    	vtr<string> inputFiles(input.size());
    	for (size_t i = 0; i < input.size(); i++)
    	{
    		inputFiles[i] = "ext" + to_string((int)i + 1);
    	}
    	data.files.input = inputFiles;
    
    	begin = chrono::steady_clock::now();
    	preprocesing(data, params);
    	times.preprocesing = chrono::duration_cast<chrono::milliseconds>(chrono::steady_clock::now() - begin).count();
    
    	if (params.isDebugInfo())
    
    		cout << print::input(data.input, 30) << endl; // print for debug comment or delete if not needed
    
    
    														   //RUN METHOD
    														   //begin = chrono::steady_clock::now();
    
    	result_operation result;
    	if (params.operation < 2 || params.operation == 3 || params.operation == 5)
    	{
    		auto dataSingle = data.convert_inputDataSingle();
    		result = operation::main(dataSingle, params);
    	}
    	else
    		result = operation::main(data, params);
    
    	//times.opeartion = chrono::duration_cast<chrono::milliseconds>(chrono::steady_clock::now() - begin).count();
    
    	//PRINT REUSULT
    	//mains::printResultLogic(data, result, times, params);
    
    	return result;
    }
    
    void mains::preprocesing(input_data &data, parameter const& params)
    {
    	//DATA PREPROCESSING
    	
    	if (params.isReduce()) {
    
    		help::reduce<double>(data.input, params.reduce);
    		help::reduce<double>(data.query, params.reduce);
    		help::reduce<int>(data.keyInput, params.reduce);
    		help::reduce<int>(data.keyQuery, params.reduce);
    
    	if (params.isPaa()) {
    
    		help::paa<double>(data.input, params.paa);
    		help::paa<double>(data.query, params.paa);
    		help::paa<int>(data.keyInput, params.paa);
    		help::paa<int>(data.keyQuery, params.paa);
    
    	
    	if (params.isSax()) {
    		help::sax(data.input, params.sax);
    		help::sax(data.query, params.sax);
    	}
    	
    
    	if (params.prolong > 0) {
    
    		help::prolong<double>(data.input, params.prolong);
    		help::prolong<double>(data.query, params.prolong);
    		help::prolong<int>(data.keyInput, params.prolong);
    		help::prolong<int>(data.keyQuery, params.prolong);
    
    	}
    
    	//if (params.isZNormalization())
    	//	help::normalizeMany(input);
    	if (params.isInterpolate()) {
    		help::interpolate(data.input);
    		help::interpolate(data.query);
    	}
    
    	if (params.isNormalizeZeroOne()) {
    		help::normalizeZeroOne(data.input, params.normalize);
    		help::normalizeZeroOne(data.query, params.normalize);
    	}
    
    	if (params.isSmooth()) {
    		help::smooth(data.input, params.smooth);
    		help::smooth(data.query, params.smooth);
    	}
    }
    
    
    void mains::printResult(input_data const &data, result_operation &result, result_time &times, parameter const &params)
    
    	if (!result.scoreMethod.empty())
    		cout << print::vector(result.scoreMethod);
    
    	if(!result.matrixSimilarity.empty())
    		result.matrixSimilarity = help::alterStructure(result.matrixSimilarity);
    	//if (!result.matrixCluster.empty())
    	//	result.matrixCluster = help::alterStructure(result.matrixCluster);
    
    
    	if (params.isPrintOutput()) {
    		if (params.isOmp())
    
    			cout << print::matrix(result.matrixSimilarity[params.scoreType - 1], params);
    
    		if (result.matrixCluster.size() > 0)
    
    			cout << print::matrix(result.matrixCluster[params.scoreType - 1], params);
    
    	}
    
    	if (params.operation > 2)
    
    		cout << print::scores_clustering(result, params.precision);
    
    
    	//WRITE LOG FILES
    	auto begin = chrono::steady_clock::now();
    	if (params.isWriteOutput()) {
    
    		print::write(print::matrix(result.matrixSimilarity[params.scoreType - 1], params), params.outputPath + ".matrix", false);
    
    		print::write(print::scores_clustering(result, params.precision), params.outputPath + ".score", false);
    
    	}
    
    	if (params.isHtml())
    	{
    		print::write(
    			/*print::printParameterString(args) + "</br>" +*/
    
    			print::scores_clustering(result, params.precision) +
    
    			print::htmlClusters(data.input, result.matrixCluster[0], data.clusters), params.outputPath + ".html", true);
    
    	}
    
    	if (params.isGdf())
    
    		print::write(print::gdf(data.files.input, data.input, result.matrixSimilarity[params.scoreType - 1], data.clusters), params.outputPath + ".gdf", false);
    
    
    	times.write = chrono::duration_cast<chrono::milliseconds>(chrono::steady_clock::now() - begin).count();
    
    	if (params.isTime())
    
    		cout << print::timeMeasures(times, params);
    
    
    	if (params.isWriteOutput()) {
    
    		print::write(print::timeMeasures(times, params), params.outputPath + ".time", false);
    
    	}
    }
    
    //for (size_t u = 0; u < 100; u++)
    //{
    //	for (size_t i = 0; i < 999; i++)
    //	{
    //		int min = 1;
    //		int max = 999;
    //		int cc = 0;
    //		map<int, int> isIn;
    //		for (int j = 0; j < 999; j++)
    //		{
    //			std::uniform_int_distribution<int> dis(min, max);
    //			while (true) {
    //				int tmp = dis(gen);
    
    //				if (isIn.count(tmp) > 0)
    //				{
    //					if (tmp == max)
    //						while (isIn.count(max) > 0) {
    //							max--;
    //						}
    //				}
    //				else {
    //					isIn[tmp] = tmp;
    //					mx[j][i] = tmp;
    //					cc++;
    //					break;
    //				}
    //			}
    //		}
    //		//cout << cc << endl;
    //	}
    
    //	auto s = calcul::scoreMap(mx, c);
    //	cout << s[999] << endl;
    //}