Newer
Older
#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]);
result_operation result;
auto params = parameter::setParameters(args);
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 ¶ms)
{
//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);
data.query = parser::readData<double>(data.files.query); //parsing
if (data.query.size() < 1)
throw runtime_error("problem occured when loading query data");
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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
//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);
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);
}
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 ×, parameter const ¶ms)
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);
cout << print::matrix(result.matrixCluster[params.scoreType - 1], params);
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);
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);
print::write(print::timeMeasures(times, params), params.outputPath + ".time", false);
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
}
}
//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;
//}