MySources/utilities.hpp

368 lines
9.7 KiB
C++
Raw Normal View History

2020-11-27 11:47:21 +01:00
#ifndef UTILITIES_H
#define UTILITIES_H
#include <Eigen/Dense>
#include <filesystem>
#include <fstream>
#include <regex>
#include <iterator>
#include <algorithm>
#include <array>
2020-11-27 11:47:21 +01:00
#define GET_VARIABLE_NAME(Variable) (#Variable)
2020-11-27 11:47:21 +01:00
struct Vector6d : public std::array<double, 6> {
Vector6d() {
for (size_t i = 0; i < 6; i++) {
this->operator[](i) = 0;
}
}
2021-03-15 18:04:29 +01:00
Vector6d(const std::vector<double> &v) {
assert(v.size() == 6);
std::copy(v.begin(), v.end(), this->begin());
}
2020-11-27 11:47:21 +01:00
Vector6d(const double &d) {
for (size_t i = 0; i < 6; i++) {
this->operator[](i) = d;
}
}
Vector6d(const std::array<double, 6> &arr) : std::array<double, 6>(arr) {}
2020-11-27 11:47:21 +01:00
Vector6d(const std::initializer_list<double> &initList) {
std::copy(initList.begin(), initList.end(), std::begin(*this));
2020-11-27 11:47:21 +01:00
}
Vector6d operator*(const double &d) const {
Vector6d result;
for (size_t i = 0; i < 6; i++) {
result[i] = this->operator[](i) * d;
}
return result;
}
Vector6d operator*(const Vector6d &v) const {
Vector6d result;
for (size_t i = 0; i < 6; i++) {
result[i] = this->operator[](i) * v[i];
}
return result;
}
Vector6d operator/(const double &d) const {
Vector6d result;
for (size_t i = 0; i < 6; i++) {
result[i] = this->operator[](i) / d;
}
return result;
}
2021-07-15 11:01:12 +02:00
Vector6d operator/(const Vector6d &v) const
{
Vector6d result;
for (size_t i = 0; i < 6; i++) {
result[i] = this->operator[](i) / v[i];
}
return result;
}
2020-11-27 11:47:21 +01:00
Vector6d operator+(const Vector6d &v) const {
Vector6d result;
for (size_t i = 0; i < 6; i++) {
result[i] = this->operator[](i) + v[i];
}
return result;
}
Vector6d operator-(const Vector6d &v) const {
Vector6d result;
for (size_t i = 0; i < 6; i++) {
result[i] = this->operator[](i) - v[i];
}
return result;
}
Vector6d inverted() const {
Vector6d result;
for (size_t i = 0; i < 6; i++) {
assert(this->operator[](i) != 0);
result[i] = 1 / this->operator[](i);
}
return result;
}
bool isZero() const {
for (size_t i = 0; i < 6; i++) {
if (this->operator[](i) != 0)
return false;
}
return true;
}
double squaredNorm() const {
double squaredNorm = 0;
std::for_each(this->begin(), std::end(*this),
2020-11-27 11:47:21 +01:00
[&](const double &v) { squaredNorm += pow(v, 2); });
return squaredNorm;
}
double norm() const { return sqrt(squaredNorm()); }
bool isFinite() const {
return std::any_of(std::begin(*this), std::end(*this), [](const double &v) {
2020-11-27 11:47:21 +01:00
if (!std::isfinite(v)) {
return false;
}
return true;
});
}
2021-03-01 14:44:35 +01:00
Eigen::Vector3d getTranslation() const {
return Eigen::Vector3d(this->operator[](0), this->operator[](1),
this->operator[](2));
}
2021-04-30 12:13:58 +02:00
Eigen::Vector3d getRotation() const
{
return Eigen::Vector3d(this->operator[](3), this->operator[](4), this->operator[](5));
}
std::string toString() const
{
std::string s;
for (int i = 0; i < 6; i++) {
s.append(std::to_string(this->operator[](i)) + ",");
}
s.pop_back();
return s;
}
2020-11-27 11:47:21 +01:00
};
namespace Utilities {
inline void parseIntegers(const std::string &str, std::vector<size_t> &result) {
typedef std::regex_iterator<std::string::const_iterator> re_iterator;
typedef re_iterator::value_type re_iterated;
std::regex re("(\\d+)");
re_iterator rit(str.begin(), str.end(), re);
re_iterator rend;
std::transform(rit, rend, std::back_inserter(result),
[](const re_iterated &it) { return std::stoi(it[1]); });
}
inline Eigen::MatrixXd toEigenMatrix(const std::vector<Vector6d> &v) {
2021-05-24 13:43:32 +02:00
Eigen::MatrixXd m(v.size(), 6);
2021-05-24 13:43:32 +02:00
for (size_t vi = 0; vi < v.size(); vi++) {
const Vector6d &vec = v[vi];
for (size_t i = 0; i < 6; i++) {
m(vi, i) = vec[i];
}
}
return m;
}
2021-04-30 12:13:58 +02:00
inline std::vector<Vector6d> fromEigenMatrix(const Eigen::MatrixXd &m)
{
std::vector<Vector6d> v(m.rows());
for (size_t vi = 0; vi < m.rows(); vi++) {
const Eigen::RowVectorXd &row = m.row(vi);
for (size_t i = 0; i < 6; i++) {
v[vi][i] = row(i);
}
}
return v;
}
// std::string convertToLowercase(const std::string &s) {
// std::string lowercase;
// std::transform(s.begin(), s.end(), lowercase.begin(),
// [](unsigned char c) { return std::tolower(c); });
// return lowercase;
//}
// bool hasExtension(const std::string &filename, const std::string &extension)
// {
// const std::filesystem::path path(filename);
// if (!path.has_extension()) {
// std::cerr << "Error: No file extension found in " << filename <<
// std::endl; return false;
// }
// const std::string detectedExtension = path.extension().string();
// if (convertToLowercase(detectedExtension) != convertToLowercase(extension))
// {
// std::cerr << "Error: detected extension is " + detectedExtension +
// " and not " + extension
// << std::endl;
// return false;
// }
// return true;
//}
} // namespace Utilities
2021-03-01 14:44:35 +01:00
#ifdef POLYSCOPE_DEFINED
2020-11-27 11:47:21 +01:00
#include "polyscope/curve_network.h"
2021-04-30 12:13:58 +02:00
#include "polyscope/pick.h"
2020-11-27 11:47:21 +01:00
#include "polyscope/polyscope.h"
2021-04-30 12:13:58 +02:00
#include <functional>
namespace PolyscopeInterface {
inline struct GlobalPolyscopeData
{
std::vector<std::function<void()>> userCallbacks;
} globalPolyscopeData;
inline void mainCallback()
{
ImGui::PushItemWidth(100); // Make ui elements 100 pixels wide,
// instead of full width. Must have
// matching PopItemWidth() below.
for (std::function<void()> userCallback : globalPolyscopeData.userCallbacks) {
userCallback();
}
2020-11-27 11:47:21 +01:00
2021-04-30 12:13:58 +02:00
ImGui::PopItemWidth();
}
2021-02-05 18:58:15 +01:00
2021-04-30 12:13:58 +02:00
inline void addUserCallback(const std::function<void()> &userCallback)
{
globalPolyscopeData.userCallbacks.push_back(userCallback);
2021-02-05 18:58:15 +01:00
}
2021-04-08 20:03:23 +02:00
2021-04-30 12:13:58 +02:00
inline void deinitPolyscope()
{
if (!polyscope::state::initialized) {
return;
}
2021-05-24 13:43:32 +02:00
polyscope::render::engine->shutdownImGui();
2020-11-27 11:47:21 +01:00
}
2021-04-30 12:13:58 +02:00
inline void init()
{
if (polyscope::state::initialized) {
return;
}
polyscope::init();
polyscope::options::groundPlaneEnabled = false;
polyscope::view::upDir = polyscope::view::UpDir::ZUp;
polyscope::state::userCallback = &mainCallback;
polyscope::options::autocenterStructures = false;
polyscope::options::autoscaleStructures = false;
2021-04-30 12:13:58 +02:00
}
using PolyscopeLabel = std::string;
inline std::pair<PolyscopeLabel, size_t> getSelection()
{
std::pair<polyscope::Structure *, size_t> selection = polyscope::pick::getSelection();
if (selection.first == nullptr) {
return std::make_pair(std::string(), 0);
}
return std::make_pair(selection.first->name, selection.second);
2020-11-27 11:47:21 +01:00
}
2021-04-30 12:13:58 +02:00
inline void registerWorldAxes()
{
PolyscopeInterface::init();
Eigen::MatrixX3d axesPositions(4, 3);
axesPositions.row(0) = Eigen::Vector3d(0, 0, 0);
// axesPositions.row(1) = Eigen::Vector3d(polyscope::state::lengthScale, 0, 0);
// axesPositions.row(2) = Eigen::Vector3d(0, polyscope::state::lengthScale, 0);
// axesPositions.row(3) = Eigen::Vector3d(0, 0, polyscope::state::lengthScale);
axesPositions.row(1) = Eigen::Vector3d(1, 0, 0);
axesPositions.row(2) = Eigen::Vector3d(0, 1, 0);
axesPositions.row(3) = Eigen::Vector3d(0, 0, 1);
2021-04-30 12:13:58 +02:00
Eigen::MatrixX2i axesEdges(3, 2);
axesEdges.row(0) = Eigen::Vector2i(0, 1);
axesEdges.row(1) = Eigen::Vector2i(0, 2);
axesEdges.row(2) = Eigen::Vector2i(0, 3);
Eigen::MatrixX3d axesColors(3, 3);
axesColors.row(0) = Eigen::Vector3d(1, 0, 0);
axesColors.row(1) = Eigen::Vector3d(0, 1, 0);
axesColors.row(2) = Eigen::Vector3d(0, 0, 1);
const std::string worldAxesName = "World Axes";
polyscope::registerCurveNetwork(worldAxesName, axesPositions, axesEdges);
polyscope::getCurveNetwork(worldAxesName)->setRadius(0.0001, false);
const std::string worldAxesColorName = worldAxesName + " Color";
polyscope::getCurveNetwork(worldAxesName)
->addEdgeColorQuantity(worldAxesColorName, axesColors)
->setEnabled(true);
}
} // namespace PolyscopeInterface
2021-03-01 14:44:35 +01:00
#endif
// namespace ConfigurationFile {
2020-11-27 11:47:21 +01:00
2021-03-01 14:44:35 +01:00
//}
//} // namespace ConfigurationFile
2020-11-27 11:47:21 +01:00
template <typename T1, typename T2>
void constructInverseMap(const T1 &map, T2 &oppositeMap) {
assert(!map.empty());
oppositeMap.clear();
for (const auto &mapIt : map) {
oppositeMap[mapIt.second] = mapIt.first;
}
}
2021-02-05 18:58:15 +01:00
template <typename T> std::string toString(const T &v) {
return "(" + std::to_string(v[0]) + "," + std::to_string(v[1]) + "," +
std::to_string(v[2]) + ")";
}
2021-04-30 12:13:58 +02:00
template<typename T>
std::string to_string_with_precision(const T a_value, const int n = 2)
{
std::ostringstream out;
out.precision(n);
out << std::fixed << a_value;
return out.str();
}
2021-05-24 13:43:32 +02:00
template<typename T>
size_t computeHashUnordered(const std::vector<T> &v)
{
size_t hash = 0;
for (const auto &el : v) {
hash += std::hash<T>{}(el);
}
return hash;
}
inline size_t computeHashOrdered(const std::vector<int> &v)
2021-05-24 13:43:32 +02:00
{
std::string elementsString;
for (const auto &el : v) {
elementsString += std::to_string(el);
}
return std::hash<std::string>{}(elementsString);
}
2021-11-15 10:08:39 +01:00
//inline std::filesystem::path getFilepathWithExtension(const std::filesystem::path &folderPath,
// const std::string &extension)
//{
// for (const std::filesystem::directory_entry &dirEntry :
// std::filesystem::directory_iterator(folderPath)) {
// if (dirEntry.is_regular_file() && std::filesystem::path(dirEntry).extension() == extension) {
// return std::filesystem::path(dirEntry);
// }
// }
// return "";
//}
2020-11-27 11:47:21 +01:00
#endif // UTILITIES_H