Convert tool to convert wmtk mesh types

applications/CMakeLists.txt

@@ -32,6 +32,7 @@ add_application(triwild ON)
 add_application(cdt_sec ON)
 add_application(shortest_edge_collapse ON)
 add_application(insertion ON)
+add_application(convert ON)
 
 
 

applications/convert/CMakeLists.txt

@@ -0,0 +1,23 @@
+include(wmtk_add_application)
+include(wmtk_register_jse_json)
+wmtk_add_application(convert_app
+    main.cpp
+    )
+
+target_compile_features(convert_app PUBLIC cxx_std_20)
+    #register_jse_json(APPLICATION_NAME convert INPUT convert_spec.json )
+
+# convert requires the output component and the convert component
+target_link_libraries(convert_app PRIVATE
+wmtk::input
+wmtk::output
+wmtk::multimesh
+wmtk::application_utils
+)
+
+wmtk_register_integration_test(
+    EXEC_NAME convert_app
+    CONFIG_FILE ${CMAKE_CURRENT_SOURCE_DIR}/test_config.json
+    CONFIG_PATH ${CMAKE_CURRENT_SOURCE_DIR}/examples
+    EXTRA_ARGUMENTS run
+)

applications/convert/examples/make_boundary.json

@@ -0,0 +1,22 @@
+{
+    "input": [
+        {
+            "file": "_pos.msh",
+            "name_spec": "position"
+        }
+    ],
+    "tree": {
+        "position": {
+            "type": "boundary",
+            "dimension": 1
+        }
+
+    },
+
+    "output": {
+        "file": "ogre_boundary.hdf5",
+        "type": ".hdf5"
+    }
+
+
+}

applications/convert/examples/merge_uv.json

@@ -0,0 +1,23 @@
+{
+    "input": [
+        {
+            "file": "_pos.msh",
+            "name_spec": "position"
+        },
+        {
+            "file": "_tex.msh",
+            "name_spec": "uv"
+        }
+    ],
+    "tree": {
+        "position": "uv"
+
+    },
+
+    "output": {
+        "file": "ogre.hdf5",
+        "type": ".hdf5"
+    }
+
+
+}

applications/convert/examples/split_uv.json

@@ -0,0 +1,19 @@
+{
+    "input": {
+        "file": "ogre.hdf5",
+        "name_spec": 
+        {
+            "position": "uv"
+        }
+    }, 
+    "output": {
+        "position": {
+            "file": "ogre_pos.vtu",
+            "position_attribute": "vertices"
+        },
+        "position.uv": {
+            "file": "ogre_uv.vtu",
+            "position_attribute": "vertices"
+        }
+    }
+}

applications/convert/main.cpp

@@ -0,0 +1,168 @@
+
+#include <jse/jse.h>
+#include <CLI/App.hpp>
+#include <CLI/CLI.hpp>
+#include <filesystem>
+#include <nlohmann/json.hpp>
+#include <wmtk/applications/utils/element_count_report.hpp>
+
+#include <wmtk/Mesh.hpp>
+#include <wmtk/utils/Logger.hpp>
+
+#include <wmtk/components/input/InputOptions.hpp>
+#include <wmtk/components/input/input.hpp>
+
+#include <wmtk/components/output/OutputOptions.hpp>
+#include <wmtk/components/output/output.hpp>
+#include <wmtk/components/utils/resolve_path.hpp>
+
+#include "CLI/CLI.hpp"
+#include "wmtk/components/multimesh/MeshCollection.hpp"
+#include "wmtk/components/multimesh/from_boundary.hpp"
+#include "wmtk/components/multimesh/from_facet_bijection.hpp"
+
+using namespace wmtk::components;
+using namespace wmtk::applications;
+using namespace wmtk;
+namespace fs = std::filesystem;
+
+namespace {
+std::shared_ptr<wmtk::Mesh> merge_meshes(
+    wmtk::components::multimesh::MeshCollection& mc,
+    const nlohmann::json& js)
+{
+    for (const auto& [parent, child_datas] : js.items()) {
+        auto& parent_mesh = mc.get_mesh(parent);
+        if (child_datas.is_string()) {
+            auto& child_mesh = mc.get_mesh(child_datas.get<std::string>());
+            components::multimesh::from_facet_bijection(parent_mesh, child_mesh);
+            return parent_mesh.shared_from_this();
+
+        } else if (child_datas.is_object()) {
+            const std::string type = child_datas["type"];
+
+            if (type == "facet_bijection") {
+                const std::string child_name = child_datas["name"];
+                auto& child_mesh = mc.get_mesh(child_name);
+                components::multimesh::from_facet_bijection(parent_mesh, child_mesh);
+                return parent_mesh.shared_from_this();
+
+            } else if (type == "boundary") {
+                const int64_t dimension = child_datas["dimension"];
+                std::string boundary_attr_name = fmt::format("boundary_{}", dimension);
+                if (child_datas.contains("boundary_attribute_name")) {
+                    boundary_attr_name = child_datas["boundary_attribute_name"];
+                }
+                components::multimesh::from_boundary(
+                    parent_mesh,
+                    wmtk::get_primitive_type_from_id(dimension),
+                    boundary_attr_name);
+                return parent_mesh.shared_from_this();
+            }
+        }
+    }
+    return nullptr;
+}
+} // namespace
+
+int run(const fs::path& config_path /*, const std::optional<fs::path>& name_spec_file*/)
+{
+    nlohmann::json j;
+    {
+        std::ifstream ifs(config_path);
+        j = nlohmann::json::parse(ifs);
+        // if (name_spec_file.has_value()) {
+        //     j["name"] = nlohmann::json::parse(std::ifstream(name_spec_file.value()));
+        // }
+    }
+
+    wmtk::components::multimesh::MeshCollection meshes;
+    std::shared_ptr<wmtk::Mesh> output_mesh;
+    if (j["input"].is_array()) {
+        for (const auto& in_opts_js : j["input"]) {
+            wmtk::components::input::InputOptions opts = in_opts_js;
+            meshes.add_mesh(wmtk::components::input::input(opts));
+        }
+    } else {
+        wmtk::components::input::InputOptions opts = j["input"];
+        output_mesh =
+            meshes.add_mesh(wmtk::components::input::input(opts)).root().shared_from_this();
+    }
+
+    if (j.contains("tree")) {
+        output_mesh = merge_meshes(meshes, j["tree"]);
+    }
+
+    if (!j.contains("output")) {
+        wmtk::logger().info("convert: No output path provided");
+    } else if (j["output"].is_object()) {
+        for (const auto& [mesh_path, out_opts_js] : j["output"].items()) {
+            auto opts = out_opts_js.get<wmtk::components::output::OutputOptions>();
+
+            wmtk::components::output::output(meshes.get_mesh(mesh_path), opts);
+        }
+    } else {
+        auto opts = j["output"].get<wmtk::components::output::OutputOptions>();
+        wmtk::components::output::output(*output_mesh, opts);
+    }
+
+
+    // if (j.contains("report")) {
+    //     const std::string report = j["report"];
+    //     if (!report.empty()) {
+    //         nlohmann::json out_json;
+    //         out_json.update(wmtk::applications::utils::element_count_report_named(*mesh));
+    //         j.erase("report");
+    //         out_json["input"] = j;
+
+
+    //        std::ofstream ofs(report);
+    //        ofs << out_json;
+    //    }
+    //}
+    return 0;
+}
+
+
+int main(int argc, char* argv[])
+{
+    CLI::App app{argv[0]};
+
+    app.ignore_case();
+
+    fs::path json_input_file;
+    std::optional<fs::path> name_spec_file;
+
+    CLI::App* run_cmd; // = app.add_subcommand("run", "Run application");
+    run_cmd = &app;
+    run_cmd->add_option("-j, --json", json_input_file, "json specification file")
+        ->required(true)
+        ->check(CLI::ExistingFile);
+
+    // run_cmd->add_option("-n, --name_spec", name_spec_file, "json specification file")
+    //     ->check(CLI::ExistingFile);
+
+    CLI11_PARSE(app, argc, argv);
+
+    // someday may add other suboptions
+    assert(run_cmd->parsed());
+
+    // if (!json_input_file.has_value() && !fill_config_path.has_value()) {
+    //     wmtk::logger().error("An input json file with [-j] is required unless blank config "
+    //                          "generation is being used with [--fill-config]");
+    //     return 1;
+    // }
+
+    int exit_mode = -1;
+
+    // run_cmd->callback([&]() {
+    //     spdlog::warn("YOW!");
+    //     assert(json_input_file.has_value());
+    //     exit_mode = run(json_input_file.value());
+    // });
+    exit_mode = run(json_input_file /*, name_spec_file*/);
+
+
+    assert(exit_mode != -1); // "Some subcommand should have updated the exit mode"
+    return exit_mode;
+}

applications/convert/test_config.json

@@ -0,0 +1,7 @@
+{
+    "tests": [
+    ],
+    "input_tag": "input",
+    "oracle_tag": "report",
+    "input_directory_tag": "root"
+}

components/input/src/wmtk/components/input/CMakeLists.txt

@@ -10,13 +10,6 @@ set(SRC_FILES
     mesh_with_tag_from_image.hpp
     input.cpp
 	input.hpp
-    NamedMultiMesh.hpp
-    NamedMultiMesh.cpp
-    utils/get_attribute.hpp
-    utils/get_attribute.cpp
-
-    MeshCollection.hpp
-    MeshCollection.cpp
 )
 
 include(stb)
@@ -25,5 +18,6 @@ include(stb)
 target_compile_features(wmtk_${COMPONENT_NAME} PUBLIC cxx_std_20)
 
 target_sources(wmtk_${COMPONENT_NAME} PRIVATE ${SRC_FILES})
-target_link_libraries(wmtk_${COMPONENT_NAME} PRIVATE stb::image)
+target_link_libraries(wmtk_${COMPONENT_NAME} PRIVATE stb::image nlohmann_json)
+target_link_libraries(wmtk_${COMPONENT_NAME} PRIVATE stb::image nlohmann_json PUBLIC wmtk::multimesh)
 

components/input/src/wmtk/components/input/InputOptions.cpp

@@ -1,5 +1,6 @@
 #include "InputOptions.hpp"
 #include <wmtk/utils/Logger.hpp>
+#include <wmtk/components/utils/json_utils.hpp>
 
 
 namespace wmtk::components::input {
@@ -11,13 +12,19 @@
 void adl_serializer<wmtk::components::input::InputOptions>::to_json(json& j, const Type& v)
 {
     //
+    j["file"] = v.file;
     j["file"] = v.file.string();
     if (!v.name_spec.is_null()) {
+        assert(!v.name_spec_file.has_value());
         j["name_spec"] = v.name_spec;
+    } else if(v.name_spec_file.has_value()) {
+        j["name_spec_file"] = v.name_spec_file.value();
+
     }
     if (v.old_mode) {
         j["old_mode"] = true;
-        j["ignore_z"] = v.ignore_z_if_zero;
+        j["ignore_z"] = v.ignore_z_if_zero; // keep around for deprecation purposes
+        //j["ignore_z_if_zero"] = v.ignore_z_if_zero;
         if (v.imported_attributes.has_value()) {
             const auto& imported_attrs = v.imported_attributes.value();
             if (imported_attrs.size() > 3) {
@@ -33,13 +40,16 @@
 void adl_serializer<wmtk::components::input::InputOptions>::from_json(const json& j, Type& v)
 {
     if (j.is_string()) {
-        v.file = j.get<std::string>();
+        v.file = j.get<std::filesystem::path>();
         return;
     }
-    v.file = j["file"].get<std::string>();
+    v.file = j["file"].get<std::filesystem::path>();
     if (j.contains("name_spec")) {
         v.name_spec = j["name_spec"];
     }
+    if (j.contains("name_spec_file")) {
+        v.name_spec_file = j["name_spec_file"];
+    }
 
     v.old_mode = false;
     if (j.contains("old_mode")) {
@@ -58,6 +68,8 @@
 
     if (v.old_mode) {
         v.ignore_z_if_zero = j.contains("ignore_z") ? bool(j["ignore_z"]) : false;
+        // overwrite old ignore_z
+        //v.ignore_z_if_zero = j.contains("ignore_z_if_zero") ? bool(j["ignore_z_if_zero"]) : false;
         if (j.contains("tetrahedron_attributes")) {
             v.imported_attributes = {
                 {},

components/input/src/wmtk/components/input/InputOptions.hpp

@@ -15,7 +15,9 @@
     std::optional<std::vector<std::vector<std::string>>> imported_attributes;
 
 
+    // either you can have a name spec in json or you can have it in a file
     nlohmann::json name_spec;
+    std::optional<std::filesystem::path> name_spec_file;
 
     bool old_mode = false;
     bool ignore_z_if_zero = false;

components/input/src/wmtk/components/input/input.cpp

@@ -1,5 +1,6 @@
 #include "input.hpp"
 
+#include <fstream>
 #include <wmtk/io/read_mesh.hpp>
 #include <wmtk/utils/Logger.hpp>
 #include <wmtk/utils/mesh_utils.hpp>
@@ -22,7 +23,7 @@
     return input(options).root().shared_from_this();
 }
 
-NamedMultiMesh input(const InputOptions& options)
+multimesh::NamedMultiMesh input(const InputOptions& options)
 {
     if (!std::filesystem::exists(options.file)) {
         log_and_throw_error("file [{}] not found", options.file.string());
@@ -49,9 +50,16 @@
     assert(mesh->is_connectivity_valid());
 
 
-    NamedMultiMesh mm;
+    multimesh::NamedMultiMesh mm;
     mm.set_mesh(*mesh);
-    mm.set_names(options.name_spec);
+    if (!options.name_spec.is_null()) {
+        mm.set_names(options.name_spec);
+    } else if (options.name_spec_file.has_value()) {
+        std::ifstream ifs(options.name_spec_file.value());
+        nlohmann::json js;
+        ifs >> js;
+        mm.set_names(js);
+    }
 
     return mm;
 }