COSC-4P80-Assignment-3/src/main.cpp

757 lines
30 KiB
C++

#include <blt/std/logging.h>
#include <blt/parse/argparse.h>
#include <blt/gfx/window.h>
#include "blt/gfx/renderer/resource_manager.h"
#include "blt/gfx/renderer/camera.h"
#include "implot.h"
#include <assign3/file.h>
#include <assign3/manager.h>
#include <thread>
#include <mutex>
#include <fstream>
#include <filesystem>
#include <cstdlib>
#include <utility>
#include <blt/fs/loader.h>
void plot_heatmap(const std::string& path, const std::string& activations_csv, const blt::size_t bin_size, const std::string& subtitle)
{
#ifdef __linux__
auto pwd = std::filesystem::current_path().string();
if (!blt::string::ends_with(pwd, '/'))
pwd += '/';
const std::string command = "cd '" + path + "' && python3 '" + pwd + "../plot_heatmap.py' '" + activations_csv + "' '" + std::to_string(bin_size)
+
"' '" + subtitle + "'";
BLT_TRACE(command);
std::system(command.c_str());
#endif
}
void plot_line_graph(const std::string& path, const std::string& topological_csv, const std::string& quantization_csv, blt::size_t bin_size,
const std::string& subtitle, const std::string& subtitle2)
{
#ifdef __linux__
auto pwd = std::filesystem::current_path().string();
if (!blt::string::ends_with(pwd, '/'))
pwd += '/';
const std::string command = "cd '" + path + "' && python3 '" + pwd + "../plot_line_graph.py' \"" + topological_csv + "\" \"" + quantization_csv +
"\" " + std::to_string(bin_size) + " true \"" + subtitle + "\" \"" + subtitle2 + "\"";
BLT_TRACE(command);
std::system(command.c_str());
#endif
}
using namespace assign3;
blt::gfx::matrix_state_manager global_matrices;
blt::gfx::resource_manager resources;
blt::gfx::first_person_camera_2d camera;
assign3::motor_data_t data{};
assign3::renderer_t renderer{data, resources, global_matrices};
void init(const blt::gfx::window_data&)
{
using namespace blt::gfx;
BLT_INFO("Hello World!");
global_matrices.create_internals();
resources.load_resources();
renderer.create();
ImPlot::CreateContext();
}
void update(const blt::gfx::window_data& window_data)
{
using namespace blt::gfx;
constexpr float color = 0.15;
// constexpr float color = 1;
glClearColor(color, color, color, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
global_matrices.update_perspectives(window_data.width, window_data.height, 90, 0.1, 2000);
camera.update();
camera.update_view(global_matrices);
global_matrices.update();
renderer.render();
}
void destroy(const blt::gfx::window_data&)
{
global_matrices.cleanup();
resources.cleanup();
renderer.cleanup();
ImPlot::DestroyContext();
blt::gfx::cleanup();
BLT_INFO("Goodbye World!");
}
void load_data_files(const std::string& str)
{
data.files = assign3::data_file_t::load_data_files_from_path(str);
for (auto& v : data.files)
v = v.normalize();
data.update();
}
void action_start_graphics(const std::vector<std::string>& argv_vector)
{
blt::arg_parse parser{};
parser.setHelpExtras("graphics");
parser.addArgument(blt::arg_builder{"--file", "-f"}
.setDefault("../data")
.setHelp("Path to data files").build());
auto args = parser.parse_args(argv_vector);
load_data_files(args.get<std::string>("file"));
blt::gfx::init(blt::gfx::window_data{"My Sexy Window", init, update, destroy}.setSyncInterval(1).setMaximized(true));
}
void write_csv(const std::vector<Scalar>& vec, const std::string& path, const std::string& header = "")
{
std::ofstream stream{path};
stream << header << std::endl;
for (const auto v : vec)
stream << v << std::endl;
}
void load_csv(std::vector<Scalar>& vec, const std::string& path)
{
auto lines = blt::fs::getLinesFromFile(path);
for (const auto& [i, line] : blt::enumerate(lines).skip(1))
vec.push_back(std::stof(line));
}
struct task_t // NOLINT
{
data_file_t* file;
blt::u32 width, height;
blt::size_t max_epochs;
shape_t shape;
init_t init;
Scalar initial_learn_rate;
task_t() = default; // NOLINT
task_t(data_file_t* file, blt::u32 width, blt::u32 height, size_t maxEpochs, shape_t shape, init_t init, Scalar initial_learn_rate):
file(file), width(width), height(height), max_epochs(maxEpochs), shape(shape), init(init), initial_learn_rate(initial_learn_rate)
{
}
gaussian_function_t topology_func{};
std::vector<std::vector<Scalar>> topological_errors{};
std::vector<std::vector<Scalar>> quantization_errors{};
std::vector<std::vector<Scalar>> activations{};
};
struct sortable_data_t
{
std::string_view path;
Scalar value;
blt::u32 rank;
sortable_data_t(const std::string_view& path, Scalar value, blt::u32 rank): path(path), value(value), rank(rank)
{
}
friend bool operator==(const sortable_data_t& lhs, const sortable_data_t& rhs)
{
return lhs.value == rhs.value;
}
friend bool operator!=(const sortable_data_t& lhs, const sortable_data_t& rhs)
{
return !(lhs == rhs);
}
friend bool operator<(const sortable_data_t& lhs, const sortable_data_t& rhs)
{
return lhs.value < rhs.value;
}
friend bool operator<=(const sortable_data_t& lhs, const sortable_data_t& rhs)
{
return !(rhs < lhs);
}
friend bool operator>(const sortable_data_t& lhs, const sortable_data_t& rhs)
{
return rhs < lhs;
}
friend bool operator>=(const sortable_data_t& lhs, const sortable_data_t& rhs)
{
return !(lhs < rhs);
}
};
std::string make_path(const task_t& task)
{
std::stringstream paths;
paths << "bins-" << task.file->data_points.begin()->bins.size() << "/";
paths << task.width << "x" << task.height << '-' << task.max_epochs << '/';
std::string shape_name = shape_names[static_cast<int>(task.shape)];
std::string init_name = init_names[static_cast<int>(task.init)];
blt::string::replaceAll(shape_name, " ", "-");
blt::string::replaceAll(init_name, " ", "-");
paths << shape_name << '/';
paths << init_name << '-' << task.initial_learn_rate << '/';
return paths.str();
}
void action_test(const std::vector<std::string>& argv_vector)
{
blt::arg_parse parser{};
parser.setHelpExtras("test");
parser.addArgument(blt::arg_builder{"--file", "-f"}
.setDefault("../data")
.setHelp("Path to data files").build());
auto args = parser.parse_args(argv_vector);
load_data_files(args.get<std::string>("file"));
std::vector<task_t> tasks;
std::vector<std::thread> threads;
std::mutex task_mutex;
// tasks.emplace_back(&data.files.back(), 5, 5, 2000, shape_t::GRID, init_t::COMPLETELY_RANDOM, 1);
// tasks.emplace_back(&data.files.back(), 5, 5, 2000, shape_t::GRID, init_t::RANDOM_DATA, 1);
// tasks.emplace_back(&data.files.back(), 5, 5, 2000, shape_t::GRID, init_t::SAMPLED_DATA, 1);
for (auto& file : data.files)
{
for (blt::u32 size = 5; size <= 7; size++)
{
for (int shape = 0; shape < 4; shape++)
{
for (int init = 0; init < 3; init++)
{
tasks.emplace_back(&file, size, size, 2000, static_cast<shape_t>(shape), static_cast<init_t>(init), 1);
}
}
}
}
static blt::size_t runs = 30;
for (blt::size_t _ = 0; _ < std::thread::hardware_concurrency(); _++)
{
threads.emplace_back([&task_mutex, &tasks]()
{
do
{
task_t task;
{
std::scoped_lock lock(task_mutex);
if (tasks.empty())
break;
task = std::move(tasks.back());
tasks.pop_back();
}
bool do_run = false;
if (do_run)
{
for (blt::size_t run = 0; run < runs; run++)
{
gaussian_function_t func{};
auto dist = distance_function_t::from_shape(task.shape, task.width, task.height);
auto som = std::make_unique<som_t>(*task.file, task.width, task.height, task.max_epochs, dist.get(),
&task.topology_func, task.shape, task.init, false);
while (som->get_current_epoch() < som->get_max_epochs())
som->train_epoch(task.initial_learn_rate);
task.topological_errors.push_back(som->get_topological_errors());
task.quantization_errors.push_back(som->get_quantization_errors());
std::vector<Scalar> acts;
for (const auto& v : som->get_array().get_map())
acts.push_back(v.get_activation());
task.activations.emplace_back(std::move(acts));
}
}
auto path = make_path(task);
std::filesystem::create_directories(path);
std::vector<Scalar> average_topological_errors;
std::vector<Scalar> average_quantization_errors;
std::vector<Scalar> average_activations;
std::vector<Scalar> stddev_topological_errors;
std::vector<Scalar> stddev_quantization_errors;
std::vector<Scalar> min_topological_errors;
std::vector<Scalar> min_quantization_errors;
std::vector<Scalar> last_topological_errors;
std::vector<Scalar> last_quantization_errors;
if (do_run)
{
average_topological_errors.resize(task.topological_errors.begin()->size());
average_quantization_errors.resize(task.quantization_errors.begin()->size());
average_activations.resize(task.activations.begin()->size());
stddev_topological_errors.resize(task.topological_errors.begin()->size());
stddev_quantization_errors.resize(task.quantization_errors.begin()->size());
min_topological_errors.resize(runs);
min_quantization_errors.resize(runs);
last_topological_errors.resize(runs);
last_quantization_errors.resize(runs);
for (auto [i, v] : blt::enumerate(task.topological_errors))
{
min_topological_errors[i] = *std::min_element(v.begin(), v.end());
last_topological_errors[i] = v.back();
}
for (auto [i, v] : blt::enumerate(task.quantization_errors))
{
min_quantization_errors[i] = *std::min_element(v.begin(), v.end());
last_quantization_errors[i] = v.back();
}
for (const auto& vec : task.topological_errors)
for (auto [index, v] : blt::enumerate(vec))
average_topological_errors[index] += v;
for (const auto& vec : task.quantization_errors)
for (auto [index, v] : blt::enumerate(vec))
average_quantization_errors[index] += v;
for (const auto& vec : task.activations)
for (auto [index, v] : blt::enumerate(vec))
average_activations[index] += v;
// calculate mean per point
for (auto& v : average_topological_errors)
v /= static_cast<Scalar>(runs);
for (auto& v : average_quantization_errors)
v /= static_cast<Scalar>(runs);
for (auto [i, mean] : blt::in_pairs(average_topological_errors, average_quantization_errors).enumerate())
{
auto [t_mean, q_mean] = mean;
float variance_t = 0;
float variance_q = 0;
for (const auto& vec : task.topological_errors)
{
auto d = vec[i] - t_mean;
variance_t += d * d;
}
for (const auto& vec : task.quantization_errors)
{
auto d = vec[i] - q_mean;
variance_q += d * d;
}
variance_t /= static_cast<Scalar>(runs);
variance_q /= static_cast<Scalar>(runs);
stddev_topological_errors[i] = std::sqrt(variance_t);
stddev_quantization_errors[i] = std::sqrt(variance_q);
}
}
else
{
load_csv(average_topological_errors, path + "topological_avg.csv");
load_csv(average_quantization_errors, path + "quantization_avg.csv");
load_csv(average_activations, path + "activations_avg.csv");
load_csv(stddev_topological_errors, path + "topological_stddev.csv");
load_csv(stddev_quantization_errors, path + "quantization_stddev.csv");
load_csv(min_topological_errors, path + "min_topological.csv");
load_csv(min_quantization_errors, path + "min_quantization.csv");
load_csv(last_topological_errors, path + "last_topological.csv");
load_csv(last_quantization_errors, path + "last_quantization.csv");
}
Scalar avg_quantization_stddev = 0;
Scalar avg_topological_stddev = 0;
for (auto [q, t] : blt::in_pairs(stddev_quantization_errors, stddev_topological_errors))
{
avg_quantization_stddev += q;
avg_topological_stddev += t;
}
avg_quantization_stddev /= static_cast<Scalar>(task.max_epochs);
avg_topological_stddev /= static_cast<Scalar>(task.max_epochs);
auto min_quant =
*std::min_element(average_quantization_errors.begin(), average_quantization_errors.end());
auto max_quant =
*std::max_element(average_quantization_errors.begin(), average_quantization_errors.end());
auto min_topo = *std::min_element(average_topological_errors.begin(), average_topological_errors.end());
auto max_topo = *std::max_element(average_topological_errors.begin(), average_topological_errors.end());
if (do_run)
{
std::ofstream topological{path + "topological_avg.csv"};
std::ofstream quantization{path + "quantization_avg.csv"};
std::ofstream activations_avg{path + "activations_avg.csv"};
std::ofstream activations{path + "activations.csv"};
std::ofstream topological_stddev{path + "topological_stddev.csv"};
std::ofstream quantization_stddev{path + "quantization_stddev.csv"};
write_csv(min_topological_errors, path + "min_topological.csv");
write_csv(min_quantization_errors, path + "min_quantization.csv");
write_csv(last_topological_errors, path + "last_topological.csv");
write_csv(last_quantization_errors, path + "last_quantization.csv");
topological_stddev << "Average topological stddev: " << avg_topological_stddev << std::endl;
quantization_stddev << "Average quantization stddev: " << avg_quantization_stddev << std::endl;
// topological_stddev << "Stddev Over Epochs: " << std::endl;
// quantization_stddev << "Stddev Over Epochs: " << std::endl;
for (auto v : stddev_topological_errors)
topological_stddev << v << std::endl;
for (auto v : stddev_quantization_errors)
quantization_stddev << v << std::endl;
topological << "error\n";
quantization << "error\n";
for (auto [i, v] : blt::enumerate(average_topological_errors))
{
topological << v << '\n';
}
for (auto [i, v] : blt::enumerate(average_quantization_errors))
{
quantization << v << '\n';
}
for (auto [i, v] : blt::enumerate(average_activations))
{
activations_avg << v / static_cast<Scalar>(runs);
if (i % task.width == task.width - 1)
activations_avg << '\n';
else
activations_avg << ',';
}
for (auto [i, v] : blt::enumerate(task.activations.front()))
{
activations << v;
if (i % task.width == task.width - 1)
activations << '\n';
else
activations << ',';
}
}
std::string shape_name = shape_names[static_cast<int>(task.shape)];
std::string init_name = init_names[static_cast<int>(task.init)];
blt::string::replaceAll(shape_name, " ", "-");
blt::string::replaceAll(init_name, " ", "-");
plot_heatmap(path, "activations.csv", task.file->data_points.front().bins.size(),
std::to_string(task.width) + "x" + std::to_string(task.height) + " " += shape_name + ", " += init_name + ", " +
std::to_string(
task.max_epochs) +
" Epochs");
plot_line_graph(path, "topological_avg.csv", "quantization_avg.csv", task.file->data_points.front().bins.size(),
std::to_string(task.width) + "x" + std::to_string(task.height) + " " += shape_name + ", " += init_name + ", Min: " +
std::to_string(min_topo) + ", Max: " + std::to_string(max_topo) +
", " + std::to_string(task.max_epochs) + " Epochs",
std::to_string(task.width) + "x" + std::to_string(task.height) + " " += shape_name + ", " += init_name + ", Min: " +
std::to_string(min_quant) + ", Max: " +
std::to_string(max_quant) +", " + std::to_string(task.max_epochs) +
" Epochs");
BLT_INFO("Task '%s' Complete", path.c_str());
}
while (true);
});
}
while (!threads.empty())
{
if (threads.back().joinable())
{
threads.back().join();
threads.pop_back();
}
}
}
struct man_whitney_t
{
Scalar u1 = 0, u2 = 0;
Scalar U = 0, meanU = 0, sigmaU = 0;
Scalar z = 0, r = 0;
std::string name1, name2;
};
struct test_t
{
std::vector<task_t> tasks;
std::string path;
test_t() = default;
test_t(const std::vector<task_t>& tasks, std::string path)
: tasks(tasks), path(std::move(path))
{
}
};
double cumulativeNormal(const double x)
{
// two tailed
return 0.5 * std::erfc(-x * M_SQRT1_2) + (1.0 - 0.5 * std::erfc(x * M_SQRT1_2));
}
man_whitney_t do_man_whitney(const std::string& pop1_path, const std::string& pop2_path, const std::vector<sortable_data_t>& pop1,
const std::vector<sortable_data_t>& pop2)
{
std::vector<sortable_data_t> data;
data.insert(data.end(), pop1.begin(), pop1.end());
data.insert(data.end(), pop2.begin(), pop2.end());
std::sort(data.begin(), data.end());
Scalar T1 = 0, T2 = 0;
const auto n1 = static_cast<Scalar>(pop1.size()), n2 = static_cast<Scalar>(pop2.size());
blt::u32 rank = 1;
for (auto it = data.begin(); it != data.end();)
{
const auto begin = it;
blt::size_t total_count = 1;
blt::u32 total_rank = rank++;
while ((it + 1) != data.end() && *begin == *(it + 1))
{
++total_count;
total_rank += rank++;
++it;
}
++it;
for (auto it2 = begin; it2 != it; ++it2)
{
if (it2->path == pop1_path)
T1 += static_cast<Scalar>(total_rank) / static_cast<Scalar>(total_count);
else if (it2->path == pop2_path)
T2 += static_cast<Scalar>(total_rank) / static_cast<Scalar>(total_count);
else
BLT_ABORT(("Impossible Path " + std::string(it2->path)).c_str());
}
}
man_whitney_t man;
man.u1 = n1 * n2 + ((n1 * (n1 + 1)) / 2) - T1;
man.u2 = n1 * n2 + ((n2 * (n2 + 1)) / 2) - T2;
man.U = std::min(man.u1, man.u2);
man.meanU = (n1 * n2) / 2;
man.sigmaU = std::sqrt((n1 * n2 * (n1 + n2 + 1)) / 12);
man.z = (man.U - man.meanU) / man.sigmaU;
man.r = std::abs(man.z) / std::sqrt(n1 + n2);
man.name1 = pop1_path;
man.name2 = pop2_path;
return man;
}
void action_convert(const std::vector<std::string>& argv_vector)
{
blt::arg_parse parser{};
parser.setHelpExtras("convert");
parser.addArgument(blt::arg_builder{"--file", "-f"}
.setDefault("../data")
.setHelp("Path to data files").build());
auto args = parser.parse_args(argv_vector);
load_data_files(args.get<std::string>("file"));
std::vector<std::thread> threads;
std::vector<test_t> tasks;
std::mutex task_mutex;
for (auto& file : data.files)
{
for (blt::u32 i = 5; i <= 7; i++)
{
for (blt::i32 shape = 0; shape < 4; shape++)
{
auto shape_v = static_cast<shape_t>(shape);
tasks.emplace_back(std::vector{
task_t{&file, i, i, 2000, shape_v, init_t::COMPLETELY_RANDOM, 1.0},
task_t{&file, i, i, 2000, shape_v, init_t::RANDOM_DATA, 1.0},
task_t{&file, i, i, 2000, shape_v, init_t::SAMPLED_DATA, 1.0}
}, "UnUsed");
}
}
}
for (blt::size_t i = 0; i < std::thread::hardware_concurrency(); i++)
{
threads.emplace_back([&]()
{
while (true)
{
test_t t;
{
std::unique_lock lock(task_mutex);
if (tasks.empty())
break;
t = tasks.back();
tasks.pop_back();
}
std::vector<std::string> paths;
blt::hashmap_t<std::string, std::vector<sortable_data_t>> data;
blt::hashmap_t<std::string, const task_t*> task_data;
for (const auto& task : t.tasks)
{
auto path = make_path(task) + "last_topological.csv";
paths.push_back(path);
auto lines = blt::fs::getLinesFromFile(path);
for (const auto& line : blt::iterate(lines).skip(1))
data[path].emplace_back(paths.back(), std::stof(line), 0);
task_data[path] = &task;
}
std::string same = task_data.begin()->first;
for (const auto& task : task_data)
{
for (auto [i, c] : blt::enumerate(task.first))
{
if (i < same.length() && same[i] != task.first[i])
same[i] = '%';
}
}
auto lines = blt::string::split_sv(same, '/');
std::string filtered_path = "stats/";
blt::size_t index = 0;
for (const auto& [i, line] : blt::enumerate(lines))
{
if (blt::string::contains(line, '%'))
{
index = i;
continue;
}
filtered_path += line;
filtered_path += '/';
}
auto bin_line = blt::string::split(lines[0], '-');
auto bin_size = std::stoi(bin_line[1]);
std::filesystem::create_directories(filtered_path);
BLT_TRACE("Writing to path %s", filtered_path.c_str());
std::vector<man_whitney_t> mans;
for (auto [i, pair] : blt::iterate(data.begin(), data.end()).enumerate())
{
for (const auto& [path2, vec2] : blt::iterate(data.begin(), data.end()).skip(i + 1))
mans.emplace_back(do_man_whitney(pair.first, path2, pair.second, vec2));
}
std::ofstream stats{filtered_path + "results_table.txt"};
stats << "\\begin{figure}[h!]\n\t\\centering" << std::endl;
stats << "\t\\makebox[\\textwidth]{\\begin{tabular}{ccc}" << std::endl << "\t\t";
for (auto [i, task] : blt::enumerate(t.tasks))
{
if (i != 0)
stats << " & \n\t\t";
stats << "\\includegraphics[width=0.4\\textwidth]{" << make_path(task) + "errors-topological" << bin_size << "}";
}
stats << "\\\\" << std::endl;
stats << "\t\\end{tabular}}" << std::endl;
stats << "\t\\caption{}\n\t\\label{fig:}" << std::endl;
stats << "\\end{figure}" << std::endl << std::endl;
stats << "\\begin{figure}[h!]\n\t\\centering" << std::endl;
stats << "\t\\makebox[\\textwidth]{\\begin{tabular}{ccc}" << std::endl << "\t\t";
for (auto [i, task] : blt::enumerate(t.tasks))
{
if (i != 0)
stats << " & \n\t\t";
stats << "\\includegraphics[width=0.4\\textwidth]{" << make_path(task) + "errors-topological" << bin_size << "}";
}
stats << "\\\\" << std::endl << "\t\t";
for (auto [i, task] : blt::enumerate(t.tasks))
{
if (i != 0)
stats << " & \n\t\t";
stats << "\\includegraphics[width=0.4\\textwidth]{" << make_path(task) + "errors-quantization" << bin_size << "}";
}
stats << "\\\\" << std::endl;
stats << "\t\\end{tabular}}" << std::endl;
stats << "\t\\caption{}\n\t\\label{fig:}" << std::endl;
stats << "\\end{figure}" << std::endl << std::endl;
stats << "\\begin{table}[h!]\n\t\\centering" << std::endl;
stats <<
"\t\\makebox[\\textwidth]{\\begin{tabular}{||m{0.3\\linewidth}|m{0.125\\linewidth}|m{0.2\\linewidth}|m{0.2\\linewidth}|m{0.15\\linewidth}||}"
<< std::endl;
stats << "\t\t\\hline" << std::endl;
stats << "\t\tName & Z-Value & P-Value & Effect Size & Significant\\\\" << std::endl;
stats << "\t\t\\hline" << std::endl;
for (const auto& man : mans)
{
auto lines1 = blt::string::split(man.name1, '/');
auto lines2 = blt::string::split(man.name2, '/');
const auto& name1 = lines1[index];
const auto& name2 = lines2[index];
auto effect = man.r < 0.3 ? "Small" : (man.r < 0.5 ? "Medium" : "Large");
constexpr Scalar acceptance_region = 1.96;
auto sig = (man.z < -acceptance_region || man.z > acceptance_region) ? "Yes" : "No";
BLT_TRACE("Z: %f P: %f", man.z, cumulativeNormal(man.z));
stats << "\t\t" << name1 << " \\newline " << name2 << " & " << man.z << " & " << cumulativeNormal(man.z) << " & " << man.r << " ("
<< effect << ") & " << sig << "\\\\" << std::endl;
stats << "\t\t\\hline" << std::endl;
}
stats << "\t\\end{tabular}}" << std::endl;
stats << "\t\\caption{}\n\t\\label{tbl:}" << std::endl;
stats << "\\end{table}" << std::endl;
}
});
}
for (auto& thread : threads)
{
if (thread.joinable())
thread.join();
}
}
int main(int argc, const char** argv)
{
std::vector<std::string> argv_vector;
for (int i = 0; i < argc; i++)
argv_vector.emplace_back(argv[i]);
#ifdef __EMSCRIPTEN__
action_start_graphics(argv_vector);
return 0;
#endif
blt::arg_parse parser{};
parser.addArgument(blt::arg_builder{"action"}
.setAction(blt::arg_action_t::SUBCOMMAND)
.setHelp("Action to run. Can be: [graphics, test, convert]").build());
auto args = parser.parse_args(argv_vector);
if (!args.contains("action"))
{
BLT_ERROR("Please provide an action");
return 0;
}
// argv_vector.erase(argv_vector.begin() + 1);
auto action = blt::string::toLowerCase(args.get<std::string>("action"));
if (action == "graphics")
action_start_graphics(argv_vector);
else if (action == "test")
action_test(argv_vector);
else if (action == "convert")
action_convert(argv_vector);
}