Isotropic Remeshing Part 2 (Works without MM)

CMakeLists.txt

@@ -123,6 +123,10 @@ else()
 target_compile_features(wildmeshing_toolkit PUBLIC cxx_std_17)
 endif()
 
+option(WMTK_MTAO_CONSTANTLY_VERIFY_MESH "verify mesh" OFF)
+if(WMTK_MTAO_CONSTANTLY_VERIFY_MESH)
+    target_compile_options(wildmeshing_toolkit PUBLIC  -DMTAO_CONSTANTLY_VERIFY_MESH)
+endif()
 #target_compile_options(wildmeshing_toolkit PUBLIC  -fconcepts)
 
 # the max dimension an attribute can be - default is to be any size (a dynamic size), but this can be set to a number like 6

applications/CMakeLists.txt

@@ -26,7 +26,7 @@ add_application(delaunay ON)
 add_application(marching ON)
 add_application(procedural ON)
 add_application(multimesh OFF)
-add_application(isotropic_remeshing OFF)
+add_application(isotropic_remeshing ON)
 add_application(tetwild_simplification ON)
 add_application(triwild ON)
 add_application(tetwild ON)

applications/cmake/wmtk_generate_test_config.cmake

@@ -1,11 +1,12 @@
 function(wmtk_generate_test_config CFG)
-    FILE(WRITE ${CMAKE_BINARY_DIR}/test_config.json "{\n")
-
-
+    set(FILE_CONTENTS "{\n")
     foreach(TEST_CONFIG ${CFG})
-        FILE(APPEND ${CMAKE_BINARY_DIR}/test_config.json "${TEST_CONFIG},\n")
+        string(APPEND FILE_CONTENTS "${TEST_CONFIG},\n")
     endforeach()
 
-    FILE(APPEND ${CMAKE_BINARY_DIR}/test_config.json "\"skip\":{}}\n")
+    string(APPEND FILE_CONTENTS "\"skip\":{}}\n")
 
+    FILE(WRITE ${CMAKE_BINARY_DIR}/test_config.json "${FILE_CONTENTS}")
 endfunction()
+
+

applications/cmake/wmtk_register_integration_test.cmake

@@ -31,6 +31,8 @@ macro(wmtk_register_integration_test )
         \"extra_flags\":\"${_EXTRA_ARGUMENTS}\"
         }")
 
+        set_property(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/.." APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${_CONFIG_PATH}")
+
     SET(WMTK_TEST_CONFIG ${WMTK_TEST_CONFIG} PARENT_SCOPE)
     SET(WMTK_APPLICATION_TEST_NAMES ${WMTK_APPLICATION_TEST_NAMES} PARENT_SCOPE)
 endmacro()

applications/convert/CMakeLists.txt

@@ -21,5 +21,5 @@ wmtk_register_integration_test(
     CONFIG_PATH ${CMAKE_CURRENT_SOURCE_DIR}/examples
     GIT_REPOSITORY "https://github.com/wildmeshing/data.git"
     GIT_TAG 363f8e860673a4e4f68df6465b99e86809c96283
-    #EXTRA_ARGUMENTS run
+    EXTRA_ARGUMENTS json
 )

applications/convert/main.cpp

@@ -5,6 +5,7 @@
 #include <filesystem>
 #include <nlohmann/json.hpp>
 #include <wmtk/applications/utils/element_count_report.hpp>
+#include <wmtk/applications/utils/get_integration_test_data_root.hpp>
 
 #include <wmtk/Mesh.hpp>
 #include <wmtk/utils/Logger.hpp>
@@ -18,8 +19,11 @@
 
 #include "CLI/CLI.hpp"
 #include "wmtk/components/multimesh/MeshCollection.hpp"
+#include "wmtk/components/multimesh/axis_aligned_fusion.hpp"
 #include "wmtk/components/multimesh/from_boundary.hpp"
 #include "wmtk/components/multimesh/from_facet_bijection.hpp"
+#include "wmtk/components/multimesh/utils/AttributeDescription.hpp"
+#include "wmtk/components/multimesh/utils/get_attribute.hpp"
 #include "wmtk/components/utils/PathResolver.hpp"
 
 using namespace wmtk::components;
@@ -74,32 +78,57 @@ std::shared_ptr<wmtk::Mesh> merge_meshes(
                 parent_named_mesh.append_child_mesh_names(parent_mesh, child_named_mesh);
 
                 return parent_mesh.shared_from_this();
+            } else if (type == "axis_aligned_periodic") {
+                std::string position_attr_path = child_datas["position_attribute"];
+                wmtk::components::multimesh::utils::AttributeDescription ad;
+                ad.path = position_attr_path;
+                auto mah = wmtk::components::multimesh::utils::get_attribute(mc, ad);
+
+                std::vector<bool> mask = child_datas["axes"];
+                std::string output_mesh_name = child_datas["fused_mesh_name"];
+                std::optional<double> eps;
+                if (child_datas.contains("epsilon")) {
+                    eps = child_datas["epsilon"].get<double>();
+                }
+                if (!eps.has_value()) {
+                    eps = 1e-10;
+                }
+                auto mptr = components::multimesh::axis_aligned_fusion(mah, mask, eps.value());
+                const auto& nmm = mc.get_named_multimesh(position_attr_path);
+
+                nlohmann::json jsout;
+                jsout[output_mesh_name] = *nmm.get_names_json();
+                mc.add_mesh(wmtk::components::multimesh::NamedMultiMesh(*mptr, jsout));
+
+                return mptr;
             }
         }
     }
     return nullptr;
 }
 } // namespace
 
-int run(const fs::path& config_path /*, const std::optional<fs::path>& name_spec_file*/)
+int run_js(
+    const std::string_view& app_name,
+    const nlohmann::json& j,
+    const std::optional<fs::path>& name_spec_file,
+    const std::optional<fs::path>& integration_test_config_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()));
-        // }
-    }
-
-    spdlog::warn("{}", j.dump(2));
-
+    // if (name_spec_file.has_value()) {
+    //     j["name"] = nlohmann::json::parse(std::ifstream(name_spec_file.value()));
+    // }
     wmtk::components::multimesh::MeshCollection meshes;
     components::utils::PathResolver path_resolver;
 
     if (j.contains("root")) {
         path_resolver = j["root"];
     }
+    if (integration_test_config_file.has_value()) {
+        auto path = wmtk::applications::utils::get_integration_test_data_root(
+            integration_test_config_file.value(),
+            app_name);
+        path_resolver.add_path(path);
+    }
 
     std::shared_ptr<wmtk::Mesh> output_mesh;
     if (j["input"].is_array()) {
@@ -120,29 +149,22 @@ int run(const fs::path& config_path /*, const std::optional<fs::path>& name_spec
 
     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);
+        std::map<std::string, wmtk::components::output::OutputOptions> output_opts = j["output"];
+        wmtk::components::output::output(meshes, output_opts);
     }
 
 
     if (j.contains("report")) {
+        nlohmann::json jnew = j;
         const std::string report = j["report"];
         meshes.make_canonical();
         if (!report.empty()) {
             nlohmann::json out_json;
             auto& stats = out_json["stats"];
-            for (const auto& [name, mesh] : meshes.all_meshes()) {
-                stats[name] = wmtk::applications::utils::element_count_report_named(mesh);
-            }
-            j.erase("report");
-            out_json["input"] = j;
+            stats = wmtk::applications::utils::element_count_report_named(meshes);
+            jnew.erase("report");
+            out_json["input"] = jnew;
 
 
             std::ofstream ofs(report);
@@ -152,6 +174,18 @@ int run(const fs::path& config_path /*, const std::optional<fs::path>& name_spec
     return 0;
 }
 
+int run(
+    const std::string_view& app_name,
+    const fs::path& config_path,
+    const std::optional<fs::path>& name_spec_file,
+    const std::optional<fs::path>& integration_test_config_file)
+{
+    nlohmann::json j;
+    std::ifstream ifs(config_path);
+    j = nlohmann::json::parse(ifs);
+
+    return run_js(app_name, j, name_spec_file, integration_test_config_file);
+}
 
 int main(int argc, char* argv[])
 {
@@ -160,21 +194,50 @@ int main(int argc, char* argv[])
     app.ignore_case();
 
     fs::path json_input_file;
+    std::optional<fs::path> json_integration_config_file;
+    std::optional<std::string> json_integration_app_name;
     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")
+    auto add_it_path = [&](CLI::App& a) {
+        a.add_option(
+             "-c, --integration-test-config",
+             json_integration_config_file,
+             "Test config file for integration test")
+            ->check(CLI::ExistingFile);
+        a.add_option(
+             "-a, --integration-test-app",
+             json_integration_config_file,
+             "Test config file for integration test")
+            ->check(CLI::ExistingFile);
+    };
+
+    CLI::App* json_cmd = app.add_subcommand("json", "Run application using a json");
+    json_cmd->add_option("-j, --json", json_input_file, "json specification file")
+        ->required(true)
+        ->check(CLI::ExistingFile);
+
+    add_it_path(*json_cmd);
+
+
+    fs::path input;
+    fs::path output;
+    std::string type;
+    CLI::App* run_cmd = app.add_subcommand("run", "Convert mesh to another type");
+    run_cmd->add_option("-i, --input", input, "input file")
         ->required(true)
         ->check(CLI::ExistingFile);
 
-    // run_cmd->add_option("-n, --name_spec", name_spec_file, "json specification file")
+    run_cmd->add_option("-o, --output", output, "output file");
+    run_cmd->add_option("-t, --type", type, "output file type, knows [vtu,hdf5]");
+    add_it_path(*run_cmd);
+
+
+    // json_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 "
@@ -184,12 +247,30 @@ int main(int argc, char* argv[])
 
     int exit_mode = -1;
 
-    // run_cmd->callback([&]() {
+    // json_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*/);
+    if (json_cmd->parsed()) {
+        exit_mode = run(argv[0], json_input_file, name_spec_file, json_integration_config_file);
+    } else {
+        wmtk::components::input::InputOptions in;
+        in.path = input;
+        wmtk::components::output::OutputOptions out;
+        out.path = output;
+        out.position_attribute = "vertices";
+        if (!type.empty() && type[0] != '.') {
+            type = '.' + type;
+        }
+        out.type = type;
+
+        nlohmann::json js;
+        js["input"] = in;
+        js["output"][""] = out;
+
+        exit_mode = run_js(argv[0], js, name_spec_file, json_integration_config_file);
+    }
 
 
     assert(exit_mode != -1); // "Some subcommand should have updated the exit mode"