repository·master·Indexed 24 days ago
https://github.com/nmwsharp/polyscopeA lightweight C++/Python viewer and user interface for 3D data such as meshes and point clouds. It provides an interactive 3D GUI to visualize geometric structures and associated scalar or vector quantities with minimal code.
args library is designed for high performance. Benchmarks indicate it is significantly faster than common alternatives like TCLAP and boost::program_options when parsing and retrieving arguments.The library is designed around three primary goals:
json.hpp) with no dependencies or complex build requirements.Note on Performance and Memory:
std::string for strings, int64_t/uint64_t/double for numbers, std::map for objects, std::vector for arrays, and bool for Booleans. You can customize this by templating the basic_json class.Polyscope operates on a paradigm of structures and quantities:
When you register a structure and its quantities, Polyscope automatically handles the visualization boilerplate, including toggling visibility, color-mapping data, adjusting color maps, and enabling 'picking' to query numerical values by clicking in the 3D scene.
The library uses debug assertions to catch errors. You can disable these by defining the NDEBUG preprocessor macro.
Warning on operator[]: For const objects, operator[] implements unchecked access. If the requested key does not exist, the behavior is undefined (similar to dereferencing a null pointer) and will trigger an assertion failure if assertions are enabled.
Best Practice: If you are unsure whether a key exists in a JSON object, use the checked access method at() instead of operator[] to avoid undefined behavior.
Arguments can be organized into args::Group objects to enforce validation logic. Groups can be nested to create complex validation hierarchies.
Supported validators for args::Group include:
args::Group::Validators::Xor: Exactly one of the flags in the group must be present.args::Group::Validators::AllOrNone: Either all flags in the group must be present, or none at all.args::Group::Validators::AtLeastOne: At least one flag in the group must be present.When a ValidationError occurs, you can use parser.Help(std::cerr) to print a formatted help menu that clearly shows the group nesting and validation requirements.
If you cannot modify the namespace of a type (e.g., boost::optional or std::filesystem::path), you can specialize nlohmann::adl_serializer within the nlohmann namespace.
namespace nlohmann {
template <typename T>
struct adl_serializer<boost::optional<T>> {
static void to_json(json& j, const boost::optional<T>& opt) {
if (opt == boost::none) {
j = nullptr;
} else {
j = *opt;
}
}
static void from_json(const json& j, boost::optional<T>& opt) {
if (j.is_null()) {
opt = boost::none;
} else {
opt = j.get<T>();
}
}
};
}You can group arguments together and apply validation logic (e.g., Xor, And, Or). If a group's validation fails, the parser throws an args::ValidationError.
Because group validation can involve complex logic (like (A && B) || (C && (D XOR E))), the library cannot automatically tell you which specific part of the logic failed. To provide helpful error messages to users, you must catch args::ValidationError and manually check your group conditions to print custom messages.
#include <iostream>
#include <args.hxx>
int main(int argc, char **argv)
{
args::ArgumentParser parser("This is a test program.", "This goes after the options.");
// Create an exclusive group (XOR)
args::Group group(parser, "This group is all exclusive:", args::Group::Validators::Xor);
args::Flag foo(group, "foo", "The foo flag", {'f', "foo"});
args::Flag bar(group, "bar", "The bar flag", {'b'});
args::Flag baz(group, "baz", "The baz flag", {"baz"});
try
{
parser.ParseCLI(argc, argv);
}
catch (args::Help)
{
std::cout << parser;
return 0;
}
catch (args::ParseError e)
{
std::cerr << e.what() << std::endl;
std::cerr << parser;
return 1;
}
catch (args::ValidationError e)
{
// Custom error handling for failed group validation
std::cerr << e.what() << std::endl;
std::cerr << parser;
return 1;
}
if (foo) { std::cout << "foo" << std::endl; }
if (bar) { std::cout << "bar" << std::endl; }
if (baz) { std::cout << "baz" << std::endl; }
return 0;
}tsl::ordered_map or nlohmann::fifo_map.The library follows RFC 7159 for Unicode support:
std::string type, functions like .size() or .length() return the number of bytes, not the number of characters or glyphs.Each generated language file for a specific font contains:
ICON_* naming convention.min: The minimum code point (excluding ASCII characters).max: The maximum code point.max 16 bit: The maximum 16-bit code point, specifically useful for libraries that only support 16-bit code points, such as Dear ImGui.Font Awesome Pro is a commercial product. To generate language files for version 5 (or similar processes for 6+), follow these steps:
icons.yml file (found in the package's metadata/ directory) in the same directory as the GenerateIconFontCppHeaders.py script.GenerateIconFontCppHeaders.py script..ttf files from the package (e.g., fa-brands-400.ttf, fa-light-300.ttf, fa-regular-400.ttf, fa-solid-900.ttf).