private static void RunRenders(TimeReportCollection <Algo> algos, TimeReportCollection <AlgoStep> steps)
{
foreach (var algo in algos)
{
foreach (var step in steps)
{
var filename = $"{algo.ao.name}_{step.qualityStr}";
var outputPath = Path(Subfolder.meshes, filename, Ext.obj);
var renderOutputPath = Path(Subfolder.renders, filename, Ext.png);
BlenderWorkspace.Instance.RenderToImage(outputPath, renderOutputPath, step.quality <= 0.05);
}
}
}
private static void RunSimplification(TimeReportCollection <Algo> algos, TimeReportCollection <AlgoStep> steps)
{
foreach (var algo in algos)
{
var logFile = Path(Subfolder.meshes, algo.ao.name, Ext.txt);
if (File.Exists(logFile))
{
File.Delete(logFile);
}
foreach (var step in steps)
{
var outputPath = Path(Subfolder.meshes, $"{algo.ao.name}_{step.qualityStr}", algo.ext);
var outputPathTxt = Path(Subfolder.logs, $"{algo.ao.name}_{step.qualityStr}", Ext.txt);
var inputPath = Path(Subfolder.none, originalModelName, algo.ext);
Stopwatch sw = Stopwatch.StartNew();
algo.Run(step, inputPath, outputPath);
File.WriteAllText(outputPathTxt, sw.ElapsedMilliseconds.ToString());
//File.AppendAllText(logFile, $"{step.quality.Sanitize()} {step.StopTimer()}\n");
}
}
}
private static void RunOutputUnifier(TimeReportCollection <Algo> algos, TimeReportCollection <AlgoStep> steps)
{
var acceptableExt = Ext.obj;
foreach (var algo in algos)
{
foreach (var step in steps)
{
var ext = algo.ext;
if (ext != acceptableExt)
{
var inputPath = Path(Subfolder.meshes, $"{algo.ao.name}_{step.qualityStr}", algo.ext);
var outputPath = Path(Subfolder.meshes, $"{algo.ao.name}_{step.qualityStr}", acceptableExt);
MeshlabWorkspace.Instance.CleanConvert(inputPath, outputPath);
if (File.Exists(inputPath))
{
File.Delete(inputPath);
}
}
}
}
}
private static void RunMyAlgos(string inputFile, bool generateBlender)
{
Logger.Write("Enter name:");
InputFilename = Console.ReadLine();
PlaySound(1, SystemSounds.Hand);
if (!Regex.IsMatch(InputFilename, @"^\w+$"))
{
Logger.WriteLine("Wrong input");
return;
}
var v = System.Configuration.ConfigurationSettings.AppSettings["verbose"];
bool.TryParse(v, out Cli.verbose);
WorkingDir = $@"{Environment.CurrentDirectory}\mc_output\{InputFilename}";
var qualitySteps = new List <float> {
0.5f, 0.25f, 0.1f, 0.05f, 0.02f, 0.01f
};
qualitySteps.Reverse();
//create an obj copys
var inputObjPath = Path(Subfolder.none, originalModelName, Ext.obj);
var inputOffPath = Path(Subfolder.none, originalModelName, Ext.off);
var inputStlPath = Path(Subfolder.none, originalModelName, Ext.stl);
var inputPlyPath = Path(Subfolder.none, originalModelName, Ext.ply);
var cleanLog = Path(Subfolder.none, "logfile_meshlab_clean", Ext.txt);
var allAlgos = InitializeAlgosAndWorkspaces();
if (!File.Exists(inputObjPath) || !File.Exists(cleanLog))
{
MeshlabWorkspace.Instance.CleanConvert(inputFile, inputObjPath, cleanLog);
}
if (generateBlender)
{
//generate images for original model
BlenderWorkspace.Instance.RenderToImage(inputObjPath, Path(Subfolder.none, originalModelName, Ext.png));
return;
}
if (!File.Exists(inputStlPath))
{
MeshlabWorkspace.Instance.Run($"-i {inputObjPath} -o {inputStlPath}");
}
if (!File.Exists(inputOffPath))
{
MeshlabWorkspace.Instance.Run($"-i {inputObjPath} -o {inputOffPath}");
}
if (!File.Exists(inputPlyPath))
{
MeshlabWorkspace.Instance.Run($"-i {inputObjPath} -o {inputPlyPath}");
}
List <AlgoStep> steps = GetSteps(qualitySteps, cleanLog);
var algosToRun = new TimeReportCollection <Algo>(GetUsersChoice(allAlgos, "programs"));
var operationsToRun = GetUsersChoice(DeclareOperations(), "operations");
foreach (var item in operationsToRun)
{
Logger.WriteLine($"------------------------\nPerforming: {item.desc}\n------------------------");
item.algosStepsDel(algosToRun, new TimeReportCollection <AlgoStep>(steps));
}
Logger.WriteLine("Finished");
PlaySound(3, SystemSounds.Exclamation);
}
private static void RunData(TimeReportCollection <Algo> algos, TimeReportCollection <AlgoStep> steps)
{
var tablesPath = Path(Subfolder.data, "table", Ext.tex);
foreach (var item in Directory.GetFiles($"{WorkingDir}\\{Subfolder.data}"))
{
File.Delete(item);
}
var algosArray = algos.ToArray();
string legend = "\\legend{";
for (int i = 0; i < algosArray.Length; i++)
{
Algo alg = algosArray[i];
if (i > 0)
{
legend += ",";
}
legend += alg.ao.name;
}
legend += "}";
var plotPaths = new HashSet <string>();
foreach (var algo in algos)
{
foreach (var step in steps)
{
var outputPath = Path(Subfolder.meshes, $"{algo.ao.name}_{step.qualityStr}", Ext.obj);
var outputPathTxt = Path(Subfolder.logs, $"{algo.ao.name}_{step.qualityStr}", Ext.txt);
var inputPath = Path(Subfolder.none, originalModelName, algo.ext);
algo.ComputeResults(step, inputPath, outputPath, outputPathTxt);
}
//convert to csv and and latexv
//string hausdorffLogFileName = $"results_hausdorff_{algo.ao.name}";
//var csvPath = Path(Subfolder.data, hausdorffLogFileName, Ext.csv);
//var texPath = Path(Subfolder.data, hausdorffLogFileName, Ext.tex);
//save csv and and latex
//File.AppendAllText(csvPath, algo.results.GetCSVTable());
var latexTab = algo.results.GetLatexTable(algo.ao.name);
//File.AppendAllText(texPath, latexTab);
File.AppendAllText(tablesPath, latexTab);
var r = algo.PlotResults();
foreach (Algo.Plot item in r)
{
var plotPath = Path(Subfolder.data, item.name, Ext.tex);
if (!plotPaths.Contains(plotPath))
{
plotPaths.Add(plotPath);
}
File.AppendAllText(plotPath, item.value);
}
var r2 = algo.PlotTimeResults();
var plotPathTimeResults = Path(Subfolder.data, r2.name, Ext.tex);
File.AppendAllText(plotPathTimeResults, r2.value);
}
foreach (var plotPath in plotPaths)
{
File.AppendAllText(plotPath, '\n' + legend);
}
}
