From b03cd1cad644aa50c2243975806c36a503c887c9 Mon Sep 17 00:00:00 2001 From: Johannes Schatteiner Date: Fri, 21 Jul 2023 13:29:10 +0200 Subject: [PATCH 1/9] Add 2D discrete grid with dependency on clipper2 --- CMakeLists.txt | 24 +- cmd/CMakeLists.txt | 5 + cmd/discrete_field_to_bitmap/CMakeLists.txt | 2 - cmd/discrete_field_to_bitmap/main.cpp | 2 +- .../CMakeLists.txt | 45 ++ cmd/discrete_field_to_bitmap_2d/main.cpp | 219 ++++++ cmd/generate_sdf_2d/CMakeLists.txt | 42 ++ cmd/generate_sdf_2d/main.cpp | 183 +++++ discregrid/CMakeLists.txt | 21 + .../cubic_lagrange_discrete_grid2D.hpp | 71 ++ .../include/Discregrid/discrete_grid2D.hpp | 100 +++ .../Discregrid/geometry/PolygonDistance.hpp | 535 ++++++++++++++ .../include/Discregrid/mesh/triangle_mesh.hpp | 2 + .../include/Discregrid/utility}/bmp_file.hpp | 84 +-- .../src/cubic_lagrange_discrete_grid2D.cpp | 669 ++++++++++++++++++ discregrid/src/data/z_sort_table.hpp | 112 +++ discregrid/src/discrete_grid2D.cpp | 39 + discregrid/src/mesh/triangle_mesh.cpp | 69 ++ .../src/utility}/bmp_file.cpp | 295 ++++---- 19 files changed, 2323 insertions(+), 196 deletions(-) create mode 100644 cmd/discrete_field_to_bitmap_2d/CMakeLists.txt create mode 100644 cmd/discrete_field_to_bitmap_2d/main.cpp create mode 100644 cmd/generate_sdf_2d/CMakeLists.txt create mode 100644 cmd/generate_sdf_2d/main.cpp create mode 100644 discregrid/include/Discregrid/cubic_lagrange_discrete_grid2D.hpp create mode 100644 discregrid/include/Discregrid/discrete_grid2D.hpp create mode 100644 discregrid/include/Discregrid/geometry/PolygonDistance.hpp rename {cmd/discrete_field_to_bitmap => discregrid/include/Discregrid/utility}/bmp_file.hpp (96%) mode change 100755 => 100644 create mode 100644 discregrid/src/cubic_lagrange_discrete_grid2D.cpp create mode 100644 discregrid/src/discrete_grid2D.cpp rename {cmd/discrete_field_to_bitmap => discregrid/src/utility}/bmp_file.cpp (95%) mode change 100755 => 100644 diff --git a/CMakeLists.txt b/CMakeLists.txt index e008514..f576dcc 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required(VERSION 3.0) +cmake_minimum_required(VERSION 3.11) list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules") project(Discregrid) @@ -6,10 +6,26 @@ project(Discregrid) # Visual studio solution directories. set_property(GLOBAL PROPERTY USE_FOLDERS on) -# Require C++11 compiler -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_CXX_STANDARD_REQUIRED ON) +# 2D SDF generation requires Clipper2 Library by AngusJohnson +option(USE_CLIPPER2 "Use Clipper2 library to enable 2D SDF generation" OFF) + +if (USE_CLIPPER2) + # Require C++17 compiler as Clipper2 does + set(CMAKE_CXX_STANDARD 17) + include(FetchContent) + FetchContent_Declare( + clipper2 + GIT_REPOSITORY https://github.com/AngusJohnson/Clipper2.git + GIT_TAG 81b01d2acbad7b06fb28df4fbfbd7228519b7905 + SOURCE_SUBDIR CPP + ) + FetchContent_MakeAvailable(clipper2) +else() + # Require C++11 compiler + set(CMAKE_CXX_STANDARD 11) +endif() +set(CMAKE_CXX_STANDARD_REQUIRED ON) # Enable simultaneous compilation of source files. if(MSVC) diff --git a/cmd/CMakeLists.txt b/cmd/CMakeLists.txt index 1b5be71..1d78479 100755 --- a/cmd/CMakeLists.txt +++ b/cmd/CMakeLists.txt @@ -1,3 +1,8 @@ add_subdirectory(generate_sdf) add_subdirectory(discrete_field_to_bitmap) add_subdirectory(generate_density_map) + +if (USE_CLIPPER2) + add_subdirectory(generate_sdf_2d) + add_subdirectory(discrete_field_to_bitmap_2d) +endif() diff --git a/cmd/discrete_field_to_bitmap/CMakeLists.txt b/cmd/discrete_field_to_bitmap/CMakeLists.txt index a9ab1b6..ea10728 100755 --- a/cmd/discrete_field_to_bitmap/CMakeLists.txt +++ b/cmd/discrete_field_to_bitmap/CMakeLists.txt @@ -32,8 +32,6 @@ endif() add_executable(DiscreteFieldToBitmap main.cpp - bmp_file.hpp - bmp_file.cpp ) add_dependencies(DiscreteFieldToBitmap diff --git a/cmd/discrete_field_to_bitmap/main.cpp b/cmd/discrete_field_to_bitmap/main.cpp index 6ce4fe1..c6666d4 100755 --- a/cmd/discrete_field_to_bitmap/main.cpp +++ b/cmd/discrete_field_to_bitmap/main.cpp @@ -7,7 +7,7 @@ #include #include -#include "bmp_file.hpp" +#include "Discregrid/utility/bmp_file.hpp" using namespace Eigen; diff --git a/cmd/discrete_field_to_bitmap_2d/CMakeLists.txt b/cmd/discrete_field_to_bitmap_2d/CMakeLists.txt new file mode 100644 index 0000000..89d5375 --- /dev/null +++ b/cmd/discrete_field_to_bitmap_2d/CMakeLists.txt @@ -0,0 +1,45 @@ +# Eigen library. +find_package(Eigen3 REQUIRED) + +# Set include directories. +include_directories( + ../../extern + ../../discregrid/include + ${EIGEN3_INCLUDE_DIR} +) + + +if(WIN32) + add_definitions(-D_SCL_SECURE_NO_WARNINGS) + add_definitions(-D_CRT_SECURE_NO_WARNINGS) +endif(WIN32) + +if ( CMAKE_COMPILER_IS_GNUCC ) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-multichar") +endif ( CMAKE_COMPILER_IS_GNUCC ) + +# OpenMP support. +find_package(OpenMP REQUIRED) +if(OPENMP_FOUND) + if (CMAKE_VERSION VERSION_GREATER "3.8") + link_libraries(OpenMP::OpenMP_CXX) + else() + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}") + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_EXE_LINKER_FLAGS}") + endif() +endif() + +add_executable(DiscreteFieldToBitmap2D + main.cpp +) + +add_dependencies(DiscreteFieldToBitmap2D + Discregrid +) + +target_link_libraries(DiscreteFieldToBitmap2D + Discregrid +) + +set_target_properties(DiscreteFieldToBitmap2D PROPERTIES FOLDER Cmd) diff --git a/cmd/discrete_field_to_bitmap_2d/main.cpp b/cmd/discrete_field_to_bitmap_2d/main.cpp new file mode 100644 index 0000000..da97847 --- /dev/null +++ b/cmd/discrete_field_to_bitmap_2d/main.cpp @@ -0,0 +1,219 @@ + +#include +#include +#include + +#include +#include +#include + +#include "Discregrid/utility/bmp_file.hpp" +#include "Discregrid/cubic_lagrange_discrete_grid2D.hpp" +#include "Discregrid/discrete_grid2D.hpp" + +using namespace Eigen; + +namespace +{ +std::array doubleToGreenBlueInverse(double v) +{ + if (v >= 0.0) + { + return {{0u, static_cast(std::min(std::max(255.0 * (1.0 - v), 0.0), 255.0)), 0u}}; + } + return {{0u, 0u, static_cast(std::min(std::max(255.0 * (1.0 + v), 0.0), 255.0))}}; +} + +std::array doubleToRedSequential(double v) +{ + return {{static_cast(std::min(std::max(255.0 * v, 0.0), 255.0)), 0u, 0u}}; +} + +std::array doubleTo5ColourHeatmap(double v, double minValue, double maxValue) +{ + const double normalised = (v - minValue) / (maxValue - minValue); + + constexpr double h1 = 0; + constexpr double h2 = 0.66667; + const double h = (1.0 - normalised) * h1 + normalised * h2; + constexpr double s = 1.0; + constexpr double l = 0.5; + + auto hue2rgb = [](double p, double q, double t){ + if(t < 0) t += 1; + if(t > 1) t -= 1; + if(t < 1/6.0) return p + (q - p) * 6 * t; + if(t < 1/2.0) return q; + if(t < 2/3.0) return p + (q - p) * (2/3.0 - t) * 6; + return p; + }; + + constexpr double q = l < 0.5 ? l * (1 + s) : l + s - l * s; + constexpr double p = 2 * l - q; + + return { + static_cast(hue2rgb(p, q, h + 1 / 3.0) * 255), + static_cast(hue2rgb(p, q, h) * 255), + static_cast(hue2rgb(p, q, h - 1 / 3.0) * 255) + }; +} + +} + +int main(int argc, char* argv[]) +{ + cxxopts::Options options(argv[0], "Transforms a slice of a discrete 2D-SDF to a bitmap image."); + options.positional_help("[input 2D-SDF file (.cdf2d)]"); + + options.add_options() + ("h,help", "Prints this help text") + ("f,field_id", "ID in which the SDF to export is stored.", cxxopts::value()->default_value("0")) + ("s,samples", "Number of samples in width direction", cxxopts::value()->default_value("1024")) + ("d,depth", "Relative depth value between -1 and 1 in direction of the axis orthogonal to the plane", cxxopts::value()->default_value("0")) + ("o,output", "Output (in bmp format)", cxxopts::value()->default_value("")) + ("c,colormap", "Color map options: redsequential (rs), green blue inverse diverging (gb) (suitable for visualisation of signed distance fields), 5 colour heatmap (hm) (suitable for visualisation of differences/errors)", cxxopts::value()->default_value("gb")) + ("input", "SDF file", cxxopts::value>()) + ; + + try + { + options.parse_positional("input"); + auto result = options.parse(argc, argv); + + if (result.count("help")) + { + std::cout << options.help() << std::endl; + std::cout << std::endl << std::endl << "Example: SDFToBitmap2D -p xz file.sdf2d" << std::endl; + exit(0); + } + if (!result.count("input")) + { + std::cout << "ERROR: No input file given." << std::endl; + std::cout << options.help() << std::endl; + std::cout << std::endl << std::endl << "Example: SDFToBitmap2D -p xz file.sdf2d" << std::endl; + exit(1); + } + + auto sdf = std::unique_ptr{}; + + auto filename = result["input"].as>().front(); + auto lastindex = filename.find_last_of("."); + auto extension = filename.substr(lastindex + 1, filename.length() - lastindex); + + std::cout << "Load SDF..."; + if (extension == "cdf2d") + { + sdf = std::make_unique(filename); + } + else + { + std::cout << "ERROR: Input file must be a '.sdf2d' file specifically." << std::endl; + std::cout << options.help() << std::endl; + std::cout << std::endl << std::endl << "Example: SDFToBitmap2D -p xz file.sdf2D" << std::endl; + exit(1); + } + std::cout << "DONE" << std::endl; + + auto const& domain = sdf->domain(); + auto diag = domain.diagonal().eval(); + + auto dir = Vector2i::Zero().eval(); + dir(1) = 1; + + auto xsamples = result["s"].as(); + auto ysamples = static_cast(std::round(diag(dir(1)) / diag(dir(0)) * static_cast(xsamples))); + + auto xwidth = diag(dir(0)) / xsamples; + auto ywidth = diag(dir(1)) / ysamples; + + auto data = std::vector{}; + data.resize(xsamples * ysamples); + + auto field_id = result["f"].as(); + + std::cout << "Sample field..."; +#pragma omp parallel for + for (int k = 0; k < static_cast(xsamples * ysamples); ++k) + { + auto i = k % xsamples; + auto j = k / xsamples; + + auto xr = static_cast(i) / static_cast(xsamples); + auto yr = static_cast(j) / static_cast(ysamples); + + auto x = domain.min()(dir(0)) + xr * diag(dir(0)) + 0.5 * xwidth; + auto y = domain.min()(dir(1)) + yr * diag(dir(1)) + 0.5 * ywidth; + + auto sample = Vector2d{}; + sample(dir(0)) = x; + sample(dir(1)) = y; + + data[k] = sdf->interpolate(field_id, sample); + if (data[k] == std::numeric_limits::max()) + { + data[k] = 0.0; + } + } + + std::cout << "DONE" << std::endl; + + auto min_v = *std::min_element(data.begin(), data.end()); + auto max_v = *std::max_element(data.begin(), data.end()); + + auto out_file = result["o"].as(); + if (out_file == "") + { + out_file = filename; + if (out_file.find(".") != std::string::npos) + { + auto lastindex = out_file.find_last_of("."); + out_file = out_file.substr(0, lastindex); + } + out_file += ".bmp"; + } + + std::cout << "Ouput file: " << out_file << std::endl; + + std::cout << "Export BMP..."; + std::transform(data.begin(), data.end(), data.begin(), [&max_v, &min_v](double v) {return v >= 0.0 ? v / std::abs(max_v) : v / std::abs(min_v); }); + + auto pixels = std::vector>(data.size()); + + auto cm = result["c"].as(); + if (cm != "gb" && cm != "rs" && cm != "hm") + { + std::cerr << "WARNING: Unknown color map option. Fallback to mode 'gb'." << std::endl; + } + + if (cm == "gb") + std::transform(data.begin(), data.end(), pixels.begin(), doubleToGreenBlueInverse); + else if (cm == "rs") + std::transform(data.begin(), data.end(), pixels.begin(), doubleToRedSequential); + else if (cm == "hm") + { + const auto min_max = std::minmax_element( + data.begin(), data.end()); + const auto min = *min_max.first; + const auto max = *min_max.second; + const auto& heatmap = [min, max](double v) { return doubleTo5ColourHeatmap(v, min, max); }; + std::transform(data.begin(), data.end(), pixels.begin(), heatmap); + } + + + BmpReaderWriter::saveFile(out_file.c_str(), xsamples, ysamples, &pixels.front()[0]); + std::cout << "DONE" << std::endl; + + std::cout << std::endl << "Statistics:" << std::endl; + std::cout << "\tdomain = " << domain.min().transpose() << ", " << domain.max().transpose() << std::endl; + std::cout << "\tmin value = " << min_v << std::endl; + std::cout << "\tmax value = " << max_v << std::endl; + std::cout << "\tbmp resolution = " << xsamples << " x " << ysamples << std::endl; + } + catch (cxxopts::OptionException const& e) + { + std::cout << "error parsing options: " << e.what() << std::endl; + exit(1); + } + + return 0; +} \ No newline at end of file diff --git a/cmd/generate_sdf_2d/CMakeLists.txt b/cmd/generate_sdf_2d/CMakeLists.txt new file mode 100644 index 0000000..8cae0ff --- /dev/null +++ b/cmd/generate_sdf_2d/CMakeLists.txt @@ -0,0 +1,42 @@ +# Eigen library. +find_package(Eigen3 REQUIRED) + +# Set include directories. +include_directories( + ../../extern + ../../discregrid/include + ${EIGEN3_INCLUDE_DIR} +) + +if(WIN32) + add_definitions(-D_SCL_SECURE_NO_WARNINGS) + add_definitions(-D_USE_MATH_DEFINES) +endif(WIN32) + +# OpenMP support. +find_package(OpenMP REQUIRED) +if(OPENMP_FOUND) + if (CMAKE_VERSION VERSION_GREATER "3.8") + link_libraries(OpenMP::OpenMP_CXX) + else() + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}") + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_EXE_LINKER_FLAGS}") + endif() +endif() + +add_executable(GenerateSDF2D + main.cpp +) + +add_dependencies(GenerateSDF2D + Discregrid +) + +target_link_libraries(GenerateSDF2D + Discregrid + Clipper2 + Clipper2utils +) + +set_target_properties(GenerateSDF2D PROPERTIES FOLDER Cmd) diff --git a/cmd/generate_sdf_2d/main.cpp b/cmd/generate_sdf_2d/main.cpp new file mode 100644 index 0000000..314b917 --- /dev/null +++ b/cmd/generate_sdf_2d/main.cpp @@ -0,0 +1,183 @@ +#include +#include + +#include +#include +#include +#include + +#include +#include "clipper.svg.h" +#include "clipper2/clipper.export.h" +#include "Discregrid/cubic_lagrange_discrete_grid2D.hpp" +#include "Discregrid/geometry/PolygonDistance.hpp" + +using namespace Eigen; + +std::istream& operator>>(std::istream& is, std::array& data) +{ + is >> data[0] >> data[1]; + return is; +} + +std::istream& operator>>(std::istream& is, AlignedBox2d& data) +{ + is >> data.min()[0] >> data.min()[1] + >> data.max()[0] >> data.max()[1]; + return is; +} + +#include + +int main(int argc, char* argv[]) +{ + cxxopts::Options options(argv[0], "Generates a 2D signed distance field from a triangle mesh."); + options.positional_help("[input OBJ file]"); + + options.add_options() + ("h,help", "Prints this help text") + ("r,resolution", "Grid resolution", cxxopts::value>()->default_value("10 10")) + ("d,domain", "Domain extents (bounding box), format: \"minX minY maxX maxY\"", cxxopts::value()) + ("i,invert", "Invert SDF") + ("o,output", "Output file in cdf format", cxxopts::value()->default_value("")) + ("input", "OBJ file containing input triangle mesh", cxxopts::value>()) + ; + + try + { + options.parse_positional("input"); + auto result = options.parse(argc, argv); + + if (result.count("help")) + { + std::cout << options.help() << std::endl; + std::cout << std::endl << std::endl << "Example: GenerateSDF2D -r \"50 50\" dragon.obj" << std::endl; + exit(0); + } + if (!result.count("input")) + { + std::cout << "ERROR: No input mesh given." << std::endl; + std::cout << options.help() << std::endl; + std::cout << std::endl << std::endl << "Example: GenerateSDF2D -r \"50 50\" dragon.obj" << std::endl; + exit(1); + } + auto resolution = result["r"].as>(); + auto filename = result["input"].as>().front(); + + if (!std::ifstream(filename).good()) + { + std::cerr << "ERROR: Input file does not exist!" << std::endl; + exit(1); + } + + std::cout << "Load mesh..."; + Discregrid::TriangleMesh mesh(filename); + std::cout << "DONE" << std::endl; + + std::cout << "Weld vertices and perform backface culling..." << std::endl; + std::vector culled_vertices; + std::vector culled_triangles; + mesh.weldVerticesAndCullBackfaces2D(culled_vertices, culled_triangles); + std::cout << "N Vertices: " << culled_vertices.size() << "; N Triangles: " << culled_triangles.size() / 3 << std::endl; + std::cout << "DONE" << std::endl; + + std::cout << "Create polygon from the union of all culled triangles..." << std::endl; + Clipper2Lib::PathsD polygon(culled_triangles.size() / 3); + for (int i = 0; i < culled_triangles.size(); i += 3) + { + const auto v0 = culled_vertices[culled_triangles[i]]; + const auto v1 = culled_vertices[culled_triangles[i + 1]]; + const auto v2 = culled_vertices[culled_triangles[i + 2]]; + polygon.emplace_back(Clipper2Lib::MakePathD({v0.x(), v0.y(), v1.x(), v1.y(), v2.x(), v2.y()})); + } + polygon = Clipper2Lib::Union(polygon, Clipper2Lib::FillRule::NonZero, 8); + std::cout << "DONE" << std::endl; + + std::cout << "Set up polygon distance function..." << std::endl; + Discregrid::PolygonDistance pd(polygon); + std::cout << "DONE" << std::endl; + + Eigen::Vector2d sample(0.0, 0.0); + std::cout << "TEST TEST PLS REMOVE ME: Sampling at (" << sample.x() << "|" << sample.y() << ")..." << std::endl; + const Discregrid::Result2D signed_distance = pd.signed_distance(sample); + std::cout << "Closest point on polygon from sample: (" << signed_distance.nearest_point.x() << "|" << signed_distance.nearest_point.y() << ")" << std::endl; + + std::filesystem::path filePath(filename); + std::string svg_name = filePath.filename().stem().string().append(".svg"); + std::cout << "Writing polygon as SVG to " << svg_name << "..." << std::endl; + Clipper2Lib::SvgWriter svg; + svg.AddPaths(polygon, false, Clipper2Lib::FillRule::NonZero, 0x4080ff9C, 0xFF003300, 1.5, false); + Clipper2Lib::PathD signed_distance_path = Clipper2Lib::MakePathD({signed_distance.nearest_point.x(), signed_distance.nearest_point.y(), sample.x(), sample.y()}); + svg.AddPath(signed_distance_path, true, Clipper2Lib::FillRule::NonZero, 0xFFFF00FF, 0xFFFF00FF, 3, false); + std::cout << "TEST TEST PLS REMOVE ME: Sampling from -0.5 to +0.5 in both dimensoins and save to svg..." << std::endl; + for (double xSample = -0.5; xSample <= 0.5; xSample += 0.1) + { + for (double ySample = -0.5; ySample <= 0.5; ySample += 0.1) + { + const Discregrid::Result2D signed_distance_sample = pd.signed_distance(Vector2d{xSample, ySample}); + svg.AddPath(Clipper2Lib::MakePathD({signed_distance_sample.nearest_point.x(), signed_distance_sample.nearest_point.y(), xSample, ySample}), true, Clipper2Lib::FillRule::NonZero, 0xFFFF00FF, 0xFFFF00FF, 3, false); + } + } + svg.SaveToFile(svg_name, 1000, 1000, 10); + std::cout << "DONE" << std::endl; + + Eigen::AlignedBox2d domain; + domain.setEmpty(); + if (result.count("d")) + { + domain = result["d"].as(); + } + if (domain.isEmpty()) + { + for (size_t i = 0; i < polygon.size(); i++) + { + + const auto &outline = polygon[i]; + for (auto const& x : outline) + { + domain.extend(Matrix{x.x, x.y}); + } + } + + domain.max() += 1.0e-3 * domain.diagonal().norm() * Vector2d::Ones(); + domain.min() -= 1.0e-3 * domain.diagonal().norm() * Vector2d::Ones(); + } + + Discregrid::CubicLagrangeDiscreteGrid2D sdf(domain, resolution); + auto func = Discregrid::DiscreteGrid2D::ContinuousFunction{}; + if (result.count("invert")) + { + func = [&pd](Vector2d const& xi) { return -1.0 * pd.signed_distance(xi).distance; }; + } + else + { + func = [&pd](Vector2d const& xi) { return pd.signed_distance(xi).distance; }; + } + + std::cout << "Generate discretization..." << std::endl; + sdf.addFunction(func, true); + std::cout << "DONE" << std::endl; + + std::cout << "Serialize discretization..."; + auto output_file = result["o"].as(); + if (output_file == "") + { + output_file = filename; + if (output_file.find(".") != std::string::npos) + { + auto lastindex = output_file.find_last_of("."); + output_file = output_file.substr(0, lastindex); + } + output_file += ".cdf2d"; + } + sdf.save(output_file); + std::cout << "DONE" << std::endl; + } + catch (cxxopts::OptionException const& e) + { + std::cout << "error parsing options: " << e.what() << std::endl; + exit(1); + } + + return 0; +} \ No newline at end of file diff --git a/discregrid/CMakeLists.txt b/discregrid/CMakeLists.txt index 29f7476..3c6e707 100755 --- a/discregrid/CMakeLists.txt +++ b/discregrid/CMakeLists.txt @@ -18,6 +18,7 @@ set(HEADERS_GEOMETRY set(HEADERS_UTILITY include/Discregrid/utility/serialize.hpp include/Discregrid/utility/lru_cache.hpp + include/Discregrid/utility/bmp_file.hpp src/utility/timing.hpp src/utility/spinlock.hpp @@ -36,8 +37,27 @@ set(SOURCES_MESH set(SOURCES_UTILITY src/utility/timing.cpp + src/utility/bmp_file.cpp ) +if (USE_CLIPPER2) + + list(APPEND HEADERS + include/Discregrid/discrete_grid2D.hpp + include/Discregrid/cubic_lagrange_discrete_grid2D.hpp + ) + + list(APPEND HEADERS_GEOMETRY + include/Discregrid/geometry/PolygonDistance.hpp + ) + + list(APPEND SOURCES + src/discrete_grid2D.cpp + src/cubic_lagrange_discrete_grid2D.cpp + ) + +endif() + macro(SOURCEGROUP name) string(TOLOWER ${name} name_lower) string(SUBSTRING ${name_lower} 0 1 FIRST_LETTER) @@ -104,6 +124,7 @@ endif() # Set link libraries. target_link_libraries(Discregrid + $,Clipper2,> ) install(TARGETS Discregrid diff --git a/discregrid/include/Discregrid/cubic_lagrange_discrete_grid2D.hpp b/discregrid/include/Discregrid/cubic_lagrange_discrete_grid2D.hpp new file mode 100644 index 0000000..f7f17b5 --- /dev/null +++ b/discregrid/include/Discregrid/cubic_lagrange_discrete_grid2D.hpp @@ -0,0 +1,71 @@ +#pragma once + +#include "discrete_grid2D.hpp" + +namespace Discregrid +{ + +class CubicLagrangeDiscreteGrid2D : public DiscreteGrid2D +{ +public: + + CubicLagrangeDiscreteGrid2D(std::string const& filename); + CubicLagrangeDiscreteGrid2D(Eigen::AlignedBox2d const& domain, + std::array const& resolution); + + void save(std::string const& filename) const override; + void load(std::string const& filename) override; + + unsigned int addFunction(ContinuousFunction const& func, bool verbose = false, + SamplePredicate const& pred = nullptr) override; + + + std::size_t nCells() const { return m_n_cells; }; + double interpolate(unsigned int field_id, Eigen::Vector2d const& xi, + Eigen::Vector2d* gradient = nullptr) const override; + + /** + * @brief Determines the shape functions for the discretization with ID field_id at point xi. + * + * @param field_id Discretization ID + * @param x Location where the shape functions should be determined + * @param cell cell of x + * @param c0 vector required for the interpolation + * @param N shape functions for the cell of x + * @param dN (Optional) derivatives of the shape functions, required to compute the gradient + * @return Success of the function. + */ + bool determineShapeFunctions(unsigned int field_id, Eigen::Vector2d const &x, + std::array &cell, Eigen::Vector2d &c0, Eigen::Matrix &N, + Eigen::Matrix *dN = nullptr) const override; + + /** + * @brief Evaluates the given discretization with ID field_id at point xi. + * + * @param field_id Discretization ID + * @param xi Location where the discrete function is evaluated + * @param cell cell of xi + * @param c0 vector required for the interpolation + * @param N shape functions for the cell of xi + * @param gradient (Optional) if a pointer to a vector is passed the gradient of the discrete function will be evaluated + * @param dN (Optional) derivatives of the shape functions, required to compute the gradient + * @return double Results of the evaluation of the discrete function at point xi + */ + double interpolate(unsigned int field_id, Eigen::Vector2d const& xi, const std::array &cell, const Eigen::Vector2d &c0, const Eigen::Matrix &N, + Eigen::Vector2d* gradient = nullptr, Eigen::Matrix *dN = nullptr) const override; + + void reduceField(unsigned int field_id, Predicate pred) override; + + void forEachCell(unsigned int field_id, + std::function const& cb) const; + +private: + + Eigen::Vector2d indexToNodePosition(unsigned int l) const; + + std::vector> m_nodes; + std::vector>> m_cells; + std::vector> m_cell_map; +}; + +} \ No newline at end of file diff --git a/discregrid/include/Discregrid/discrete_grid2D.hpp b/discregrid/include/Discregrid/discrete_grid2D.hpp new file mode 100644 index 0000000..41ab9ac --- /dev/null +++ b/discregrid/include/Discregrid/discrete_grid2D.hpp @@ -0,0 +1,100 @@ +#pragma once + +#include +#include +#include +#include + +namespace Discregrid +{ + +class DiscreteGrid2D +{ +public: + + using CoefficientVector = Eigen::Matrix; + using ContinuousFunction = std::function; + using MultiIndex = std::array; + using Predicate = std::function; + using SamplePredicate = std::function; + + DiscreteGrid2D() = default; + DiscreteGrid2D(Eigen::AlignedBox2d const& domain, std::array const& resolution) + : m_domain(domain), m_resolution(resolution), m_n_fields(0u) + { + auto n = Eigen::Matrix::Map(resolution.data()); + m_cell_size = domain.diagonal().cwiseQuotient(n.cast()); + m_inv_cell_size = m_cell_size.cwiseInverse(); + m_n_cells = n.prod(); + } + virtual ~DiscreteGrid2D() = default; + + virtual void save(std::string const& filename) const = 0; + virtual void load(std::string const& filename) = 0; + + virtual unsigned int addFunction(ContinuousFunction const& func, bool verbose = false, + SamplePredicate const& pred = nullptr) = 0; + + double interpolate(Eigen::Vector2d const& xi, Eigen::Vector2d* gradient = nullptr) const + { + return interpolate(0u, xi, gradient); + } + + virtual double interpolate(unsigned int field_id, Eigen::Vector2d const& xi, + Eigen::Vector2d* gradient = nullptr) const = 0; + + /** + * @brief Determines the shape functions for the discretization with ID field_id at point xi. + * + * @param field_id Discretization ID + * @param x Location where the shape functions should be determined + * @param cell cell of x + * @param c0 vector required for the interpolation + * @param N shape functions for the cell of x + * @param dN (Optional) derivatives of the shape functions, required to compute the gradient + * @return Success of the function. + */ + virtual bool determineShapeFunctions(unsigned int field_id, Eigen::Vector2d const &x, + std::array &cell, Eigen::Vector2d &c0, Eigen::Matrix &N, + Eigen::Matrix *dN = nullptr) const = 0; + + /** + * @brief Evaluates the given discretization with ID field_id at point xi. + * + * @param field_id Discretization ID + * @param xi Location where the discrete function is evaluated + * @param cell cell of xi + * @param c0 vector required for the interpolation + * @param N shape functions for the cell of xi + * @param gradient (Optional) if a pointer to a vector is passed the gradient of the discrete function will be evaluated + * @param dN (Optional) derivatives of the shape functions, required to compute the gradient + * @return double Results of the evaluation of the discrete function at point xi + */ + virtual double interpolate(unsigned int field_id, Eigen::Vector2d const& xi, const std::array &cell, const Eigen::Vector2d &c0, const Eigen::Matrix &N, + Eigen::Vector2d* gradient = nullptr, Eigen::Matrix *dN = nullptr) const = 0; + + virtual void reduceField(unsigned int field_id, Predicate pred) {} + + + MultiIndex singleToMultiIndex(unsigned int i) const; + unsigned int multiToSingleIndex(MultiIndex const& ij) const; + + Eigen::AlignedBox2d subdomain(MultiIndex const& ij) const; + Eigen::AlignedBox2d subdomain(unsigned int l) const; + + Eigen::AlignedBox2d const& domain() const { return m_domain; } + std::array const& resolution() const { return m_resolution; } + Eigen::Vector2d const& cellSize() const { return m_cell_size;} + Eigen::Vector2d const& invCellSize() const { return m_inv_cell_size;} + +protected: + + + Eigen::AlignedBox2d m_domain; + std::array m_resolution; + Eigen::Vector2d m_cell_size; + Eigen::Vector2d m_inv_cell_size; + std::size_t m_n_cells; + std::size_t m_n_fields; +}; +} \ No newline at end of file diff --git a/discregrid/include/Discregrid/geometry/PolygonDistance.hpp b/discregrid/include/Discregrid/geometry/PolygonDistance.hpp new file mode 100644 index 0000000..930109c --- /dev/null +++ b/discregrid/include/Discregrid/geometry/PolygonDistance.hpp @@ -0,0 +1,535 @@ +#pragma once +#include +#include +#include +#include +#include +#include "TriangleMeshDistance.h" +#include "clipper2/clipper.core.h" + +// This file is a derivative of TriangleMeshDistance.h providing the same functionality in 2D. +// This file can be used to get the distance of a point to a closed polygon (that can contain holes). +namespace Discregrid +{ + // Point-Edge distance definitions + enum class NearestEntity2D { V0, V1, E }; + static double point_edge_sq_unsigned( + NearestEntity2D& nearest_entity, + Eigen::Vector2d& nearest_point, + const Eigen::Vector2d& point, + const Eigen::Vector2d& v0, + const Eigen::Vector2d& v1); + // ----------------------------------- + + // Struct that contains the result of a 2D distance query + struct Result2D + { + double distance = std::numeric_limits::max(); + Eigen::Vector2d nearest_point; + NearestEntity2D nearest_entity; + int edge_id = -1; + }; + // ----------------------------------- + + // A class to compute signed and unsigned distances to a triangle mesh. + class PolygonDistance + { + private: + /* Definitions */ + struct BoundingSphere + { + Eigen::Vector2d center; + double radius; + }; + + struct Node + { + BoundingSphere bv_left; + BoundingSphere bv_right; + int left = -1; // If left == -1, right is the edge_id + int right = -1; + }; + + struct Edge + { + std::array vertices; + int id = -1; + }; + + /* Fields */ + std::vector vertices; + std::vector edges; + std::vector nodes; + std::vector pseudonormals_edges; + std::vector pseudonormals_vertices; + BoundingSphere root_bv; + bool is_constructed = false; + + /* Methods */ + void _construct(); + void _build_tree(const int node_id, BoundingSphere& bounding_sphere, std::vector &edges, const int begin, const int end); + void _query(Result2D &result, const Node &node, const Eigen::Vector2d& point) const; + + public: + /* Methods */ + PolygonDistance() = default; + + /** + * @brief Constructs a new PolygonDistance object. + * + * @param vertices Pointer to the vertices coordinates array in xyxy... layout. + * @param n_vertices Number of vertices. + * @param edges Pointer to the connectivity array in ijij... layout. + * @param n_edges Number of edges. + */ + template + PolygonDistance(const FLOAT* vertices, const SIZE_T n_vertices, const INT* edges, const SIZE_T n_edges); + + /** + * @brief Constructs a new PolygonDistance object. + * + * @param vertices Vertices of the polygon. Y coordinate of the 3rd vertex should be accessed by `vertices[2][1]`. + * @param edges Edges of the polygon. Index of the 2nd vertex of the 3rd edge should be accessed by `edges[2][1]`. + */ + template + PolygonDistance(const std::vector& vertices, const std::vector& edges); + + /** + * @brief Constructs a new PolygonDistance object. + * + * @param polygon Clipper2 PathsD (= Polygon) object. + */ + PolygonDistance(const Clipper2Lib::PathsD &polygon); + + /** + * @brief Initializes an existing PolygonDistance object (including empty ones). + * + * @param vertices Pointer to the vertices coordinates array in xyxy... layout. + * @param n_vertices Number of vertices. + * @param edges Pointer to the conectivity array in ijij... layout. + * @param n_edges Number of edges. + */ + template + void construct(const FLOAT* vertices, const SIZE_T n_vertices, const INT* edges, const SIZE_T n_edges); + + /** + * @brief Initializes an existing PolygonDistance object (including empty ones). + * + * @param vertices Vertices of the polygon. Y coordinate of the 3rd vertex should be access by `vertices[2][1]`. + * @param edges Edges of the polygon. Index of the 2nd vertex of the 3rd edge should be access by `edges[2][1]`. + */ + template + void construct(const std::vector& vertices, const std::vector& edges); + + /** + * @brief Computes the unsigned distance from a point to the polygon. Thread safe. + * + * @param point to query from. Typed to `Vector2d` but can be passed as `{x, y}`. + * + * @return Result containing distance, nearest point on the polygon, nearest entity and the nearest edge index. + */ + template + Result2D unsigned_distance(const IndexableVector2double& point) const; + Result2D unsigned_distance(const std::array& point) const; + + /** + * @brief Computes the unsigned distance from a point to the polygon. Thread safe. + * + * @param point to query from. Typed to `Vector2d` but can be passed as `{x, y}`. + * + * @return Result containing distance, nearest point on the polygon, nearest entity and the nearest edge index. + */ + template + Result2D signed_distance(const IndexableVector2double& point) const; + Result2D signed_distance(const std::array& point) const; + }; +} + +/* ========================================== DECLARATIONS ========================================== */ +template +inline Discregrid::PolygonDistance::PolygonDistance(const FLOAT* vertices, const SIZE_T n_vertices, const INT* edges, const SIZE_T n_edges) +{ + this->construct(vertices, n_vertices, edges, n_edges); +} + +template +inline Discregrid::PolygonDistance::PolygonDistance(const std::vector& vertices, const std::vector& edges) +{ + this->construct(vertices, edges); +} + +inline Discregrid::PolygonDistance::PolygonDistance(const Clipper2Lib::PathsD &polygon) +{ + size_t size = 0; + for (size_t i = 0; i < polygon.size(); i++) + { + size += polygon[i].size(); + } + std::vector polygonVertices; + polygonVertices.reserve(size); + std::vector polygonEdges; + polygonEdges.reserve(size); + size_t counter = 0; + for (size_t i = 0; i < polygon.size(); i++) + { + auto path = polygon[i]; + size_t subCounter = counter; + for (size_t j = 0; j < path.size() - 1; j++) + { + auto point = path[j]; + polygonVertices.emplace_back(point.x, point.y); + polygonEdges.emplace_back(counter++, counter); + } + auto point = path.back(); + polygonVertices.emplace_back(point.x, point.y); + polygonEdges.emplace_back(counter++, subCounter); + } + this->construct(polygonVertices, polygonEdges); +} + +template +inline void Discregrid::PolygonDistance::construct(const FLOAT* vertices, const SIZE_T n_vertices, const INT* edges, const SIZE_T n_edges) +{ + this->vertices.resize(2 * n_vertices); + for (size_t i = 0; i < static_cast(n_vertices); i++) + { + this->vertices[i][0] = static_cast(vertices[2 * i]); + this->vertices[i][1] = static_cast(vertices[2 * i + 1]); + } + + this->edges.resize(2 * n_edges); + for (size_t i = 0; i < static_cast(n_edges); i++) + { + this->edges[i][0] = static_cast(edges[2 * i]); + this->edges[i][1] = static_cast(edges[2 * i + 1]); + } + this->_construct(); +} + +template +inline void Discregrid::PolygonDistance::construct(const std::vector& vertices, const std::vector& edges) +{ + this->vertices.resize(vertices.size()); + for (size_t i = 0; i < vertices.size(); i++) + { + this->vertices[i][0] = static_cast(vertices[i][0]); + this->vertices[i][1] = static_cast(vertices[i][1]); + } + + this->edges.resize(edges.size()); + for (size_t i = 0; i < edges.size(); i++) + { + this->edges[i][0] = static_cast(edges[i][0]); + this->edges[i][1] = static_cast(edges[i][1]); + } + this->_construct(); +} + +template +inline Discregrid::Result2D Discregrid::PolygonDistance::unsigned_distance(const IndexableVector2double& point) const +{ + return this->unsigned_distance({static_cast(point[0]), static_cast(point[1])}); +} + +inline Discregrid::Result2D Discregrid::PolygonDistance::unsigned_distance(const std::array& point) const +{ + if (!this->is_constructed) + { + std::cout << "PolygonDistance error: not constructed." << std::endl; + exit(-1); + } + + const Eigen::Vector2d p(point[0], point[1]); + Result2D result; + result.distance = std::numeric_limits::max(); + this->_query(result, this->nodes[0], p); + return result; +} + +template +inline Discregrid::Result2D Discregrid::PolygonDistance::signed_distance(const IndexableVector2double& point) const +{ + const Eigen::Vector2d p(point[0], point[1]); + Result2D result = this->unsigned_distance(p); + + const Eigen::Vector2i& edge = this->edges[result.edge_id]; + Eigen::Vector2d pseudonormal; + switch (result.nearest_entity) + { + case NearestEntity2D::V0: + pseudonormal = this->pseudonormals_vertices[edge[0]]; + break; + case NearestEntity2D::V1: + pseudonormal = this->pseudonormals_vertices[edge[1]]; + break; + case NearestEntity2D::E: + pseudonormal = this->pseudonormals_edges[result.edge_id]; + break; + default: + break; + } + + const Eigen::Vector2d u = p - result.nearest_point; + result.distance *= u.dot(pseudonormal) >= 0.0 ? 1.0 : -1.0; + + return result; +} + +inline Discregrid::Result2D Discregrid::PolygonDistance::signed_distance(const std::array& point) const +{ + return this->signed_distance({static_cast(point[0]), static_cast(point[1])}); +} + +inline void Discregrid::PolygonDistance::_construct() +{ + if (this->edges.empty()) + { + std::cout << "PolygonDistance error: Empty edge list." << std::endl; + exit(-1); + } + + // Build the tree containing the edges + std::vector edges; + + edges.resize(this->edges.size()); + for (int i = 0; i < static_cast(this->edges.size()); i++) + { + edges[i].id = i; + + const Eigen::Vector2i& edge = this->edges[i]; + edges[i].vertices[0] = this->vertices[edge[0]]; + edges[i].vertices[1] = this->vertices[edge[1]]; + } + + this->nodes.emplace_back(); + this->_build_tree(0, this->root_bv, edges, 0, static_cast(edges.size())); + + // Compute + this->pseudonormals_edges.reserve(this->edges.size()); + this->pseudonormals_vertices.resize(this->vertices.size(), { 0, 0 }); + + std::unordered_map> vertexIndexToEdgeNormalIndices; + + // (Pseudo-)Normals edges + for (int i = 0; i < static_cast(this->edges.size()); i++) { + + // Edge + const Eigen::Vector2i edge = this->edges[i]; + const int i0 = edge[0]; + const int i1 = edge[1]; + const Eigen::Vector2d a = this->vertices[i0]; + const Eigen::Vector2d b = this->vertices[i1]; + + // Edge normal calculation routine from Clipper2 library + if (a == b) + { + std::cout << "PolygonDistance::_construct error: Can not calculate edge normal because both vertices are the same!" << std::endl; + exit(-1); + } + auto dx = b.x() - a.x(); + auto dy = b.y() - a.y(); + const auto inverse_hypot = 1.0 / std::sqrt(dx * dx + dy * dy); + dx *= inverse_hypot; + dy *= inverse_hypot; + const Eigen::Vector2d normal(dy, -dx); + + for (const int index : edge) + { + auto edgeNormalIndex = static_cast(this->pseudonormals_edges.size()); + + if (vertexIndexToEdgeNormalIndices.find(index) == vertexIndexToEdgeNormalIndices.end()) + { + vertexIndexToEdgeNormalIndices[index] = std::vector(); + } + + vertexIndexToEdgeNormalIndices[index].push_back(edgeNormalIndex); + } + + this->pseudonormals_edges.push_back(normal); + } + + // Pseudonormals vertices + for (const auto& pair : vertexIndexToEdgeNormalIndices) + { + int vertexIndex = pair.first; + std::vector edgeNormalIndices = pair.second; + if (edgeNormalIndices.size() != 2) + { + std::cout << "PolygonDistance error: Polygon is not valid. At least one vertex does not have exactly two incident edges." << std::endl; + exit(-1); + } + Eigen::Vector2i edge1 = this->edges[edgeNormalIndices[0]]; + Eigen::Vector2i edge2 = this->edges[edgeNormalIndices[1]]; + Eigen::Vector2d a = this->vertices[vertexIndex]; + Eigen::Vector2d b = this->vertices[edge1[0] == edge2[0] || edge1[0] == edge2[1] ? edge1[1] : edge1[0]]; + Eigen::Vector2d c = this->vertices[vertexIndex == edge2[0] ? edge2[1] : edge2[0]]; + double alpha0 = std::acos(std::abs((b - a).normalized().dot((c - a).normalized()))); + this->pseudonormals_vertices[vertexIndex] = (alpha0 * (this->pseudonormals_edges[edgeNormalIndices[0]] + this->pseudonormals_edges[edgeNormalIndices[1]])).normalized(); + } + + this->is_constructed = true; +} + +inline void Discregrid::PolygonDistance::_build_tree(const int node_id, BoundingSphere& bounding_sphere, std::vector &edges, const int begin, const int end) +{ + const int n_edges = end - begin; + + if (n_edges <= 0) + { + std::cout << "PolygonDistance::_construct error: Empty leaf." << std::endl; + exit(-1); + } + + if (n_edges == 1) + { + // Build node leaf + this->nodes[node_id].left = -1; + this->nodes[node_id].right = edges[begin].id; + + // Bounding sphere + const Edge& edge = edges[begin]; + const Eigen::Vector2d helper = edge.vertices[0] + edge.vertices[1]; + const Eigen::Vector2d center(helper.x() / 2.0, helper.y() / 2.0); + const double radius = std::max((edge.vertices[0] - center).norm(), (edge.vertices[1] - center).norm()); + bounding_sphere.center = center; + bounding_sphere.radius = radius; + } + else + { + // Compute AABB center and largest dimension of all current edges. (AABB center is the average of all edge vertex positions) + Eigen::Vector2d top = {std::numeric_limits::lowest(), std::numeric_limits::lowest()}; + Eigen::Vector2d bottom = {std::numeric_limits::max(), std::numeric_limits::max()}; + Eigen::Vector2d center = {0, 0}; + for (int edge_i = begin; edge_i < end; edge_i++) + { + for (int vertex_i = 0; vertex_i < 2; vertex_i++) + { + const Eigen::Vector2d& p = edges[edge_i].vertices[vertex_i]; + center += p; + + for (int coord_i = 0; coord_i < 2; coord_i++) + { + top[coord_i] = std::max(top[coord_i], p[coord_i]); + bottom[coord_i] = std::min(bottom[coord_i], p[coord_i]); + } + } + } + center /= 2 * n_edges; + const Eigen::Vector2d diagonal = top - bottom; + const int split_dim = diagonal[0] < diagonal[1] ? 1 : 0; + + // Set node bounding sphere + double radius_sq = 0.0; + for (int edge_i = begin; edge_i < end; edge_i++) + { + for (int i = 0; i < 2; i++) + { + radius_sq = std::max(radius_sq, (center - edges[edge_i].vertices[i]).squaredNorm()); + } + } + bounding_sphere.center = center; + bounding_sphere.radius = std::sqrt(radius_sq); + + // Sort the triangles according to their center along the split dimension + std::sort(edges.begin() + begin, edges.begin() + end, + [split_dim](const Edge& a, const Edge& b) + { + return a.vertices[0][split_dim] < b.vertices[0][split_dim]; + } + ); + + // Children + const int mid = static_cast(0.5 * (begin + end)); + + this->nodes[node_id].left = static_cast(this->nodes.size()); + this->nodes.emplace_back(); + this->_build_tree(this->nodes[node_id].left, this->nodes[node_id].bv_left, edges, begin, mid); + + this->nodes[node_id].right = static_cast(this->nodes.size()); + this->nodes.emplace_back(); + this->_build_tree(this->nodes[node_id].right, this->nodes[node_id].bv_right, edges, mid, end); + } +} + + +inline void Discregrid::PolygonDistance::_query(Result2D &result, const Node &node, const Eigen::Vector2d& point) const +{ + // End of recursion + if (node.left == -1) + { + const int edge_id = node.right; + const Eigen::Vector2i& edge = this->edges[node.right]; // If left == -1, right is the edge + const Eigen::Vector2d& v0 = this->vertices[edge[0]]; + const Eigen::Vector2d& v1 = this->vertices[edge[1]]; + + Eigen::Vector2d nearest_point; + NearestEntity2D nearest_entity; + const double distance_sq = point_edge_sq_unsigned(nearest_entity, nearest_point, point, v0, v1); + + if (distance_sq < result.distance * result.distance) + { + result.nearest_point = nearest_point; + result.nearest_entity = nearest_entity; + result.distance = std::sqrt(distance_sq); + result.edge_id = edge_id; + } + } + // Recursion + else + { + // Find which child bounding volume is closer + const double d_left = (point - node.bv_left.center).norm() - node.bv_left.radius; + const double d_right = (point - node.bv_right.center).norm() - node.bv_right.radius; + + if (d_left < d_right) + { + // Overlap test + if (d_left < result.distance) + { + this->_query(result, this->nodes[node.left], point); + } + + if (d_right < result.distance) + { + this->_query(result, this->nodes[node.right], point); + } + } + else + { + if (d_right < result.distance) + { + this->_query(result, this->nodes[node.right], point); + } + if (d_left < result.distance) + { + this->_query(result, this->nodes[node.left], point); + } + } + } +} + +static double Discregrid::point_edge_sq_unsigned(NearestEntity2D& nearest_entity, Eigen::Vector2d& nearest_point, const Eigen::Vector2d& point, const Eigen::Vector2d& v0, const Eigen::Vector2d& v1) +{ + const Eigen::Vector2d e = v1 - v0; + const double e2 = e.dot(e); + const Eigen::Vector2d diff = point - v0; + const double t = std::clamp(diff.dot(e) / e2, 0.0, 1.0); + + // Closest point on edge + nearest_point = {v0.x() + t * e.x(), v0.y() + t * e.y()}; + + if (t <= std::numeric_limits::epsilon()) + { + nearest_entity = NearestEntity2D::V0; + } + else if (t >= 1.0 - std::numeric_limits::epsilon()) + { + nearest_entity = NearestEntity2D::V1; + } + else + { + nearest_entity = NearestEntity2D::E; + } + + return (point-nearest_point).squaredNorm(); +} \ No newline at end of file diff --git a/discregrid/include/Discregrid/mesh/triangle_mesh.hpp b/discregrid/include/Discregrid/mesh/triangle_mesh.hpp index 66d38b5..d931b0e 100755 --- a/discregrid/include/Discregrid/mesh/triangle_mesh.hpp +++ b/discregrid/include/Discregrid/mesh/triangle_mesh.hpp @@ -92,6 +92,8 @@ class TriangleMesh Eigen::Vector3d computeFaceNormal(unsigned int f) const; + void weldVerticesAndCullBackfaces2D(std::vector& culled_vertices, std::vector& culled_triangles) const; + private: void construct(); diff --git a/cmd/discrete_field_to_bitmap/bmp_file.hpp b/discregrid/include/Discregrid/utility/bmp_file.hpp old mode 100755 new mode 100644 similarity index 96% rename from cmd/discrete_field_to_bitmap/bmp_file.hpp rename to discregrid/include/Discregrid/utility/bmp_file.hpp index a3204a3..622ab00 --- a/cmd/discrete_field_to_bitmap/bmp_file.hpp +++ b/discregrid/include/Discregrid/utility/bmp_file.hpp @@ -1,42 +1,42 @@ -#pragma once - -class BmpReaderWriter -{ -public: - static bool isBigEndian(); - static unsigned short endianSwap(unsigned short nValue); - static unsigned int endianSwap(unsigned int i); - - // ------------------------------------------------------------------- - -#pragma pack(1) - - struct BMPHEADER { - unsigned short Type; - unsigned int Size; - unsigned short Reserved1; - unsigned short Reserved2; - unsigned int OffBits; - }; - - // Only Win3.0 BMPINFO (see later for OS/2) - struct BMPINFO { - unsigned int Size; - unsigned int Width; - unsigned int Height; - unsigned short Planes; - unsigned short BitCount; - unsigned int Compression; - unsigned int SizeImage; - unsigned int XPelsPerMeter; - unsigned int YPelsPerMeter; - unsigned int ClrUsed; - unsigned int ClrImportant; - }; - -#pragma pack() - - // Data is persists until the class is destructed. - static bool loadFile(const char *filename, unsigned int &width, unsigned int &height, unsigned char *&data); - static bool saveFile(const char *filename, int width, int height, unsigned char *data); -}; +#pragma once + +class BmpReaderWriter +{ +public: + static bool isBigEndian(); + static unsigned short endianSwap(unsigned short nValue); + static unsigned int endianSwap(unsigned int i); + + // ------------------------------------------------------------------- + +#pragma pack(1) + + struct BMPHEADER { + unsigned short Type; + unsigned int Size; + unsigned short Reserved1; + unsigned short Reserved2; + unsigned int OffBits; + }; + + // Only Win3.0 BMPINFO (see later for OS/2) + struct BMPINFO { + unsigned int Size; + unsigned int Width; + unsigned int Height; + unsigned short Planes; + unsigned short BitCount; + unsigned int Compression; + unsigned int SizeImage; + unsigned int XPelsPerMeter; + unsigned int YPelsPerMeter; + unsigned int ClrUsed; + unsigned int ClrImportant; + }; + +#pragma pack() + + // Data is persists until the class is destructed. + static bool loadFile(const char *filename, unsigned int &width, unsigned int &height, unsigned char *&data); + static bool saveFile(const char *filename, int width, int height, unsigned char *data); +}; diff --git a/discregrid/src/cubic_lagrange_discrete_grid2D.cpp b/discregrid/src/cubic_lagrange_discrete_grid2D.cpp new file mode 100644 index 0000000..1689b13 --- /dev/null +++ b/discregrid/src/cubic_lagrange_discrete_grid2D.cpp @@ -0,0 +1,669 @@ +#include "cubic_lagrange_discrete_grid2D.hpp" + +#include "data/z_sort_table.hpp" +#include +#include "utility/spinlock.hpp" + +#include +#include +#include +#include +#include +#include +#include + +using namespace Eigen; + +namespace Discregrid +{ + +namespace +{ + +// See Zienkiewicz The Finite Element Method its Basis and Fundamentals 2013 page 159 (2D) and 168 (3D) +Matrix +shape_function_(Vector2d const &xi, Matrix *gradient = nullptr) +{ + auto res = Matrix{}; + + const auto x = xi[0]; + const auto y = xi[1]; + + const auto x2 = x * x; + const auto y2 = y * y; + + const auto _1mx = 1.0 - x; + const auto _1my = 1.0 - y; + + const auto _1px = 1.0 + x; + const auto _1py = 1.0 + y; + + const auto _1m3x = 1.0 - 3.0 * x; + const auto _1m3y = 1.0 - 3.0 * y; + + const auto _1p3x = 1.0 + 3.0 * x; + const auto _1p3y = 1.0 + 3.0 * y; + + const auto _1mxt1my = _1mx * _1my; + const auto _1mxt1py = _1mx * _1py; + const auto _1pxt1my = _1px * _1my; + const auto _1pxt1py = _1px * _1py; + + const auto _1mx2 = 1.0 - x2; + const auto _1my2 = 1.0 - y2; + + // Corner nodes. + auto factor = (1.0 / 32.0) * (9.0 * (x2 + y2) - 10.0); + res[0] = factor * _1mxt1my; + res[1] = factor * _1pxt1my; + res[2] = factor * _1mxt1py; + res[3] = factor * _1pxt1py; + + // Edge nodes. + factor = (9.0 / 32.0) * _1mx2; + auto factort1m3x = factor * _1m3x; // Note that x is multiplied with xi (+-1/3) so 9 * xi * x becomes 1/3 * x + auto factort1p3x = factor * _1p3x; + res[4] = factort1m3x * _1my; + res[5] = factort1p3x * _1my; + res[6] = factort1m3x * _1py; + res[7] = factort1p3x * _1py; + + factor = (9.0 / 32.0) * _1my2; + auto factort1m3y = factor * _1m3y; + auto factort1p3y = factor * _1p3y; + res[8] = factort1m3y * _1mx; + res[9] = factort1p3y * _1mx; + res[10] = factort1m3y * _1px; + res[11] = factort1p3y * _1px; + + if (gradient) + { + auto &dN = *gradient; + + const auto _27tx2p9ty2m10 = 27 * x2 + 9 * y2 - 10; + const auto _27ty2p9tx2m10 = 27 * y2 + 9 * x2 - 10; + + const auto _18x = 18 * x; + const auto _18y = 18 * y; + + dN(0, 0) = _1my * (_18x - _27tx2p9ty2m10); + dN(0, 1) = _1mx * (_18y - _27ty2p9tx2m10); + dN(1, 0) = _1my * (_18x + _27tx2p9ty2m10); + dN(1, 1) = _1px * (_18y - _27ty2p9tx2m10); + dN(2, 0) = _1py * (_18x - _27tx2p9ty2m10); + dN(2, 1) = _1mx * (_18y + _27ty2p9tx2m10); + dN(3, 0) = _1py * (_18x + _27tx2p9ty2m10); + dN(3, 1) = _1px * (_18y + _27ty2p9tx2m10); + + dN.topRows(4) /= 32.0; + + const auto _9x2 = 9 * x2; + const auto _2x = 2 * x; + const auto _3x = 3 * x; + const auto _3x3 = 3 * x2 * x; + const auto _9x2m2xm3 = _9x2 - _2x - 3; + const auto _3x3mx2m3xp1 = _3x3 - x2 - _3x + 1; + const auto _9x2p2xm3 = _9x2 + _2x - 3; + const auto _3x3px2m3xm1 = _3x3 + x2 - _3x - 1; + + dN(4, 0) = _1my * _9x2m2xm3; + dN(4, 1) = -_3x3mx2m3xp1; + dN(5, 0) = _1my * -_9x2p2xm3; + dN(5, 1) = _3x3px2m3xm1; + dN(6, 0) = _1py * _9x2m2xm3; + dN(6, 1) = _3x3mx2m3xp1; + dN(7, 0) = _1py * -_9x2p2xm3; + dN(7, 1) = -_3x3px2m3xm1; + + const auto _9y2 = 9 * y2; + const auto _2y = 2 * y; + const auto _3y = 3 * y; + const auto _3y3 = 3 * y2 * y; + const auto _3y3my2m3yp1 = _3y3 - y2 - _3y + 1; + const auto _9y2m2ym3 = _9y2 - _2y - 3; + const auto _3y3py2m3ym1 = _3y3 + y2 - _3y - 1; + const auto _9y2p2ym3 = _9y2 + _2y - 3; + + dN(8, 0) = -_3y3my2m3yp1; + dN(8, 1) = _1mx * _9y2m2ym3; + dN(9, 0) = _3y3py2m3ym1; + dN(9, 1) = _1mx * -_9y2p2ym3; + dN(10, 0) = _3y3my2m3yp1; + dN(10, 1) = _1px * _9y2m2ym3; + dN(11, 0) = -_3y3py2m3ym1; + dN(11, 1) = _1px * -_9y2p2ym3; + + dN.bottomRows(12u - 4u) *= 9.0 / 32.0; + } + + return res; +} + +// Determines Morten value according to z-curve. +inline uint64_t +zValue(Vector2d const &x, double invCellSize) +{ + std::array key; + for (unsigned int i(0); i < 2; ++i) + { + if (x[i] >= 0.0) + key[i] = static_cast(invCellSize * x[i]); + else + key[i] = static_cast(invCellSize * x[i]) - 1; + } + + std::array p = { + static_cast(static_cast(key[0]) - (std::numeric_limits::lowest() + 1)), + static_cast(static_cast(key[1]) - (std::numeric_limits::lowest() + 1))}; + + return morton_lut(p); +} +} // namespace + + Vector2d CubicLagrangeDiscreteGrid2D::indexToNodePosition(unsigned int l) const +{ + auto x = Vector2d{}; + + auto n = Matrix::Map(m_resolution.data()); + + // Amount of vertices and edges + auto nv = (n[0] + 1) * (n[1] + 1); + auto ne_x = n[0] * (n[1] + 1); + + auto ij = Matrix{}; + // 0 -> nv: l is a cell's corner vertex + if (l < nv) + { + ij(1) = l / (n[0] + 1); + ij(0) = l % (n[0] + 1); + + x = m_domain.min() + m_cell_size.cwiseProduct(ij.cast()); + } + // nv -> nv + 2 * ne_x: l is a non-corner vertex in x direction + else if (l < nv + 2 * ne_x) + { + l -= nv; + // Identify cell index, then split into x and y dimensions. + auto e_ind = l / 2; + ij(1) = e_ind / n[0]; + ij(0) = e_ind % n[0]; + // Calculate cell position + x = m_domain.min() + m_cell_size.cwiseProduct(ij.cast()); + // Add sub-cell node position to cell position: Either 1/3 or 2/3 of cell size in x direction + x(0) += (1.0 + static_cast(l % 2)) / 3.0 * m_cell_size[0]; + } + // nv + 2 * ne_x -> nv + 2 * (ne_x + ne_y): l is non-corner vertex in y direction + else + { + l -= nv + 2 * ne_x; + // Identify cell index, then split into x and y dimensions. + auto e_ind = l / 2; + ij(1) = e_ind % n[1]; + ij(0) = e_ind / n[1]; + + // Calculate cell position + x = m_domain.min() + m_cell_size.cwiseProduct(ij.cast()); + // Add sub-cell node position to cell position: Either 1/3 or 2/3 of cell size in y direction + x(1) += (1.0 + static_cast(l % 2)) / 3.0 * m_cell_size[1]; + } + + return x; +} + +CubicLagrangeDiscreteGrid2D::CubicLagrangeDiscreteGrid2D(std::string const &filename) +{ + load(filename); +} + +CubicLagrangeDiscreteGrid2D::CubicLagrangeDiscreteGrid2D(AlignedBox2d const &domain, std::array const &resolution) : DiscreteGrid2D(domain, resolution) +{ +} + +void CubicLagrangeDiscreteGrid2D::save(std::string const &filename) const +{ + auto out = std::ofstream(filename, std::ios::binary); + serialize::write(*out.rdbuf(), m_domain); + serialize::write(*out.rdbuf(), m_resolution); + serialize::write(*out.rdbuf(), m_cell_size); + serialize::write(*out.rdbuf(), m_inv_cell_size); + serialize::write(*out.rdbuf(), m_n_cells); + serialize::write(*out.rdbuf(), m_n_fields); + + serialize::write(*out.rdbuf(), m_nodes.size()); + for (auto const &nodes : m_nodes) + { + serialize::write(*out.rdbuf(), nodes.size()); + for (auto const &node : nodes) + { + serialize::write(*out.rdbuf(), node); + } + } + + serialize::write(*out.rdbuf(), m_cells.size()); + for (auto const &cells : m_cells) + { + serialize::write(*out.rdbuf(), cells.size()); + for (auto const &cell : cells) + { + serialize::write(*out.rdbuf(), cell); + } + } + + serialize::write(*out.rdbuf(), m_cell_map.size()); + for (auto const &maps : m_cell_map) + { + serialize::write(*out.rdbuf(), maps.size()); + for (auto const &map : maps) + { + serialize::write(*out.rdbuf(), map); + } + } + + out.close(); +} + +void CubicLagrangeDiscreteGrid2D::load(std::string const &filename) +{ + auto in = std::ifstream(filename, std::ios::binary); + + if (!in.good()) + { + std::cerr << "ERROR: Discrete grid can not be loaded. Input file does not exist!" << std::endl; + return; + } + + serialize::read(*in.rdbuf(), m_domain); + serialize::read(*in.rdbuf(), m_resolution); + serialize::read(*in.rdbuf(), m_cell_size); + serialize::read(*in.rdbuf(), m_inv_cell_size); + serialize::read(*in.rdbuf(), m_n_cells); + serialize::read(*in.rdbuf(), m_n_fields); + + auto n_nodes = std::size_t{}; + serialize::read(*in.rdbuf(), n_nodes); + m_nodes.resize(n_nodes); + for (auto &nodes : m_nodes) + { + serialize::read(*in.rdbuf(), n_nodes); + nodes.resize(n_nodes); + for (auto &node : nodes) + { + serialize::read(*in.rdbuf(), node); + } + } + + auto n_cells = std::size_t{}; + serialize::read(*in.rdbuf(), n_cells); + m_cells.resize(n_cells); + for (auto &cells : m_cells) + { + serialize::read(*in.rdbuf(), n_cells); + cells.resize(n_cells); + for (auto &cell : cells) + { + serialize::read(*in.rdbuf(), cell); + } + } + + auto n_cell_maps = std::size_t{}; + serialize::read(*in.rdbuf(), n_cell_maps); + m_cell_map.resize(n_cell_maps); + for (auto &cell_maps : m_cell_map) + { + serialize::read(*in.rdbuf(), n_cell_maps); + cell_maps.resize(n_cell_maps); + for (auto &cell_map : cell_maps) + { + serialize::read(*in.rdbuf(), cell_map); + } + } + + in.close(); +} + +unsigned int CubicLagrangeDiscreteGrid2D::addFunction(ContinuousFunction const &func, bool verbose, SamplePredicate const &pred) +{ + using namespace std::chrono; + + const auto t0_construction = high_resolution_clock::now(); + + auto n = Matrix::Map(m_resolution.data()); + + // Amount of vertices and edges + const auto nv = (n[0] + 1) * (n[1] + 1); + const auto ne_x = n[0] * (n[1] + 1); + const auto ne_y = (n[0] + 1) * n[1]; + const auto ne = ne_x + ne_y; + const auto n_nodes = nv + 2 * ne; + + m_nodes.emplace_back(); + auto &coeffs = m_nodes.back(); + coeffs.resize(n_nodes); + + std::atomic_uint counter(0u); + SpinLock mutex; + auto t0 = high_resolution_clock::now(); + + // Evaluate function at every node +#pragma omp parallel default(shared) + { +#pragma omp for schedule(static) nowait + for (int l = 0; l < static_cast(n_nodes); ++l) + { + auto x = indexToNodePosition(l); + auto &c = coeffs[l]; + + if (!pred || pred(x)) + c = func(x); + else + c = std::numeric_limits::max(); + + if (verbose && (++counter == n_nodes || duration_cast(high_resolution_clock::now() - t0).count() > 1000u)) + { + std::async(std::launch::async, [&] + { + mutex.lock(); + t0 = high_resolution_clock::now(); + std::cout << "\r" + << "Construction " << std::setw(20) + << 100.0 * static_cast(counter) / static_cast(n_nodes) << "%"; + mutex.unlock(); + }); + } + } + } + + m_cells.emplace_back(); + auto &cells = m_cells.back(); + cells.resize(m_n_cells); + const auto nx = n[0]; + const auto ny = n[1]; + for (auto l = 0u; l < m_n_cells; ++l) + { + // Build translation table for easy querying without having to recalculate the index positions + const auto j = l / nx; + const auto i = l % nx; + + auto &cell = cells[l]; + cell[0] = (nx + 1) * j + i; + cell[1] = cell[0] + 1; + cell[2] = (nx + 1) * (j + 1) + i; + cell[3] = cell[2] + 1; + + auto offset = nv; + cell[4] = offset + 2 * (nx * j + i); + cell[5] = cell[4] + 1; + cell[6] = offset + 2 * (nx * (j + 1) + i); + cell[7] = cell[6] + 1; + + offset += 2 * ne_x; + cell[8] = offset + 2 * (ny * i + j); + cell[9] = cell[8] + 1; + cell[10] = offset + 2 * (ny * (i + 1) + j); + cell[11] = cell[10] + 1; + } + + m_cell_map.emplace_back(); + auto &cell_map = m_cell_map.back(); + cell_map.resize(m_n_cells); + std::iota(cell_map.begin(), cell_map.end(), 0u); + + if (verbose) + { + std::cout << "\rConstruction took " << std::setw(15) << static_cast(duration_cast(high_resolution_clock::now() - t0_construction).count()) / 1000.0 << "s" << std::endl; + } + + return static_cast(m_n_fields++); +} + +bool CubicLagrangeDiscreteGrid2D::determineShapeFunctions(unsigned int field_id, Eigen::Vector2d const &x, std::array &cell, Eigen::Vector2d &c0, Eigen::Matrix &N, Eigen::Matrix *dN) const +{ + if (!m_domain.contains(x)) + return false; + + auto mi = (x - m_domain.min()).cwiseProduct(m_inv_cell_size).cast().eval(); + if (mi[0] >= m_resolution[0]) + mi[0] = m_resolution[0] - 1; + if (mi[1] >= m_resolution[1]) + mi[1] = m_resolution[1] - 1; + auto i = multiToSingleIndex({ { mi(0), mi(1) } }); + auto i_ = m_cell_map[field_id][i]; + if (i_ == std::numeric_limits::max()) + return false; + + auto sd = subdomain(i); + i = i_; + + // Mapping to isoparametric space from world (actually local?) space + const auto denom = (sd.max() - sd.min()).eval(); + c0 = Vector2d::Constant(2.0).cwiseQuotient(denom).eval(); + const auto c1 = (sd.max() + sd.min()).cwiseQuotient(denom).eval(); + const auto xi = (c0.cwiseProduct(x) - c1).eval(); + + cell = m_cells[field_id][i]; + N = shape_function_(xi, dN); + return true; +} + +double CubicLagrangeDiscreteGrid2D::interpolate(unsigned int field_id, Eigen::Vector2d const& xi, const std::array &cell, const Eigen::Vector2d &c0, const Eigen::Matrix &N, Eigen::Vector2d* gradient, Eigen::Matrix *dN) const +{ + if (!gradient) + { + auto phi = 0.0; + for (auto j = 0u; j < 12u; ++j) + { + auto v = cell[j]; + auto c = m_nodes[field_id][v]; + if (c == std::numeric_limits::max()) + { + return std::numeric_limits::max(); + } + phi += c * N[j]; + } + + return phi; + } + + auto phi = 0.0; + gradient->setZero(); + for (auto j = 0u; j < 12u; ++j) + { + auto v = cell[j]; + auto c = m_nodes[field_id][v]; + if (c == std::numeric_limits::max()) + { + gradient->setZero(); + return std::numeric_limits::max(); + } + phi += c * N[j]; + (*gradient)(0) += c * (*dN)(j, 0); + (*gradient)(1) += c * (*dN)(j, 1); + } + gradient->array() *= c0.array(); + + return phi; +} + +double CubicLagrangeDiscreteGrid2D::interpolate(unsigned int field_id, Vector2d const &x, Vector2d *gradient) const +{ + if (!m_domain.contains(x)) + return std::numeric_limits::max(); + + auto mi = (x - m_domain.min()).cwiseProduct(m_inv_cell_size).cast().eval(); + if (mi[0] >= m_resolution[0]) + mi[0] = m_resolution[0] - 1; + if (mi[1] >= m_resolution[1]) + mi[1] = m_resolution[1] - 1; + auto i = multiToSingleIndex({{mi(0), mi(1)}}); + auto i_ = m_cell_map[field_id][i]; + if (i_ == std::numeric_limits::max()) + return std::numeric_limits::max(); + + auto sd = subdomain(i); + i = i_; + auto d = sd.diagonal().eval(); + + auto denom = (sd.max() - sd.min()).eval(); + auto c0 = Vector2d::Constant(2.0).cwiseQuotient(denom).eval(); + auto c1 = (sd.max() + sd.min()).cwiseQuotient(denom).eval(); + auto xi = (c0.cwiseProduct(x) - c1).eval(); + + auto const &cell = m_cells[field_id][i]; + if (!gradient) + { + auto phi = 0.0; + auto N = shape_function_(xi, nullptr); + for (auto j = 0u; j < 12u; ++j) + { + auto v = cell[j]; + auto c = m_nodes[field_id][v]; + if (c == std::numeric_limits::max()) + { + return std::numeric_limits::max(); + } + phi += c * N[j]; + } + + return phi; + } + + auto dN = Matrix{}; + auto N = shape_function_(xi, &dN); + + auto phi = 0.0; + gradient->setZero(); + for (auto j = 0u; j < 12u; ++j) + { + auto v = cell[j]; + auto c = m_nodes[field_id][v]; + if (c == std::numeric_limits::max()) + { + gradient->setZero(); + return std::numeric_limits::max(); + } + phi += c * N[j]; + (*gradient)(0) += c * dN(j, 0); + (*gradient)(1) += c * dN(j, 1); + } + gradient->array() *= c0.array(); + + return phi; +} + +void CubicLagrangeDiscreteGrid2D::reduceField(unsigned int field_id, Predicate pred) +{ + auto &coeffs = m_nodes[field_id]; + auto &cells = m_cells[field_id]; + auto keep = std::vector(coeffs.size()); + for (auto l = 0u; l < coeffs.size(); ++l) + { + auto xi = indexToNodePosition(l); + keep[l] = pred(xi, coeffs[l]) && coeffs[l] != std::numeric_limits::max(); + } + + auto &cell_map = m_cell_map[field_id]; + cell_map.resize(m_n_cells); + std::iota(cell_map.begin(), cell_map.end(), 0u); + + const auto cells_ = cells; + cells.clear(); + for (auto i = 0u; i < cells_.size(); ++i) + { + auto keep_cell = false; + auto vals = std::vector{}; + for (auto v : cells_[i]) + { + keep_cell |= keep[v]; + vals.push_back(coeffs[v]); + } + if (keep_cell) + { + cells.push_back(cells_[i]); + cell_map[i] = static_cast(cells.size() - 1); + } + else + cell_map[i] = std::numeric_limits::max(); + } + + // Reduce vertices. + auto z_values = std::vector(coeffs.size()); + for (auto l = 0u; l < coeffs.size(); ++l) + { + auto xi = indexToNodePosition(l); + z_values[l] = zValue(xi, 4.0 * m_inv_cell_size.minCoeff()); + } + + std::fill(keep.begin(), keep.end(), false); + + auto vertex_to_cell = std::vector>>(coeffs.size()); + for (auto c = 0u; c < cells.size(); ++c) + { + auto const &cell = cells[c]; + + for (auto j = 0u; j < cell.size(); ++j) + { + auto v = cell[j]; + keep[v] = true; + vertex_to_cell[v].insert({c, j}); + } + } + auto last_vertex = static_cast(coeffs.size() - 1); + for (auto i = static_cast(coeffs.size() - 1); i >= 0; --i) + { + if (!keep[i]) + { + std::swap(coeffs[i], coeffs[last_vertex]); + std::swap(z_values[i], z_values[last_vertex]); + std::swap(vertex_to_cell[i], vertex_to_cell[last_vertex]); + for (auto const &kvp : vertex_to_cell[i]) + { + cells[kvp.first][kvp.second] = i; + } + for (auto const &kvp : vertex_to_cell[last_vertex]) + { + cells[kvp.first][kvp.second] = last_vertex; + } + + last_vertex--; + } + } + coeffs.resize(last_vertex + 1); + z_values.resize(coeffs.size()); + + auto sort_pattern = std::vector(coeffs.size()); + std::iota(sort_pattern.begin(), sort_pattern.end(), 0u); + std::sort(sort_pattern.begin(), sort_pattern.end(), + [&](unsigned int i, unsigned int j) { + return z_values[i] < z_values[j]; + }); + + for (auto i = 0u; i < sort_pattern.size(); ++i) + { + auto j = sort_pattern[i]; + for (auto const &kvp : vertex_to_cell[j]) + { + assert(cells[kvp.first][kvp.second] == j); + cells[kvp.first][kvp.second] = i; + } + } + + auto coeffs_ = coeffs; + std::transform(sort_pattern.begin(), sort_pattern.end(), coeffs.begin(), + [&coeffs_](unsigned int i) { return coeffs_[i]; }); +} + +void CubicLagrangeDiscreteGrid2D::forEachCell(unsigned int field_id, std::function const &cb) const +{ + auto n = m_resolution[0] * m_resolution[1]; + for (auto i = 0u; i < n; ++i) + { + auto domain = AlignedBox2d{}; + auto mi = singleToMultiIndex(i); + domain.min() = m_domain.min() + Matrix::Map(mi.data()).cast().cwiseProduct(m_cell_size); + domain.max() = domain.min() + m_cell_size; + + cb(i, domain, 0); + } +} + +} // namespace Discregrid diff --git a/discregrid/src/data/z_sort_table.hpp b/discregrid/src/data/z_sort_table.hpp index ea22ba4..841600c 100755 --- a/discregrid/src/data/z_sort_table.hpp +++ b/discregrid/src/data/z_sort_table.hpp @@ -1,3 +1,28 @@ +// The pre-shifted tables are from https://github.com/Forceflow/libmorton/tree/main under the MIT license: +/* +MIT License + +Copyright (c) 2016 Jeroen Baert + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + #ifndef Z_SORT_TABLE_H__ #define Z_SORT_TABLE_H__ @@ -133,4 +158,91 @@ uint64_t morton_lut(std::array const& x) return answer; } +// 2D +static const unsigned int Morton2D_encode_x_256[256] = +{ + 0, 1, 4, 5, 16, 17, 20, 21, + 64, 65, 68, 69, 80, 81, 84, 85, + 256, 257, 260, 261, 272, 273, 276, 277, + 320, 321, 324, 325, 336, 337, 340, 341, + 1024, 1025, 1028, 1029, 1040, 1041, 1044, 1045, + 1088, 1089, 1092, 1093, 1104, 1105, 1108, 1109, + 1280, 1281, 1284, 1285, 1296, 1297, 1300, 1301, + 1344, 1345, 1348, 1349, 1360, 1361, 1364, 1365, + 4096, 4097, 4100, 4101, 4112, 4113, 4116, 4117, + 4160, 4161, 4164, 4165, 4176, 4177, 4180, 4181, + 4352, 4353, 4356, 4357, 4368, 4369, 4372, 4373, + 4416, 4417, 4420, 4421, 4432, 4433, 4436, 4437, + 5120, 5121, 5124, 5125, 5136, 5137, 5140, 5141, + 5184, 5185, 5188, 5189, 5200, 5201, 5204, 5205, + 5376, 5377, 5380, 5381, 5392, 5393, 5396, 5397, + 5440, 5441, 5444, 5445, 5456, 5457, 5460, 5461, + 16384, 16385, 16388, 16389, 16400, 16401, 16404, 16405, + 16448, 16449, 16452, 16453, 16464, 16465, 16468, 16469, + 16640, 16641, 16644, 16645, 16656, 16657, 16660, 16661, + 16704, 16705, 16708, 16709, 16720, 16721, 16724, 16725, + 17408, 17409, 17412, 17413, 17424, 17425, 17428, 17429, + 17472, 17473, 17476, 17477, 17488, 17489, 17492, 17493, + 17664, 17665, 17668, 17669, 17680, 17681, 17684, 17685, + 17728, 17729, 17732, 17733, 17744, 17745, 17748, 17749, + 20480, 20481, 20484, 20485, 20496, 20497, 20500, 20501, + 20544, 20545, 20548, 20549, 20560, 20561, 20564, 20565, + 20736, 20737, 20740, 20741, 20752, 20753, 20756, 20757, + 20800, 20801, 20804, 20805, 20816, 20817, 20820, 20821, + 21504, 21505, 21508, 21509, 21520, 21521, 21524, 21525, + 21568, 21569, 21572, 21573, 21584, 21585, 21588, 21589, + 21760, 21761, 21764, 21765, 21776, 21777, 21780, 21781, + 21824, 21825, 21828, 21829, 21840, 21841, 21844, 21845 +}; + +static const unsigned int Morton2D_encode_y_256[256] = +{ + 0, 2, 8, 10, 32, 34, 40, 42, + 128, 130, 136, 138, 160, 162, 168, 170, + 512, 514, 520, 522, 544, 546, 552, 554, + 640, 642, 648, 650, 672, 674, 680, 682, + 2048, 2050, 2056, 2058, 2080, 2082, 2088, 2090, + 2176, 2178, 2184, 2186, 2208, 2210, 2216, 2218, + 2560, 2562, 2568, 2570, 2592, 2594, 2600, 2602, + 2688, 2690, 2696, 2698, 2720, 2722, 2728, 2730, + 8192, 8194, 8200, 8202, 8224, 8226, 8232, 8234, + 8320, 8322, 8328, 8330, 8352, 8354, 8360, 8362, + 8704, 8706, 8712, 8714, 8736, 8738, 8744, 8746, + 8832, 8834, 8840, 8842, 8864, 8866, 8872, 8874, + 10240, 10242, 10248, 10250, 10272, 10274, 10280, 10282, + 10368, 10370, 10376, 10378, 10400, 10402, 10408, 10410, + 10752, 10754, 10760, 10762, 10784, 10786, 10792, 10794, + 10880, 10882, 10888, 10890, 10912, 10914, 10920, 10922, + 32768, 32770, 32776, 32778, 32800, 32802, 32808, 32810, + 32896, 32898, 32904, 32906, 32928, 32930, 32936, 32938, + 33280, 33282, 33288, 33290, 33312, 33314, 33320, 33322, + 33408, 33410, 33416, 33418, 33440, 33442, 33448, 33450, + 34816, 34818, 34824, 34826, 34848, 34850, 34856, 34858, + 34944, 34946, 34952, 34954, 34976, 34978, 34984, 34986, + 35328, 35330, 35336, 35338, 35360, 35362, 35368, 35370, + 35456, 35458, 35464, 35466, 35488, 35490, 35496, 35498, + 40960, 40962, 40968, 40970, 40992, 40994, 41000, 41002, + 41088, 41090, 41096, 41098, 41120, 41122, 41128, 41130, + 41472, 41474, 41480, 41482, 41504, 41506, 41512, 41514, + 41600, 41602, 41608, 41610, 41632, 41634, 41640, 41642, + 43008, 43010, 43016, 43018, 43040, 43042, 43048, 43050, + 43136, 43138, 43144, 43146, 43168, 43170, 43176, 43178, + 43520, 43522, 43528, 43530, 43552, 43554, 43560, 43562, + 43648, 43650, 43656, 43658, 43680, 43682, 43688, 43690 +}; + +inline +uint64_t morton_lut(std::array const& x) +{ + uint64_t answer = 0; + answer = answer << 48 | morton256_z[(x[2] >> 8) & 0xFF] | // shifting second byte + morton256_y[(x[1] >> 8) & 0xFF] | + morton256_x[(x[0] >> 8) & 0xFF]; + answer = answer << 24 | + morton256_z[(x[2]) & 0xFF] | // first byte + morton256_y[(x[1]) & 0xFF] | + morton256_x[(x[0]) & 0xFF]; + return answer; +} + #endif // Z_SORT_TABLE_H__ diff --git a/discregrid/src/discrete_grid2D.cpp b/discregrid/src/discrete_grid2D.cpp new file mode 100644 index 0000000..b46c909 --- /dev/null +++ b/discregrid/src/discrete_grid2D.cpp @@ -0,0 +1,39 @@ +#include + +using namespace Eigen; + +namespace Discregrid +{ + + +DiscreteGrid2D::MultiIndex +DiscreteGrid2D::singleToMultiIndex(unsigned int l) const +{ + const auto n0 = m_resolution[0]; + const auto j = l / n0; + const auto i = l % n0; + return {{i, j}}; +} + +unsigned int +DiscreteGrid2D::multiToSingleIndex(MultiIndex const & ij) const +{ + return ij[1] * m_resolution[0] + ij[0]; +} + +AlignedBox2d +DiscreteGrid2D::subdomain(MultiIndex const& ij) const +{ + auto origin = m_domain.min() + Map const>( + ij.data()).cast().cwiseProduct(m_cell_size); + return { origin, origin + m_cell_size}; +} + +AlignedBox2d +DiscreteGrid2D::subdomain(unsigned int l) const +{ + return subdomain(singleToMultiIndex(l)); +} + + +} \ No newline at end of file diff --git a/discregrid/src/mesh/triangle_mesh.cpp b/discregrid/src/mesh/triangle_mesh.cpp index 8a59453..f95f3a5 100755 --- a/discregrid/src/mesh/triangle_mesh.cpp +++ b/discregrid/src/mesh/triangle_mesh.cpp @@ -5,6 +5,7 @@ #include #include #include +#include using namespace Eigen; @@ -214,5 +215,73 @@ TriangleMesh::computeFaceNormal(unsigned int f) const return (x1 - x0).cross(x2 - x0).normalized(); } +struct Vector2dHash +{ + std::size_t operator()(const Vector2d& v) const + { + std::size_t seed = 0; + constexpr std::hash hasher; + seed ^= hasher(v.x()) + 0x9e3779b9 + (seed << 6) + (seed >> 2); + seed ^= hasher(v.y()) + 0x9e3779b9 + (seed << 6) + (seed >> 2); + return seed; + } +}; + +struct Vector2dEqual +{ + bool operator()(const Vector2d& v1, const Vector2d& v2) const + { + return v1.isApprox(v2); + } +}; + +void TriangleMesh::weldVerticesAndCullBackfaces2D(std::vector& culled_vertices, std::vector& culled_triangles) const +{ + const Vector3d view_vector(0, 0, 1); // XY-Plane + + std::vector culled_and_welded_vertices; + std::vector culled_and_welded_triangles; + std::unordered_map vertex_to_index; + + auto weld_to_mesh = [&](const Vector2d& vertex) + { + const auto it = vertex_to_index.find(vertex); + if (it == vertex_to_index.end()) + { + const unsigned int index = culled_and_welded_vertices.size(); + culled_and_welded_vertices.push_back(vertex); + vertex_to_index[vertex] = index; + culled_and_welded_triangles.push_back(index); + } + else + { + culled_and_welded_triangles.push_back(it->second); + } + }; + + for (size_t i = 0; i < m_faces.size(); ++i) + { + const auto& triangle = m_faces[i]; + const auto i0 = triangle[0]; + const auto i1 = triangle[1]; + const auto i2 = triangle[2]; + Vector3d v0 = m_vertices[i0]; + Vector3d v1 = m_vertices[i1]; + Vector3d v2 = m_vertices[i2]; + Vector3d e1 = v1 - v0; + Vector3d e2 = v2 - v0; + + if (e1.cross(e2).dot(view_vector) < 0.0) + { + weld_to_mesh(v0.head<2>()); + weld_to_mesh(v1.head<2>()); + weld_to_mesh(v2.head<2>()); + } + } + + culled_vertices = culled_and_welded_vertices; + culled_triangles = culled_and_welded_triangles; +} + } diff --git a/cmd/discrete_field_to_bitmap/bmp_file.cpp b/discregrid/src/utility/bmp_file.cpp old mode 100755 new mode 100644 similarity index 95% rename from cmd/discrete_field_to_bitmap/bmp_file.cpp rename to discregrid/src/utility/bmp_file.cpp index 0de1675..2d27191 --- a/cmd/discrete_field_to_bitmap/bmp_file.cpp +++ b/discregrid/src/utility/bmp_file.cpp @@ -1,147 +1,148 @@ -#include -#include -#include "bmp_file.hpp" - -// Compression Type -#define BI_RGB 0L -#define BI_RLE8 1L -#define BI_RLE4 2L - - -// ------------------------------------------------------------------- -bool BmpReaderWriter::loadFile(const char *filename, unsigned int &width, unsigned int &height, unsigned char *&data) -{ - if (data) - { - delete [] data; - data = NULL; - } - width = 0; - height = 0; - - FILE *f = fopen(filename, "rb"); - if (!f) - return false; - - size_t num; - BMPHEADER header; - num = fread(&header, sizeof(BMPHEADER), 1, f); - if(isBigEndian()) header.Type = endianSwap(header.Type); - if (num != 1) { fclose(f); return false; } - if (header.Type != 'MB') { fclose(f); return false; } - - BMPINFO info; - num = fread(&info, sizeof(BMPINFO), 1, f); - if (num != 1) { fclose(f); return false; } - if(isBigEndian()) info.Size = endianSwap(info.Size); - if(isBigEndian()) info.BitCount = endianSwap(info.BitCount); - if(isBigEndian()) info.Compression = endianSwap(info.Compression); - if(isBigEndian()) info.Width = endianSwap(info.Width); - if(isBigEndian()) info.Height = endianSwap(info.Height); - - if (info.Size != sizeof(BMPINFO)) { fclose(f); return false; } - if (info.BitCount != 24) { fclose(f); return false; } - if (info.Compression != BI_RGB) { fclose(f); return false; } - - width = info.Width; - height = info.Height; - data = new unsigned char[width * height * 3]; - - int lineLen = (((info.Width * (info.BitCount>>3)) + 3)>>2)<<2; - unsigned char *line = new unsigned char[lineLen]; - - for(int i = info.Height-1; i >= 0; i--) { - num = fread(line, lineLen, 1, f); - if (num != 1) { fclose(f); return false; } - unsigned char *src = line; - unsigned char *dest = data + i*info.Width*3; - for(unsigned int j = 0; j < info.Width; j++) { - unsigned char r,g,b; - b = *src++; g = *src++; r = *src++; - *dest++ = r; *dest++ = g; *dest++ = b; - } - } - - delete [] line; - fclose(f); - - return true; -} - -// ------------------------------------------------------------------- -bool BmpReaderWriter::saveFile(const char *filename, int width, int height, unsigned char *data) -{ - FILE *f = fopen(filename, "wb"); - if (!f) return false; - - // todo : works on pcs only, swap correctly if big endian - BMPHEADER header; - header.Type = 'MB'; - header.Size = sizeof(BMPINFO); - header.Reserved1 = 0; - header.Reserved2 = 0; - header.OffBits = sizeof(BMPHEADER) + sizeof(BMPINFO); - fwrite(&header, sizeof(BMPHEADER), 1, f); - - BMPINFO info; - info.Size = sizeof(BMPINFO); - info.Width = width; - info.Height = height; - info.Planes = 1; - info.BitCount = 24; - info.Compression = BI_RGB; - info.XPelsPerMeter = 4000; - info.YPelsPerMeter = 4000; - info.ClrUsed = 0; - info.ClrImportant = 0; - fwrite(&info, sizeof(info), 1, f); - - // padded to multiple of 4 - int lineLen = (((info.Width * (info.BitCount>>3)) + 3)>>2)<<2; - info.SizeImage = lineLen * height; - - unsigned char *line = new unsigned char[lineLen]; - - for(int i = 0; i < height; i++) - { - unsigned char *src = data + i*width*3; - unsigned char *dest = line; - for(int j = 0; j < width; j++) - { - unsigned char r,g,b; - r = *src++; g = *src++; b = *src++; - *dest++ = b; *dest++ = g; *dest++ = r; - } - for (int j = 3*width; j < lineLen; j++) - *dest++ = 0; - fwrite(line, lineLen, 1, f); - } - - delete [] line; - fclose(f); - - return true; -} - -bool BmpReaderWriter::isBigEndian() -{ - int i = 1; return *((char*)&i) == 0; -} - -unsigned short BmpReaderWriter::endianSwap(unsigned short nValue) -{ - return (((nValue >> 8)) | (nValue << 8)); -} - -unsigned int BmpReaderWriter::endianSwap(unsigned int i) -{ - unsigned char b1, b2, b3, b4; - - b1 = i & 255; - b2 = (i >> 8) & 255; - b3 = (i >> 16) & 255; - b4 = (i >> 24) & 255; - - return ((unsigned int)b1 << 24) + ((unsigned int)b2 << 16) + ((unsigned int)b3 << 8) + b4; -} - +#include "utility/bmp_file.hpp" + +#include +#include + +// Compression Type +#define BI_RGB 0L +#define BI_RLE8 1L +#define BI_RLE4 2L + + +// ------------------------------------------------------------------- +bool BmpReaderWriter::loadFile(const char *filename, unsigned int &width, unsigned int &height, unsigned char *&data) +{ + if (data) + { + delete [] data; + data = NULL; + } + width = 0; + height = 0; + + FILE *f = fopen(filename, "rb"); + if (!f) + return false; + + size_t num; + BMPHEADER header; + num = fread(&header, sizeof(BMPHEADER), 1, f); + if(isBigEndian()) header.Type = endianSwap(header.Type); + if (num != 1) { fclose(f); return false; } + if (header.Type != 'MB') { fclose(f); return false; } + + BMPINFO info; + num = fread(&info, sizeof(BMPINFO), 1, f); + if (num != 1) { fclose(f); return false; } + if(isBigEndian()) info.Size = endianSwap(info.Size); + if(isBigEndian()) info.BitCount = endianSwap(info.BitCount); + if(isBigEndian()) info.Compression = endianSwap(info.Compression); + if(isBigEndian()) info.Width = endianSwap(info.Width); + if(isBigEndian()) info.Height = endianSwap(info.Height); + + if (info.Size != sizeof(BMPINFO)) { fclose(f); return false; } + if (info.BitCount != 24) { fclose(f); return false; } + if (info.Compression != BI_RGB) { fclose(f); return false; } + + width = info.Width; + height = info.Height; + data = new unsigned char[width * height * 3]; + + int lineLen = (((info.Width * (info.BitCount>>3)) + 3)>>2)<<2; + unsigned char *line = new unsigned char[lineLen]; + + for(int i = info.Height-1; i >= 0; i--) { + num = fread(line, lineLen, 1, f); + if (num != 1) { fclose(f); return false; } + unsigned char *src = line; + unsigned char *dest = data + i*info.Width*3; + for(unsigned int j = 0; j < info.Width; j++) { + unsigned char r,g,b; + b = *src++; g = *src++; r = *src++; + *dest++ = r; *dest++ = g; *dest++ = b; + } + } + + delete [] line; + fclose(f); + + return true; +} + +// ------------------------------------------------------------------- +bool BmpReaderWriter::saveFile(const char *filename, int width, int height, unsigned char *data) +{ + FILE *f = fopen(filename, "wb"); + if (!f) return false; + + // todo : works on pcs only, swap correctly if big endian + BMPHEADER header; + header.Type = 'MB'; + header.Size = sizeof(BMPINFO); + header.Reserved1 = 0; + header.Reserved2 = 0; + header.OffBits = sizeof(BMPHEADER) + sizeof(BMPINFO); + fwrite(&header, sizeof(BMPHEADER), 1, f); + + BMPINFO info; + info.Size = sizeof(BMPINFO); + info.Width = width; + info.Height = height; + info.Planes = 1; + info.BitCount = 24; + info.Compression = BI_RGB; + info.XPelsPerMeter = 4000; + info.YPelsPerMeter = 4000; + info.ClrUsed = 0; + info.ClrImportant = 0; + fwrite(&info, sizeof(info), 1, f); + + // padded to multiple of 4 + int lineLen = (((info.Width * (info.BitCount>>3)) + 3)>>2)<<2; + info.SizeImage = lineLen * height; + + unsigned char *line = new unsigned char[lineLen]; + + for(int i = 0; i < height; i++) + { + unsigned char *src = data + i*width*3; + unsigned char *dest = line; + for(int j = 0; j < width; j++) + { + unsigned char r,g,b; + r = *src++; g = *src++; b = *src++; + *dest++ = b; *dest++ = g; *dest++ = r; + } + for (int j = 3*width; j < lineLen; j++) + *dest++ = 0; + fwrite(line, lineLen, 1, f); + } + + delete [] line; + fclose(f); + + return true; +} + +bool BmpReaderWriter::isBigEndian() +{ + int i = 1; return *((char*)&i) == 0; +} + +unsigned short BmpReaderWriter::endianSwap(unsigned short nValue) +{ + return (((nValue >> 8)) | (nValue << 8)); +} + +unsigned int BmpReaderWriter::endianSwap(unsigned int i) +{ + unsigned char b1, b2, b3, b4; + + b1 = i & 255; + b2 = (i >> 8) & 255; + b3 = (i >> 16) & 255; + b4 = (i >> 24) & 255; + + return ((unsigned int)b1 << 24) + ((unsigned int)b2 << 16) + ((unsigned int)b3 << 8) + b4; +} + From 8158b06eb49de1c2c2219c421f3f0a509aa734d8 Mon Sep 17 00:00:00 2001 From: Johannes Schatteiner Date: Fri, 21 Jul 2023 15:41:56 +0200 Subject: [PATCH 2/9] Make 2D files always in solution even when clipper2 is not present --- README.md | 14 +++++++--- cmd/discrete_field_to_bitmap_2d/main.cpp | 2 -- cmd/generate_sdf_2d/main.cpp | 6 ++-- discregrid/CMakeLists.txt | 28 +++++++------------ discregrid/include/Discregrid/All | 2 ++ .../Discregrid/geometry/PolygonDistance.hpp | 7 ++++- 6 files changed, 30 insertions(+), 29 deletions(-) diff --git a/README.md b/README.md index d47bd5b..24cd5bf 100755 --- a/README.md +++ b/README.md @@ -6,13 +6,16 @@ **Figure 1**: Left: Slice of a three-dimensional discrete signed distance field of the Stanford dragon. Right: Density map for SPH boundary handling of Stanford dragon. **Discregrid** is a static C++ library for the parallel discretization of (preferably smooth) functions on regular grids. -The library generates a (cubic) polynomial discretization given a box-shaped domain, a grid resolution, and a function that maps a three-dimensional position in space to a real scalar value. +The library generates a (cubic) polynomial discretization given a box-shaped domain, a grid resolution, and a function that maps a two- or three-dimensional position in space to a real scalar value. Isoparametric cubic polynomials of Serendipity type for the cell-wise discretization are employed. The coefficient vector for the discrete polynomial basis is computed using regular sampling of the input function at the higher-order grid's nodes. The algorithm to generate the discretization is moreover *fully parallelized* using OpenMP and especially well-suited for the discretization of signed distance functions. The library moreover provides the functionality to serialize and deserialize the a generated discrete grid. Discregrid ships with [TriangleMeshDistance](https://github.com/InteractiveComputerGraphics/TriangleMeshDistance) to directly provide the capability to compute and discretize signed distance fields to triangle meshes. +![](Dragon2D.png) +**Figure 2**: Left: 2D-Polygon representation of the Stanford dragon. Right: Two-dimensional discrete signed distance field of the Stanford dragon. + Besides the library, the project includes three executable programs that serve the following purposes: * *GenerateSDF*: Computes a discrete (cubic) signed distance field from a triangle mesh in OBJ format. * *DiscreteFieldToBitmap*: Generates an image in bitmap format of a two-dimensional slice of a previously computed discretization. @@ -26,9 +29,12 @@ Besides the library, the project includes three executable programs that serve t ## Build Instructions -This project is based on [CMake](https://cmake.org/). Simply generate project, Makefiles, etc. using [CMake](https://cmake.org/) and compile the project with the compiler of your choice. The code was tested with the following configurations: -- Windows 10 64-bit, CMake 3.8, Visual Studio 2017 -- Debian 9 64-bit, CMake 3.8, GCC 6.3. +This project is based on [CMake](https://cmake.org/). Simply generate project, Makefiles, etc. using [CMake](https://cmake.org/) and compile the project with the compiler of your choice. The minimum required version of CMake for this project is 3.11. The code was tested with the following configurations: +- Windows 10 64-bit, CMake 3.23.1, Visual Studio 2017 + +If the option USE_CLIPPER2 is active in CMake the [Clipper2](https://github.com/AngusJohnson/Clipper2) library is automatically downloaded and the following two executable programs can also be generated: +* *GenerateSDF2D*: Computes a discrete (cubic) 2D signed distance field from a triangle mesh in OBJ format. Clipper2 is used to convert the triangle mesh to a 2D polygon before discretization, as seen on the left in Figure 2. +* *DiscreteFieldToBitmap2D*: Generates an image in bitmap format of a previously computed 2D discretization. ## Usage In order to use the library, the main header has to be included and the static library has to be compiled and linked against the client program. diff --git a/cmd/discrete_field_to_bitmap_2d/main.cpp b/cmd/discrete_field_to_bitmap_2d/main.cpp index da97847..2585c17 100644 --- a/cmd/discrete_field_to_bitmap_2d/main.cpp +++ b/cmd/discrete_field_to_bitmap_2d/main.cpp @@ -8,8 +8,6 @@ #include #include "Discregrid/utility/bmp_file.hpp" -#include "Discregrid/cubic_lagrange_discrete_grid2D.hpp" -#include "Discregrid/discrete_grid2D.hpp" using namespace Eigen; diff --git a/cmd/generate_sdf_2d/main.cpp b/cmd/generate_sdf_2d/main.cpp index 314b917..acc4960 100644 --- a/cmd/generate_sdf_2d/main.cpp +++ b/cmd/generate_sdf_2d/main.cpp @@ -7,10 +7,8 @@ #include #include -#include "clipper.svg.h" -#include "clipper2/clipper.export.h" -#include "Discregrid/cubic_lagrange_discrete_grid2D.hpp" -#include "Discregrid/geometry/PolygonDistance.hpp" +#include +#include using namespace Eigen; diff --git a/discregrid/CMakeLists.txt b/discregrid/CMakeLists.txt index 3c6e707..81e3b1f 100755 --- a/discregrid/CMakeLists.txt +++ b/discregrid/CMakeLists.txt @@ -2,6 +2,8 @@ set(HEADERS include/Discregrid/discrete_grid.hpp include/Discregrid/cubic_lagrange_discrete_grid.hpp + include/Discregrid/discrete_grid2D.hpp + include/Discregrid/cubic_lagrange_discrete_grid2D.hpp ) set(HEADERS_MESH @@ -13,6 +15,7 @@ set(HEADERS_MESH set(HEADERS_GEOMETRY include/Discregrid/geometry/TriangleMeshDistance.h + include/Discregrid/geometry/PolygonDistance.hpp ) set(HEADERS_UTILITY @@ -27,6 +30,8 @@ set(HEADERS_UTILITY set(SOURCES src/discrete_grid.cpp src/cubic_lagrange_discrete_grid.cpp + src/discrete_grid2D.cpp + src/cubic_lagrange_discrete_grid2D.cpp ) set(SOURCES_MESH @@ -40,24 +45,6 @@ set(SOURCES_UTILITY src/utility/bmp_file.cpp ) -if (USE_CLIPPER2) - - list(APPEND HEADERS - include/Discregrid/discrete_grid2D.hpp - include/Discregrid/cubic_lagrange_discrete_grid2D.hpp - ) - - list(APPEND HEADERS_GEOMETRY - include/Discregrid/geometry/PolygonDistance.hpp - ) - - list(APPEND SOURCES - src/discrete_grid2D.cpp - src/cubic_lagrange_discrete_grid2D.cpp - ) - -endif() - macro(SOURCEGROUP name) string(TOLOWER ${name} name_lower) string(SUBSTRING ${name_lower} 0 1 FIRST_LETTER) @@ -101,6 +88,11 @@ if(WIN32) add_definitions(-D_USE_MATH_DEFINES) endif(WIN32) +# Enable PolygonDistance to use clipper2 reliant constructor. +if (USE_CLIPPER2) + add_definitions(-DIS_CLIPPER_ENABLED) +endif() + set(DISCREGRID_SOURCE_FILES ${HEADERS} ${SOURCES} diff --git a/discregrid/include/Discregrid/All b/discregrid/include/Discregrid/All index 34431bf..23faa6e 100755 --- a/discregrid/include/Discregrid/All +++ b/discregrid/include/Discregrid/All @@ -1,3 +1,5 @@ #include "cubic_lagrange_discrete_grid.hpp" +#include "cubic_lagrange_discrete_grid2D.hpp" #include "geometry/TriangleMeshDistance.h" +#include "geometry/PolygonDistance.hpp" #include "mesh/triangle_mesh.hpp" diff --git a/discregrid/include/Discregrid/geometry/PolygonDistance.hpp b/discregrid/include/Discregrid/geometry/PolygonDistance.hpp index 930109c..5d9696e 100644 --- a/discregrid/include/Discregrid/geometry/PolygonDistance.hpp +++ b/discregrid/include/Discregrid/geometry/PolygonDistance.hpp @@ -1,11 +1,12 @@ #pragma once #include #include -#include #include #include #include "TriangleMeshDistance.h" +#ifdef IS_CLIPPER_ENABLED #include "clipper2/clipper.core.h" +#endif // This file is a derivative of TriangleMeshDistance.h providing the same functionality in 2D. // This file can be used to get the distance of a point to a closed polygon (that can contain holes). @@ -94,12 +95,14 @@ namespace Discregrid template PolygonDistance(const std::vector& vertices, const std::vector& edges); +#ifdef IS_CLIPPER_ENABLED /** * @brief Constructs a new PolygonDistance object. * * @param polygon Clipper2 PathsD (= Polygon) object. */ PolygonDistance(const Clipper2Lib::PathsD &polygon); +#endif /** * @brief Initializes an existing PolygonDistance object (including empty ones). @@ -158,6 +161,7 @@ inline Discregrid::PolygonDistance::PolygonDistance(const std::vectorconstruct(vertices, edges); } +#ifdef IS_CLIPPER_ENABLED inline Discregrid::PolygonDistance::PolygonDistance(const Clipper2Lib::PathsD &polygon) { size_t size = 0; @@ -186,6 +190,7 @@ inline Discregrid::PolygonDistance::PolygonDistance(const Clipper2Lib::PathsD &p } this->construct(polygonVertices, polygonEdges); } +#endif template inline void Discregrid::PolygonDistance::construct(const FLOAT* vertices, const SIZE_T n_vertices, const INT* edges, const SIZE_T n_edges) From 5c188b5cb6335cd415b17a73b11eca46f3bf55aa Mon Sep 17 00:00:00 2001 From: Johannes Schatteiner Date: Fri, 21 Jul 2023 15:47:32 +0200 Subject: [PATCH 3/9] Add 2D Dragon --- Dragon2D.png | Bin 0 -> 275796 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 Dragon2D.png diff --git a/Dragon2D.png b/Dragon2D.png new file mode 100644 index 0000000000000000000000000000000000000000..62ed90b81231a7472aa8c17f61ee5f8ee144e4f4 GIT binary patch literal 275796 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

^nmRJ;T1CQ+PM#B7Z8K^l4qqZzOs zQGsZRp5jK-AG#=|aB=dzd=KpMr0)p|&LjNC+EXEDerwteh%lbMNbfd0TO1Ln1QaT| zTU_*_pcw5>;l0;(PqwE^hO}490UZI4@f4)+yY-J3RCvr#OSs3hmvuoF>5ZfX2xUbg z>j5C$*qG^gW)QcHn=TU5$}4|0h6q`b5~Z*g81< zM%UC%eutu&f@!9u=b}A;hCQs~EdtSNJ4taFSdtquRn;VS?QxM!=AWBl5)zI;t~SgV zSQJlk*siOU_Edf0B?hIJ*-Z}1cuU+krWPLb?-lRbK;%yzpjwr7=@SY zTu7hHXu9BBs@D^h*se;YRszqN0oZdUUeey0lf@0Km4$FI%dS(3F1VOG(p!;&R(Q?hq!=p8Q z81_{;5{rr0&3RV)Z$D_X7oAS2;E-FIP%s{-@)eVn=-Yy41J)Un$0ul@iS`MydwB;V zT%nxh(ON&`pq+>>-nd?xgZqW~5tdDC;*fqDcoWK*2a1FU>|Rzesq!7Q&vBQ&B)jQ^ z;Y5{9n&)qsNSlXi7!I?@wo3O*+jD|nQ^&7*@42jC)NzBjWt*!|8_N4zk%X@lR@x+gO^j)ch>I3jZ{hVkZ*nrVNfRNy%3Mn6 z>x?=WFQ#55yC|S9=hS~VR(eYbhSZ&KTRFxf6o3b+O~oH-TV6M@AJ-dF#&e3b|65g= zi08$1#f%Fge68TZaa(i!e%26>%Ij#V1`$m~X>NK~5t$^@cb=Uc^;rFLB+xdn3>Bu- zxxT5K>{M-`TZFyH6nByAgr_Q0X`mu5CMz8Tn<7=P)xY-%z3DUKPk|P^&oWYQdwE0_^2PEwrpWU$A}J&aW8&%MQU6Q{V>Xhp$msQA&9Jn@r-l#+u4ss_; zS08f(!7ZYPS>;Tb#T0ln-AcR8m~RFLYOIojhpfO^GqwyRpm7xla8E4tS?&(;_kJIb zA};-5r2@Z|lzOEDuLAnQ}{8{m-=$OLJnJD#KZ6n&T^bT# zgbKmiCas!=0^NOqXyxg>?+)bkzdV%`-g@7z3_SfIUEky+p+pZ3=v51n#>!_waSs%h z2#^^HG*nea-*fhdcuht!oiLBUk?9FNxA}x;^f)znWybccsSmiytr<6ZJ!RP_fqfyD zK4&pDa)fL54pO8N9Xm#n0(|VE9}%?Kp&jTfC1$Bc2_YUC2HMF9d%JKWY#InWG@ujn z?TA*lKSiID!2SXs7_Hr7M}Xjx6;-Lf?xv&j$Me^^!;Uc2Xw*CoRzgTirhxE?g6Kc& z@yxP3uVWpWm6Z6?(Y8&e3ulKmCmV-@dNFgSA>=7YuFh+(;B8_n;M@71AR6q`XSm(Z z2%^;eS~?>(?QrvEbR&y{LmxpYRP}ZUoWz&5a?D2#fPE3$x-Q94$LNXZcoykNSsShCLN|Ze4d{}|dyNcV@Ln|ubT__nDdnJay$+k-X zxua1$3Tr4B0|kol#0NlaTy+i)h4xH{k0BQ9xrz|cd%Q7j{RUgnV%ie>Z1{uCZnI*z z9zN-LS%HaDe!ZIwI1ZC`@nc6l6ccPYOw}h6x}hP}lPPJek!np0I2gwSi42VDpa_Z8 zl2W)43z`cBwmU+CuSVk!82Z(_U^>Exw;9{mOTIO^e;}2IY7Z_w+RTOTFqeI*#KL?c zAU=JEBP4Ie%6}X)Dmr$y`C89%J5`@|N;xxEzC_;SRx6^iJ*c;wx4Wzr3_+F{M6U9S zayO(rzhrz+CIo3{9<-T&U^#B*SE=dX=wb;gcPx(QYQge|4M>v3w5hCjt5t#AH9=DD zJK*ujbTYRO)GcEa61e8U+PX99a4{wu8pX5HRD8T>ndRtv3`q>I5V{ZgN9y}g$6;TI zum7J5K%0E2t|KcsmB3ROoCxc^Na;&v-Xl`0OVMVJNAiFv_N_M_Ml(HMBo`4j{BO~x z0AQ%g=`_?Y?CT^%b2;Hv6~QK-8D$EZMm&eUMUWO>IFl&?~ zrP*;Twk0-=6c-Yi6%ZKT=OxS@^?X4g-FO=kzsbT_be7X4HLQz6~1_b)f2;waMfPy#_GZDv~?5(Q%iYqbn{35i}k{%vH(B=IJpgID;E(TO_Q>&p;{ zJ+YxcgR+vNg{FlMP{tXa=|~QzdHrsWr18IxIkn5t+uRsU-NeoFAp6jsSrgQ1|DJA~ zTS|*xD6dBKaR|#pU^VSU0a;pNTLaDo)a~_1#>hgEU`YJ>{nSQ)pDIw?bk6_iB``>Nq{6ze~F#smPAw14$D*q+4UQ5nSEPJo@9oS{mZZ`%g9GNklpN@m45l zm33yodn9Y5aw?`KsW#>CDP-zv$+&69OUx140M__k;&|U42kOX%%MefRJ-I%9(s+T& zt@blfh$gjP@B|C;h;L;HGx?yuhf`Fvtnt%H!_W7Fq*p;-e~i%g-HqW-2-?;yLz4-3 zvTFezx6HS%iclHvM*|6<>?(ifP4m;H{7M5Qd~1ZsuL=mXrM zrdZtXee0WQzxOBZ32n$e*n~$JfrAQ8a2YQ*y~X7_jZoSLx^r1>^J_4Xb27xORAB+s zFd$-HZ(SYw1z9W%Y?H2oqkbSygRW81P3=N=l&3)0joYg#Bjw;U%e_axS?(xOB6>OF z_c0ZV0*L$)o%bB)ie%{*Rim8eR50^Z{6`5HoMM3@1`Gt5lo~{M&(0&qK^ZCMAmD{vz*GB+Du4l zxkkgsXB@zn@ORzZ#VXHNFO1{Xqp|;W{KEGS7D9nXr!DBa`m6~3kz`x{)UX?tzY5&1 z1ZM|!uxJAk<}+3j>|7v&tM=daXZ%s{+uGCVoyS@|v2Ga`EPi@TGI+b5fQ1Tt5NkS| z%wM*gdfN+;?>FJaR7Ytb6+t7+=PD{2BxcQ2!8!aJYcMkuG%^=p%)+cEhV{8*RQHL_ zlb^qnR9IfG=d~_*WI21Tnn6`cr|MRX#GCP?+ptPtJ;?M82&Y?SjYQ>>l6$-QnvT@%k~Pn zZUL`gX71vJ!Y;U~+ojV!Up;6gq2TbY*r^%z{7{JqV z!{c1)d;WPQ61n`@d_=nx5_q`5R{s&|X!@~cAIU~1b+UZW%y*Sr4Hm}LN6WEGGV)7x zueq%OiKC^7uSAkRmnDo0+$vkE zw(mL+ke+xvcF>YbyUjMBcMCyH7{w=uR*w za#%Nu9^A)K??Jf=lTw{;y{ujpOO)}F!H7gBT~wgfZ^fSIMW&}Wn7B^QQ{Ws2@TtVt?zo9_ zWnjg9XcVdm6+*s%aPt#UEz=8A800d)$J=Q~Ps?lv=c5FZD+%vX336UlldPt=fO;qw zyJssmxSoyWyVNJf(8-dw9qQk_}HjW*N>*Qq9%=odgdy_ z@2Lrm*qjzO=VyNA`= z#h6D&7xf_w^3e$Ouv3sZ<}Qrvfckw`1(^(*9_G?FnjA`+4k!xZ*O6cHRXev@mVw3i%J9HLkj# zJg+ZttT#L8BiNKxhumq=bX_3)?zIyIeGZb4ifqMG+APzIE}}l&SW?Qt81p`btyOY&G+xeAFn?H!3fKm6xVeyQ>{3w4l|Pp zPvzdvb-onZ$`c=lXH$7#%;ndV%|fTozo^m%o&obciBH<41O})&zD@QiP-B}#UX>l- zs-cMcLh%>w+MXcvx)(l>m!K+cJqPyTTkmkL(cD+oWWTb6xAuAkZ$L(jPpENkG(K12 z3lC}nJ&(k803IV31`?0^99EMkq?gtAqlpcGpU~?D`u#Csw!d@qXM~1-U-i!7xlMNU zzIH1)bfDrfd*!e!yWH--AS8MUs%zL!^Cz7{!7 z26VPvZjA*hw&(mtekpJ30vORG^N=aqGdaTaRPN*l~dfSwwZS?`(=rEb@HCt-cziUD3dPtwr ziie-+3AOUJLUMnTqt(;d>363{;}3JJKVbk2;&HEAg03V7GL;pMnN?C~!|Ik^QkuKf*M(tCz44phL)_zyEKvLc(^ zrnmlaF+;V916F_Fk2R$WmTt-)_!zzg2o?(#>xX+)FmcVqEhySLtP)q`{(c-|=Z^AA zEN63o?hIo8K90RwDebC8L)mUrOt<9^k@eyKW915R!ZkxJic-x=%Iq_vc=;3i483Pl z*8Xu$3FPxrcG{~@GltUy~H?Spb{VO+=!Yz zJMS#*=waCt!Tb#^5F`s~hvgYg!%rS<`6wLUW4+)2vtdNFO!YJ(j4Gn|PiS2Nu+$ox zQ!^zYyeK&;bx%gaWr~lbO+&4iMe)j|x+eN;Q}sw~O`f;=idO`FykOfqDr=9tVo`0= z7mOcGZI45IQICKfZnhg~vEzWO4>8s;zCS~u^Bw^1FMTrrPsbfb5 z{VK|#n+anD`nx^|K|bsAqG$am0moNVugjC{pmc|JtkpaJyBm#V2q0{>SYrXYobN#Q zwEshM+_tysy#^#j7{CEw^;G*!X?=B<8H*nn`fw1KJ8`)CSQKJJXA|Y5ldDuMqEu?A zz>RwTQylQ&Z^)oaMhHHEG738A1@~e6AUU8}Ju!hns(w+0j8l|Oj@6_t;dicbpYx!s zIAlyoWLBtP3kuC&GtCaBtzPI^WX_kf?~-knri_9uwVAkQ3vtL^{h;o zh|?W(Sbr<%l2lic%0t?N; z3}S<;c9wx|GKXHf{$k`Vp1JT9lzq0^BdYIQ<7Rxv6iuODD`>U8YR5Qt#i`w7B z!hL>CO*jb5?QlrL&Q1`bB4>&G@tmq;?Tc$QFT+E24v_YM0Ph!Obqz`P`kM_A8R5-l zz+MKkLSe{be*b=TEPJBuWa!rq9}U(e5QA&te&&aZBrRp-zN*{(uHY+8Sf}=(z%r5D zLL_3esTZM8r6i_msmj{8o~e9o9CjozZ2B6$q&m7jRW_jhOM9DneDo|WW_{S&-J)C9 zp)9-KLig#$j|9AH@J%`VR_d3tGt8GRG!X%gT@CVNcx$$OkXL0U*Hm&4DLSL(*8l? z5erbgEh>OH9ir9oq$J@kES(bT!3HoiHl~|KhG6xl3w;2>oS1~ksixDcgEm ztep}+6EuIB6VkgfwXIr8(Zk=RSq`<|pGnr?A zII}Q|c`@!C5;~24Dz}$ZCk$A#@t=f8VuS5SW{JC)spdX#d~E6i;5NDIq-C4!I?)41 zoUG&R%UdNn`lw~N5lkw|=c~GNX{g*QV=oKs$luAQ{SZDl7Bta8vTZPJQufw=lMWBLOM>~oBn$_SfUr?_=8aLPl!1-_ zbg9DdX!P5{@eAFvigig+F(gM}bWeOGzXf;OJPKhvD4pO(G4>r!Za1y_qV1Sv>Q5|V zb5;@to+LNd2O~EzT4K=5M^!a|aqvG-e!Mh8iZ1yi(E*<5!cug1v9aJp5S<+<7&zRx z%;&G?4|0im9;iBZkdP)qE`F}19w_J&o|f6M?Aba$B=&6jLqS!AkrdhRcPPGm?$*jD zbIH_w1mHHDqI_d1&yUI8^rBrTd8~I?0EfjEL8Y2m$rb@HrKUeLOl;=a)izS3`OOAx zf*rr>62%F=q$M2HvTE9=4tB|cvz}F}woBQ8daH=G9@cQe5Ary3Zt(18?)~)3QJ}7Z< zQnwn?{v&VmtM0->Dj7CU{|xMuwJpk>g#DlikXXqV{46>_Y{o{Y)G~fh>8SW-3AJo8 z;t7$1A#$ujgysRloqh11u;375l|}h}*G*Np)o%#>n+n$~?$(-}<@my}<~){lP*E|X z@kOKUru|=@E~#p{YO%OiiUvE-l-_kiSD!M45K28_)0E`jky{_X_;k1{t?JC8CPCaR zMam=+ehs%YQ8=yGNuF(%R9dL>YRy^d{Xv><+^4qFro&Xm6)K?BrDkyPa59Mvo*_rY zbffyRdJjMXwmOrnXw+h;1Y%B^7n|GjvRt4Yn1DI3t>SD`P7yfd1G z5zj#AQ?tjtbS27k(x)*gHs26Q{IwnS*&Up{n(vr99DH@vW!Lqg|}1J>oxZv&Yxl&Q^Qsd=hHqCm={E2weEoYW_)$|Tnn*JFT^X-;jR~k@ zbRec$%q_d7&ler9q1h)79H)nM6nf)fr9G*avh;1t=sT&lYlW*aSPfF@RXkyDg&%0A zyNgRmj0TBTB&c#jcO|+XB1C^KEanbYMwpefXajW~N<6l4toeY;9?Gz9w&7}mgSVYu zJ>|LGlo70F#doLRYg)~_!;Vw!O}WB2O!+1B@#Dn4XV5n*!=VqiR`5$suDMumnsTV~ zi2XqEW6l}=osT`KF_6&xHH#U0m&-AlA-eTZaEW^q+sv@y@6QIFAycAR{7UJ`XePU0 zY0sl2{SVX(YGq)C3i6I0e1j7x(Auv!um(O0m!S{?oD%7bH&eK{lvK4fI*@k8(MnLs70xSNX#!FT5%k(}MCiMT&`MtwdzR=;XL~ zx10A_a=!^J-c532kj}i;sW>YH1S=S9p`Ru;?{6+4%cf~DslnkNvgzoSd^9-}Tm&J=`p?j=WHzS-J_vJ;vlomP36uIY zZ95W5ai|sr&HZNo$Ml{j77f5RjPm9I)pEB;D&|{fki!Gl!-`rP_xO0zbds!BHQwnB znlX`btTj*Vlf&C;`Lkv+cdT>2dBk%5H^`FJb!Uc&{$fZfy9&zBB(-&?Hb$rqP08@5 zC9^Mlo9E4Lv?4_f7f^#B$d#1d@hUvQFr_~cLqk8d0Ne}C_*v)RLf+9-uDh5^03|Ql z!5kg2?-1A|%rp|C8giOyTb*eN>z6ay+thr|Y=38SoF;dP0KE{7Hu!`SpJ<~q@uoAgCejLj?3 zFN6g^Y+#vT8xh3$y0Yo&xg)QvtZpJb(1ajlaWK6yW`H9hyFcHPCb)xdoKopL@oj$1 zD~cxD8(T}r^QQ0;eR+p9Qt*=3w(Vwaf1;RTuF@#x#`VU^%2rrRjN%Tpht*wXbcsmc z_a7JU;egb}It<3H;uwv*Xv0Zb4l^*l?}4|Q-(p!3B#oO;LJ@wJm_(VRBb)?AO-Z6t zqZtx^-EUBgRVKy3Z&i5O+;rzOTI_C?-DeG}F>U27^%BH8pZ;yCvdlO=c$gIRsDjGb zKo0j|-U;jKQC$I-8|P=#z9~_jx+p4Do7}IOAMh$NZeeK+bkmWCO>{AoyWfWOD^NH{ zamFRUZG=~fwN;t8n_gw3P{o!Y0eL_m4uRM9fN zKPHhs%9+T0!)AEU9%@S3+rWUmWFSv*M4|D|uHsY4paX~WpTe9}0{y3<-862b%Nmf% z{`{;C&30+8w+2~BQ!~GKbm^+(Gz9(58?Z%#V(xAq_p-gZ(TIkB4{?HET9AJd%%pEA zRPZV;BusxL4WH&qQ+2-J(2#kOhlgJ}Lb38ev-vJvTc@(wz-yKp25XdRnmi2eY&hI~ zKc2wy_PmqmXn&a~wPbNQSba4-5bRA{4Hv(W?ev#AY6#)00D|hS<)UM{yKaaK z&kCb&O2`Oh#ZKw2bTt%hKnJhG@Ra!8iGHdUJC{!rS&X4?jVC@^)+l~Ayk4Kycd~}T zUE74z3jW=+Xzc6&6Xu07l0z?w5wV8K@X81qHlh1y@W?WETXD1u5xnj2OyUT<9|;8} z9ht}Nr%1tTUY{2sNMgpRu|2qJ+HQyd9fdXK`mVjM(88vrr?c&~@clRoyaTP_+-;nk zt*$0oY0oMyG`!8xGBNd)IB0DpN%h;sZ4|Xd_jSD96NQ}cqL%AkoZ$Ab1}k{Kcs!rX zEwk3FNk{UVs^{=XZEQ|6u8VPk3ulp@xdX&Zk2*)=lQO?5G!aNOF!_XExLAZa%1c7Y z_Jnq~$&0fw)eTSKqTJx#Nx=9scUbXSuo<{I-eU&PM%?_O&Xxy|w?B>7AJ@f3@&A#B zmzkTkT$Sj~CMaZ>SG9G-65R}a#kFnG z1>q+6*=Eh{6w}kl>h>$Ac%&|^ax3Y0N?lDF49wIN%~wY`*+d*fI5dM33p9{cCs|AO z6&3bWr82cKhTNNw-@-2y9P+|M!z_r^qAEJ6Vsvx>Pf&&eM`v18AmF>OtjRp||LSCOEy-rPh`?Hx_ z0f9eJMbq8vCQI_oYvsS$%x^qdj8s`|kpIo*0h0394Xg?Q!!|d)4EN0mLUOKlkG3vm zdTH1$vcjz9D@Ysl)8d%wj(XjIqOGX1It>SQ(FVOHK%PEf9lkou+A+m!yo7(*b_z=EPwy1vHveDM2k z`DW^3ekw4}(LBmtj5*4o{WM{-KQHv9V!jmPd#rTmy=p}ik(k>1=ET~lx~Anl2~ zN9xl*{fw6s4#!!C%I=DmTrwe*n7k%PPTJ4#!H^ZGj;+nOi zmmnuw+a8K$`bGqyh~G>LD2N)?Jm3YPP}+MI+S&fq^q#U(6bU#HA@p;B{zD*zS4cnI zkVS7|q!CgkIP-Y8d3af$3iRrC{xIwv{)mKhUp>6Z1K7q>P*C`BSwQ3X*kzgP{WL7< zfF5E(05ANnx%u3Ae?4b~1fIH;1L`TOg(doB(Xr_`oMEC}>`8q-#e{(Rq)boi=TT)F zUQaVdj}AC1IF}p`On}x5=ZkMZLkH#WA&+mL4#u8EPN5ZE2vY0w)!<{#jksyp@{2MN zra}&V7!rp!@TuW1l1E^6jovj0Pniq;PT%a7LqJ;tRX=L?G$_$Ij4OB;7vbD)mzfah zU;~Q@OJG!~t6AX6h8#MusZZYE+$!_D=Av(DiqjpQ76g**DON^$D{^94o0oUh^BNj}AH+?A+auylHwVm2fdNlX8AM#De?3j-a?y58pm9CCNF# z>i&ESL+s)$GH|>%o0%7Aw^XNSXFwQY;uQRL*DG}KcN=_h5eUpv8&F(v_!FS`158#M zWfKwe3^9D)R11ca<=6S8>tgCB*OWSD4(q3kpz%wFIV}R^NkY^hB8ZoNQsgUnEKLa5faHl0U@&EDkoq=$+!P=`w?_Km3L=U1%l!&rw zM2{YwAc&smHBq8lL68-MD66gLy+nz!1iQNEon^nrd(Qd(@BWzko_pq+Yp$86^4RAQ zb5pAOWO&y(Z&kpPM?|x+G*dxD0>Gh|7RZEM8n}0RJvY1Or~h?kq=mOw*`mlN$D`ns zqt!4Go3r82y+5i(j@eJr(pB6iMhjh6*Y4saeq+dv$Xs)$n9j!yG?kxIa)Z8$^(O2y zs=oDqguB@aE)8htYyx{LsbE=~MXQ;*f%+-$P$lzTGgi#M3t%;Ti0T(quZLTSi$HCzwfI)m`dJ8 z)D>h_SwU})e~&o>ukKMkf9invPlly+=OG9H8E;Av0J`klClYQot ziHV8-d2Nnd5wQE?&F@J;0#@(VcoMJQvGB?tktJXNEX4Y<#+FC8`5$NEUq4Cp`;X&u zC9TKfj%cu!=&Oh^`o7K<6FY-tyQK!n3 z)|HBW(hhm3ecW~ithQYEcD>iKTIQlRht_T*pg?8ehNb;xe>d9m=|U|P{OWj@GtT*! zpQ0{~yb?WK^J6s!vL82mPoq+Tw5LO49$E091(UOfUzc8fc%x09l9QPf!Cs}pUZwe~ zG_+eBsAh1`*KJ{_*ml;4gp?-SuD2{!|I2ukSAHY)7Z4DDnQ{YzZY)m8kE!Wd{3xS6 z+AX)Y`v7Ngm6VcN+4o7~-Nw^(u#kTp{1x-X4MGAU_qa(O(-M6k?YJ7OJ~Tm%KnRi-wL#~?ZlVwe zgQwMn)=QxaC5dcqBRI1Bo$p=WS<1U)(|qYd2vGEpup^RfCtpKD1gbd0Vf|2Z-$xlX zuDIi0s6N@B4y`}&HXF|m)4I-vf3(e!nJIet)~qm=8`;Dc;y$+uN$=;Pe#mdrEFb&{ zXURRj%DuvmZ!x_&2(S2JpL5~EI70(3$nu8&a(n$qg`m z|F6HB*t@512F1y#_6hZSP#uMct+BOIeEnidqPhCYi16mO&w&H(cwCJ$b>`2cVFs+e z9bV^CG3F4B8!~-@2h73b%feaRTDfS`*W5N#E=JrTY_CG7gpthxBHoA>Cz;cCY3PB{ zNTiH-cc77zfnkyg^s!8{wa`=rzk$iEA}_dMKI;vH@ac`wIew|H@azJ@0KY-zT&(se zRo*(oTh{tR?v@(dqCYX=hB0ABNem`)fF1G1$Y#lNxe+4U=Tvo_t- z=>)3UXD>y=u-@+1$N?47$OzZLEx|qt<-msejDaf{pV~4+4;bHG&QfpAmGX@~zG0!E zr}t4>7vNn{q)s>yUdKY9d+MYv^>zvc`(B{Q5s}RS)l?GvMd8~pqQ$t)!ro#bbcJfL z;k!XG6D|-*pkd*v+DM;tbI%#SCNa?*g^=&ehX?Y`wGUIjT9z1+Rngg*77%`->FD4| zCSy*C_wbk+>6yP~Sj^+2UMxn?q-8?I%D0RzWBm-Xv5Rb^&WSjY@-8{#4qH8CS3O5M zr63bK%Z9?yr2h7rZbn17lAdL!LC6(2LI^%m_^c8#aucv1l{{QrRef6)|2I8A@%T-g zpjMh~+MO3YW4~n!TCaKe;wLtFVhG51v4!?s+FjjG1iy6@P)}wU7~xup;A8!zuk@Jd zLo~^A%S8a#zxnhxe+L?TXlS5xF2VtX=R-XvBN~y)aJa;N)P%$9S&*83Ue_#>)x@fZJcm7i? zmP2EVaDLv9oeLFGDveAVC$|dX$BP9yH-u~BbO##JV01X^lMZx~GF7eMNm%J8-bX*P zWpn00A7xb!+dbRiQGdAsvlHL<_NupvIm=fm?3#ISM)>XgSve$U>su0G0jT%evIHB3 zUILs3rts}v7a`MT+&gMc>Y;tSB=L1R7$GS&d+%7BAG=*RUpP3v?0dwPu9M#tZ?KAT0uc3nUeJH>{6-4~_DiAYXiDGk|K zhug2CW0%@yV>8p=RYnB2nuhUa;Dxt_Dq=~OQc19G|8E~C9GT916$KG>&0ppT-h53_42X#tmeP2LD`{w`sjHu4BX&6*{e%v9lIedWwdPHQPpN#y*z zSzg%mWme-mO4gv|FjKS>U~8ff=Js0jc?y(u;UzXE`vM~R>esJI10zA8v|T7If8F&& z#nSTrxqTI@FAgij+m zCS(;ydU01YT;UH2NCmvJHIf8FW#}0U)d68W~dsKMOGY@=CuffO^RjK zq7`^H^J0<$L`wDV`>RXyH8cI|zCcP%Yrjg1(Ovx1lfaqV!hifyizPoCJYv{d_L}Mp zC9A3JFu&fx3kq8`FgG9}g@z2WtKY{p|IxNo_sCoi86@eo8T|}u^Gm((Je&Se6}dj- zXsfgLss@W4PZG$g$u<7VzsXs9E(rL3T#NxR;p0o0FcpT%wK#1@oQQ9G(bpcoE;X!T zp?eEbz{`P`zqagf9~d83%rARPw=t=)h%Axrq3$X{hS6j&D$_05zIX6+3uGibp*;t<*iPIbYI)$(IKnIA$N8{g~@E#|)R2fc3aUwN_UZP%5UpY!6lNcjB<+LOS83E$j9?VlzZP?9?W{K{jlEVodX9H^W+d z(zb2SzoJ=4P2KH22Y(fSp`u) z+U(t($r!Hequ(4EHW?DW>ut%{jP4W`EoXo3HVFVRs5p0Ywo$%}Pm7yky$a8ILg04y zh;70f_jd55Y+3yIV_Sx_CdH4Ws?d>U$#=E}8)3WAwq#j`_Qu6Qq7UxB_O=Ca#a?=J+(KUDVQL9&AUD4VJfs3HTxov+OKg! z+y*{2`ur>rIcrl3D4}vD8|QA3tnPpbokoL~XPRQ>z{#n7!VYKi;KIj>)%iyoTCJIJ zXS^H`gSV6%o(Qx;yoR?b9^=&G>GgDpx8z0QCQtc9CY4~bWe@MNn`uP2RBykO;OmM>^ zLl*0l%YjZ>?K2-AiM_y0R<{{H2HnTUM(OD^^ls*Nx$>!|fcy3dB5Sv@=SK+FA zZc0jzJ{@CfPie?E-j5da82#{>eBA))uf^+Y27I|**xtCfCT<%qfyel zKs7Po7Hgd*w) zF6#MLu;e$SgXgrkF=?dP%_*_*#p1u!^QMg6D;m=jrBi=c=WGWPI}+#r^33tf=yQNR z&(q*{h%(R)kb2ViPmY)9sy0wUxVh=K={ozW3Q~~AR97BJC5YVISZEA zoKv>=5PPit98>Bt23tqPRG|r)&&!{yJCPA*8u;bzV9BNG;-*x);S{tg{1HeDG*$y82~mOp>UJxXeYjI=`)07uj5W z#z=E)c_NX1>J=-Zo4#kHL_h8@-KR$EUirk%Q9bFHa&C6CY|VA>NX=+bnAT+Z`qU;| zh$LP#zq6P)b4|0!R6l94^u#DFcPH48Myx}BBtW>d%|gs5`|3TFNUnW_ReBKb;!XKp z^Y8oTaigHZ3Y>b6hvcG%ZQ0V4i&Dw%msPwt=HAxlBJ5%!QXuy# z`U-+*7A_?K2S2<(Pd>1@`tl*>jTZJ@*sp3wz56E}po9*_gc#~^0cZhT(iGSgmJRS@ zE3BggsybZG!3hVN?33qiJA7JvA*V_toKYUrF$P#m#M|CI%9%Z3^c)>@^eEgOnUBuF zb#XdZ+Qd!SoV!nGzJ}6th&`BKpVIT9Ju^Sx7|zwkCgjL{FaFqGfBi+;jAKHbfQq#$ z&()4Po(#}i*!%Ev;exBx2d(IHlgsH5!0tp^osp4% z+a4$H6%P8M+S*iR@?Sn8iZOS=55siLBrrJif7Vx33CmY=hRSj@YSvy)aPRRM)0-;x zw)%BOZfyZdmb8~~p9A1(B`|yt<)UG{cN9h@;j1^jnP0+$X1UuO)eDKX1FOx8e;e94 zpo!NsVsSD>Kfsh%#@_PDT~jldYYN)h6&vx9VkoMl48svQP&itjo^}u=g7=WfZ;v)* z;LP|iftDA9xHOie6AeB1{dtZRfx5S+I5@=!LN17G#9gG|ZhV3r=WDSn*4Y>qjL;NQ z95>3Shm(RBOB)*K!rD;PGH>@$KPFTB1g_|XC z_Y(|xQSpOotO7WnxQQeD@IRI2K2Pao=cq0o6e-pVr^{Q6c}gtu3moi35}9UIu&X#z zAk@?{bxZG^7l|rA!rDY81XgT2n$-+-KdIdza-NTz4yJH23Mr_>yV$J%6!{~IaN?b1 zEE4{}$`|5-ulKb$2bbT$0c4^BtadPtzm7lnEINVkE6g@`;8W9oV?;a1J@t6Z4?RJ6 zQ~Ji27i8j=g!5`L{IiUEv4re4(jm2Ekai3)^YYisHgC82wTxb5ut|-Qu2t2cP9Xo0 z9gcD|qmqq0?{HptWA!_F9-f|WP-Y+~riChAuTK6*mUC--+Hw9TugS;jq)8*Dw3%90 zk+4TCcybu{4Y%Kp6dWtO57GG^nsyN`Kx9uGUs!{eKFyXU!!gwLXKNW}rnP*loEKz{ zjOB#W{RknFSnffpemn)2#vb4IkEn*Qh59g3MHGl1_E2u>@M4*wBV)Pb`=Of^&=SXw z0QumaCI(8Ck;<5`WcGeGfu6+fIZze5J4D`a*r`wUPvec(xt<)aTnN%?I_;@6slE5x zd}m%NT7m|ezdtIni8RSyk7pfu(sxN9 zX1QaC-YNhqY<7oy^KV;_N~4RP-=opy3n3#vXlGQWMPfWr=qb=y)Sjqo#RAxv_lRbS zXSO4J53$>;&@exQwloz)*VnS`6YVRapO0C~-00m3c+=yEYwem_`TMk;AC!c2*tU1* z>yfctNhg|THMGg;a@%$^v|{PXACRQDNi_GLdA#83A@84C<6Lav44%1mN*jpO0oB9> z4XI@l=y+SA;=J8Rai@GTzkZrZ0?c3C^!AL0e2L3d>}^V-4(#?!19d;!=BwK8Z^N}!dA^P=zoii;6FP6cVx(KR9!_j zRtJQ;Yk9~)TUGj$tT9zlsDT@=p6c&7>RRej#cz(s>9!W$a^LXFhzPxpXuEuOU0rcS z73#N!B0KB}_Cy}fy{2Xh`9gJT?5*>pZ6xcv1hyV2He=`MmjEKEOE*V;-@s05`ceVy z7qF@~rGrjXX|uvX;t-csA2BRRbE_fmB!x@tvBz7#))W`&_b1*}+vu0U9P8b_mc{Q% zal#WK!p*|+Q!M&F02hi}JpbE+SZYfex_!fQ!6$KNpZT4FW0pE)xpv7SdNf~_KKT0K z%Q{d7PsZkK%~K*5;MNTpzMItx$d5@?BD_*Ih!t<8b)LtLMgQ^?XVin}k$h47!Vn^^ z+rTaoH1TM3Qe9Juf9;#17^|^-cu`0<+Hw?}QT9^Nkm1KHm@jRYn^_52$TZud#GjlH zyTWT1L11r~ur(=F6>wD>BI3hKn-L2ZTinvsRrRNW!b)3xvwH7u=amsjOn0Scy0kpI z$Pa_yEB2B!dOC_O`u8=7cyjD6Wn#nsSS(>v^eHQkr0B5$`8l?)AcRC?*IV+AEmz4C zxqG*no@F5k=kOqMY0CiWMz;fM&`&31xFwmYrl#iqH?)Z=MBu7WhZ$(G$}2{NS#v+U zFvKOYzDz5)^^E&YedQOWCt%n4;@%;xiM&aCKRY6YxwHbZ8^!S_&4wtdL=9`HGmKcg z#_C1#^ZuErp+PECMIwG@=*cODhLZCEzidG7_ydljLtV%2go0R?)^lf2VebHL!!cBI zoV+uhhc{d@-v{2cn!J@DcUOTK!PHQ=}DlsOW_Ctu20;V>NbrE zokn$0si$xw^1|qJwMp}%7h!^y1$8+2r;a|usAlPVo5(&D8nvv2_Ym9ZGd zR^_G$^&u)Tw_!`+lTMlnjdNzKkAT{047Vcpakz_BeL&a1IVwi^|0z*uCUNZNHeae|6dDjQ$;+J{Q&p>xj-2q z(^>}e^TnK?yttULM{RBjpUS5beZiQ7mD1)v~_ zJ&CD}ZyIeZwQCNjvLo{wom}(GiLp!yn#(cCez>1mcwtaVIjG<%^*d=_amS*B;U_W& zL?wz{qIof9Wa+kUZYk>mZ+_Q5@oWNMS#W|6r|E4tLaxt8{@2#!O6k8OJ_@gva9|-= z+7LwrG>fQL#rK&g8-`N7*KRJIK@c>76I-Cvc_0T8rP5sz8MYK?(4E*#P~$i>&7&T*@pFX@g9#q7>R6vj@)e~x+2g!z-JEXU+#uOck~tu4pYZB8 zW*@U3`-U|KD-4T7@uOQ-HA091HY>qKgenub!{vH^tF8wG1@Qp**|=#E2i!H(^rs`K z2TKr6FN-w3v9a+&Gw3h6UAkth;kwZL+~YwxDUdmB4sIs)#oX5)MTzc&(tzE<8 z;;%+JA>UuQC_?exvH=)Q?Gy%P{WkcA@K!eBNoFQ&HwOY1H+@k>z5A3~==-1(o=|nFOMT3yP_@D9ggxI&9&}9eGFFra*|K7t=a2N zvZT(K+w_Nq7ZHujN|ELAZjECrTpUa$a%c@n9Q)6 z^O0IeAm?J9yYejW4!$htf*eP(qr_0X%MpUCPrNBH z)cpXOdO#=qlH&7JyJwh(Pj9m1mYQbeKz;CYYmBEkqjyBLY3;KO)VC^a|3qE(!h6S3 zv!zZPiuqm;H%+E_?xia=KBQiEP`s&fB42{wKPS{F298T>nr5Jl(=0Q1Y3x8mf#*xl zWy$hWhsq~wlm^%wQLK0>GNiE(ZQm|~ckXSitClAr zuIj7%hDWDJfeMerQx^P$f+he)2Ro5gG-N)GV`O9XCSz6$J5j3e@0M5c zHd z4hRo;A4KG85=>q1mXLy)8*S`o?=8O<`J%vf^o8iMHgitzDD^*|qM@Z-i7eLr#agx- zA)hfo*dguj2#(=doZ`ktQvFLXfzLVYG1O%9)<#G8}LxZ$}Vm`gv!|1p8rD1aS z_d^amwXH<6(}(nfSdt>lNmcc|59#{;e7F4YRV#BDqZr5+EbwTsKa{Hm_3^$~z^qg` zTGQcm`0JU5`}6g#F#rlE)X9}v0dq{vOry>>Fsx4bfwH+EAVAY-zYC-Kn|~?n(X>hD zQS>U=q8WEX(O1~x@rLK?r7s~wE`R{hP)0jnmNte|NvO5jDeHZgi{;1~DF_;MQd00T z(bf!h{_w>XF1|5~r9473vy260du-2}76S7eE~yFe1#9H$WrMUk+hez311#(%zZGsE zq;5He8)dN$bUy;SlA%wK@T7o!&XX3VBl|74Bv0s(4j6;T0(A#`TpjT;Ulo_aCue^8 ziL`bCzh)4}8b5 zyr{$Kq`ozB3##bF0Cdu8MCrq-kWDkR{W;{L0OQHl!sDftE=@M%ZsSs?AvI*d_uuSd za!)yq#>&KPW|4pO-_5BSL;mi@s@L~J@vB#@TYbgogw0}`j@Oa7p6wm)=Z?GTTmjej zQ@NmmkVc0`EH-wIg*HkzF#VvtI@$YBmEQsgmCpDZ1ME5s?I4|$Wh@a&dBL1}a95$L zvz^?v0swz&l0SM>4?A4n>1yo%CmGDQ#|WbSTR;)I*N6!_Xw7ehj^cN~*C(BR?*AMW?lZQ3WKQU-XsV6inH`QwwxfLG`co7uT`8RjvoL!k!d=KJ_3%&%zHKcMpE{Cmeco=W@? zR%t6}!S%>{N=sPy|jZhY_>AlO^NH$;xz0@%;I7B6#)o_Rc|L z3?|x#{8|FqZ1S~G9ms1@U7eT2qCm=WlMayE^D7nQaP3aV^G-A1G=EKxk`qGXfz#>Y z1U06p6S|#wg~>e58YUby3!zE;U_OI__fz+^o}4)S7exg55bj9x0Hbfeo68!4 zS5W?+Ly!VTPA5mN>8c1O>uqwL8n0wiT!pNwi8XJnKZB}-o6!}=ARgx1Pl5`s74>yo zpmoV8Q{KP2hWEhe9qoY9hOZYZoZf)ogyZaX>o4qNT~S{<|f)cSjnY zy!dwRVQ{?SVCBq0JlTx@FVEYJ8Q2E$`e5iOS?6GeV2#_Bfskn(gU`lrkB^ALhdVgk zKD$mIaJWrhGXp+*(wBVSr^xbsBZ2(8jbfR@6h2!_@p%u9w0vS)C|nvG2*g>*q0b>H zLmsURGps%jqe)l|Hb*F_h9T7SI^EL*mbvfeXDJy@UkF(z(+-&wH8(TWKXU!OFqJs( zSO40@g=p!FLeJ_&^xKS#*NBFP^9`;oD^5Q1b?TW_milIcjcz1e_9=0gKqaA|S+Xt| zJrOC}4$Qf~YvWxVtoQy6iP{Yj zyQq$@kX09><9_(+hjOYF%=2Hrx;f8fca2BhBSK#BLp7Sqhj`gC;1fR5X@N+7Mp9WZK$m8;(kyCCFtgZLvx2m}-n!(L6CbSbHw2gv z+-FTV`L_81MJ7WQ!y3&0mZgEqtbR}@;;t@$?XB;KIxa9+1Pz`t_@Qg~MMShzMu501 zJ~k`2-=UL|*ilDc_C+IwbpZ!7+Kvv^M!Rqp1R%dnjru)&f|=mas`2W0GMufzY^VsS zodX}i^o(CbJw3l6jV50rG$&mkYI}FC-U#*J7hVq|VvN=-@Y~t`f#JADUErv%AeF3# z9~Pi!bmnCI`&s3ugnv<^cryMP&A=|_N{U$o#bc=++J^iTO7e(P=NA>YDsy(wShLoH z_s+eTrUFYWZcqdsHrfbZJ)zrB8A zR}(lSyD@;um-rUZG>g2$Do~lSisH<ie*-0DG{%+f3HgaeYgrG;c$2!ZyyK8S6PG|A31pZ-*zs|P+MOX(>fykBt*a=~nRRVyG+PES^{yAE^ahZcpYg!T-Iw673JCYg=qXCq_%;M_)~s45yDpyPA%mVBV3h$ zRMqeBy%f*>paaVOa1=t1>fU0@-A@}?uoEYE)@ixU3-O`S-#j~Fl(x3U2N_zpwEV;h z*W{w+)9Ef(N_o=KaNlc9&E!=hWG^B$)pif)%^wv28V-xl0f(%kxw3#`Ok3RG+l+-R z5Ol_<_-1S#^{HJk`i6W#>3FTWsux%YDjM|1?JjS$9;|C+H3V;$q6o+oDO$)8_i+eF zNW$hzoz4r&frQi(y2u>rMwp0oOh4TBZ{HC$1W4Fn{=GKnMwIm0(M~>D&tA)JvU|hg z9kf?TDNyKyP`qM@jstw#GXC->yelE4jRD@4IN)x}2(ov5Dz$}7&y54;iW?!C{geg= zhj=3_!a1+XLL8hD8r&`iaG>n_UH6nn!1bQQ3796l^GrF-c)hu8oI!4NT9a;6YRDY* zXLd4c%~%X_%Rtc`m4$SL+{RGQk(w}qx;q{ElY>M-o1vu|Qu}>C*W0MJL>tt6B{opp zQk6T$zZ|8_1afQFvc2yX8P)~gFT=Pa4RAfJAyYP~2H@P|I9CvR9VIg;%ShbwR^GyY z#}9U0*>czdfrJAS^Sx(sZV+itIl#V8Vm4@87N3<*0Xq$iqHn4{EvPe_)&)?$yRGFb zXx?J{cXQlEEyx!@Ju*mJ(K&M=Vg|c63BSbOZ^N+mhTKk+$`Ft$-Xr)I0%~AuRsixe z1^iQ)pW2z~*_z;IyS;^`EJYt##q1-(f?$;9u!Wq2ycB?T?7feVf3qh8_;h?v!sliBm>U+pfBx82ZOHk9`h#Ko_mCJyzb=0Cb=-N)NTGXc z{d1t#S{nM8HjPiWlioTcqD(2kO#$3MG@9uwuB)+*jQP=3av}V^{+WT3gP_8zDi5&^ ze%)vF)x@5ZUAD1k;b#>^%oT1KeDSFc6@!BpIm9Bhwgw)6p7c@3%@;BPUkU_^}0Zt@@ z2zssDAVNrw7lzQ9fEHrY<@ORApS3=V@H zWxCTpa_)X@80D9dNy|@pZF5+!^=7j$*dfD*-?(zZedp+dt&%X!m$aHblj}#+$47yd zSsvv-{oM6DeNnHD!I2)LaURs`RV9#H|4Uq(*9q5*8dGK68Exy>mngf~Y!$w9Ti)d1yE9dw9*&jzJ7{Uv>8;jP&5w?D|sM970D0`ma zyTmj-KRZ#PvBm(@i6SX3jo6}wVwHnlr#(Kl6iD>)`N2CBJ?4~Cx8=I-fCTeq;?cz# z2f-Kc(%*#*lCBcg(9`xDJMd$=rJ1T3?M`P;LVVcbY*2fvZFhbu{BwE)A{fMl^wQ9Hze^4 zAA}IycCz5YTAMUsZE)D)fAg|&a>cN)@bivVH!u(hh5bzgNxg3e&Mg?=kRr-W|#4goD;00C7>B zEg~dgV~;7ML;W_x?0)^iS^$QiOFsMawtnCmlgqQd5m`AbW9=(vR$oE*I~H5EH0TC? zw>1ASgE!HZ3E19 zr=9^a(&*#sFugVx+JdlyK%*Bg-e|2ez5vu&EC8T`co##aM6EAl5#E%?wWgH=y@O=N zF<)56Vkwm~)#W{K0F5cmo`|e7RekUoWe@JhAF!hNQZlE~i&74~@3nhIeuw#r4~P=0 zCQ{!&=u}#xs%;y#5YeI^(I?@`1p!0Q-pr}gt2G9sxu7@n2$7PpFe*2=;S|=Kq$h_Z z7}GbvRTb-*)@#Dp@Kl`RE*o3b*sc+^%HA4V1kPk+y-*;{Wb@}qmRW!1yZa|YF2^Rz zsK$4|fF!ZL#tUbYYO|z9zSgMRJ(drEU}mKk z<=M>`CWBLHeoVcOwcmP8rd}XHHB<0LLHD9dlOKsuV~n1=z^vSawUcKqhKZG;?TFr9 z{3crv3VbF6%vE^ss)n#3+q77xS{)8`B;`sztvqd)%GiJUOO)`&R2sW~V(u3*EOdF2 z!r)%X3M97VN?q=rnxbVlZJ!Bd2ieq{+2fbp?$`HSDVH-lM_11TrhZXoB?U({*iSf*LD1fnnh8>?kD5wS)=&8HHR;{j4NFzBf4CpNWy-Znm$w{B%&kt4VJjnp+I_A* z|o$QaYF23CdQ#Pjo4PGjDy9?8OiGlc}fsQ_VKEaP{XmrLoR+lG!HyloC z_FVL#F!#ca15~RiW%d_{e;~kT%7KB5{_2U)UCj_X?{#QqNj0Rc0+E9uFDUb$-2V)nkrXD`+1d;jW>tr%)YDE>8$ zh0a1TFCNI|`u-jt53lI6NNSfqrf)s%$JlJ1Jtc0_WGF4nR&XT?^&1uud$;r(b{oF~ zkSR*!snwA{fc+C5%nWjyaMW4`KfjQ!JdP6-h1SasKG!iD261{Lgv7YQ1s2LKJmbf- zytbl9K_2!7-v{l(Ht{(DwXgKIcN8Y}HdTklPwgl0LB<8SXMTIQv`;vY%yivu;v5%! zny$wgMVrZgctOlOy7gn-F-agme2n{X7cMcP|1t8xI$uDRr*B`aJIIUn(C-rVd4uYuxMYkKppY+H$g;QF!}QO%2Z)SUX^!E^Qq~T`Vk1WH-i; zppu z#fxYu_lt)jQr}Hm@c9ZtIN^Ecqy-m!)SG`lEU9*gMm;;-cFB9YJ@DFWDY9%oh$&z8 zEpmrFDE8>bqlJ%qyv%#hD+!1zd8zK?hKC{7u4%c(g>ObDJj7ka4$H`j(EGvIa z6sw9tc@uHrBp|x2S!^n&F(g1}FK~mEWV`kLsO%vLP^o81W0VWCvE>E-Bl?N7l2`UdEz_;+dpFsnm+R*6{oIwxj=ZizTP6{=9T&+hV|!kJ|#)p zxC0Hs!vt<1(XQRp$NcU(ZF4$I)5|Q2e4}9KE_YPWQXsbj=)hV0fc%t{nG~K_*(JMwFh0I07G;v;*Dl3u30*`@tPs^Kb+jw zcF8)rq#?m9dga|LZ7ib`gkRYab5=HZXoO7&@} zhr3zC?wJYEEnA__uF|vAnFuNRTU#? zYi|jBawH#yII0MoFvS_H$OI}sEVro*HqQEE^X+oe>vwKiv;f)(7#+}%0MR1IR@Pu6 zVj+wc-GwFHnBW~bQ@Jaa??-s~u|-7Smlj`oi@W0_G_KPp>>>T*4E+GQHlMX{YI+3Ql5>J zzKM0rSo?*%B#y<^>et*(^4UG*f2WgeqOT9w>-NX7*4Ea_%gdDm)zmIZ!)pN~^!am9 zT^+5G*nsFT-QDo!rBgu{qjX+8F?kb3Ci;@9&UGf4IbM^8T;YmBw{=%_;c%nnpkfIv zJvcN3D`wywdkK3*>Cv>ME`K%31v~9FKfGSLVcnfSYBhT1CJqW`A1xaJEen!9f_pH> z%T(zd_tQQEmXVZ9++#;buRMK(T!TIQa_{$4-Q4D+1@C+))JMqoFiE`0-qhmD>K6gI zQ5IbtkzV8bGd8aHUX-_%Bm|mv5{>W2Z_TJdvGm2RU3$H_bzfSP)%Zx$uJx{e`}%C} zyoX5bM?ikx?pp@Qc%`^>yGU3aEX4v4zyYh$7cz=*19rL z4QU=-&h1L14h}-);#*(8)L{Al_2Ij{SZ4FS<4JBW>0ce_g$iWZ1RGkm;divZiioI# z!R&u7dkuqA)HCP-B~N4#rm5_I^)YT z_S+UF-&n@jxZk{6pO zd-(DYZXt03az{?}LZjapo!OHlr^MsHdccF+QOuRku%UKLOC|-8*p&i;^rbM2f{TkQ zAR1^ssD5kdeqmx_665E$^W*KV+0@ijq&J1k9kIj`Nn5WB88Ojz39>5d@k(u*j8 z#8p}08?*A&D@=nou3UVV&=8VnEo*c*<6Dzy#-GTFS76%Pv;*udWMA9Kt2sC~b@)qX zDG(Yoo!{vi-UMa=(6mJ+WPd-!*2`V^Z!ORtOsRMc9_Z4@(T>M7I9rl{s(2&%fr(-U zUaa@k(||Og23U(GWK|1vzs7oEAfd5A*6sAuNz*nF9mu`@wsSS(bEuboV@S-|N|8ry zgZp@cJK|si?>&U^wXs?J9f5ytrUo$hU1fa}+IEK2On;;!9pjc+n4}6cG&Kd&Gcu!; z^7SU5xNE@pz{2V2DIgXhM-e=63At!msa|uU1GOVlN zLa_B~QOd0Of_Hll^1Ox!@7OQlmeuF~Y7zHnetwFw`Ti1E_rx0}N=UABMBaLM>dFAL zC!AP=cxCJMf0#-|1h8dkeYnnY7|OKy`#v!1rxzJ77?K#cv;O$emA;Z9QP6&~^xIhv z0=Ks5KX)?Ofc<_NDK!Yq%?}s^A1B=P-5?*yT2|-(j60?2%^*=z#(WIfgU@m)l^NHc z;+8_Sy`Lcrtb~`ic)y&j$vN+P&fL~M78$X(7rY%p&JsOn2(%vpv3m@iS^oBGsr+22 zwa>+hH<;&Shdurk@z3c^`6x9dE8p4y({m5hL>P^RZaOzyF10pSI{K0dqhr%t=ew-ci-Sp@Z=eJ%}m zY1PWCT9s#F`V*rRQCP%qq=qWh*_XSFxJ+2L`GYjgEs!0eeGhpfv+^!A;w;e08+M6<1z-tOuuU4PGbksKR}j1zhvC zJuXe7Q>4@M+6HOsrm09safa+(59<8xSn)wr%snLT<1S+}O0? zRjgh{AV$4<_T6FhAnoUU3_o zw`>Rt%5GJ%<(mKCHx=rh_ody#Rye8*ZNZOOH!p9;RfK|fS!r4L zS+lkV4UG-b{DYsEXn7)i?V7cl3?zX_A8ZH4ils}JVEUXHn6l)P*ynS=wg;eRx1Q+U zxqJAkNB@5P(W9yddiUy$zJ2;;wO$O9G=W)b#;h6m;>$1a+S{+;;fW7#D)EpVe;vN{ zqF?|1=-0m=25dC|ojPwYkp*Jvn(FHC-cvN%1m=RqhK3E}LUS|9%F5BMU0}3o0~;Sr zP)0DWlxvJvt^|gt#)ihw2-H&7U_1P)|KaC(0`u1oKPyud8jBhmgP*2p3=KrVI2*)o zF&60v1n1`FAIAJzVP8g&Z}3wjfir9E+O^?+kWcW_LfB}e!bW3M(6*~qtir;D3$bYN z!th+?FQ&b*r@XWrefthT_ik0;Ij&r_G7JyqlE5^!wx$LvS1%94dRFxgf5SeQ1A?DB z3gQQ5$0$Mi;CPF1s=T}+GwYlq1;(!q?b~mbXJCL_ zy=v7a(_hOQjJ{vF9GyCL+!Sx^ni{NJvm7NT!SXe$tmeKz;2+d~5c>7*7tRC0d3Np6 z6;<7;(4|Y4(7?zrX(VF?fVk;>2n{|K!KwQ$_{c-Gnv<`xZe=x9V8ilCBdam6NIp9TQaaq1Xu19d($d9&htMU(h? zo8~tg6M)S9RkrN5Uqo^2DJQEZy*K*#{+>Vc#}aOx&$Iclu(%2_%;WT z;0+MsP~7q+2N^9QdTo7eD5R{ZU4s>?R)hk1AYue>9_ZG&TbOe3_lwc6ese=WOT6GM z2A$e>3Wbrt9MHOK!c)-->_b3glM6@u0Bk!BB+1x_KDza5~Zz5L*cTdRSDX) zZO5y+v(rp{SV&9xG67f$}uogb?;JzPMtcUQ>V@w z>bhci_jwcjK<2l+nv{u4Rf#Z_fh_)(u9g=2j%=1-V8 zK^kY|_9HQL>!F*8)$J?WYsc?kew)8&KISf(8_pTQ91^@Ss8w;R@Qp6P92E3XAoj0X zy(*lag1KnX@e5AF>k9v%{Eyk1WQ;$)w(M_pw zROwvmO3lkvE9|Q-JRTM=?Pz6G8Agl&rYOoy`qJr0}f4}^DELgMvv*ypjd!N6zNeC9%x$Dk2XzznC zbkNWZ0)NAXr^EvjRghO;$_jof9T8zSFz`gpKY@_};k|J)mMvd~sxDRN-?x7#inoZz zfe9%18I$lQOUg<&{me~h3@R?!^rSf=KQYsiF8o=VRvU~&;m?hfZAepAYJOWmx$x5p zL0bjwCK{Yteh=RC^D}|?-E!_N@fn6GEV60<@KF{eKh-gDTNTHYMipjD+&pwEIoVj{ zu@U}VMUJHMj}tHHJebU|#Wm#mCCbGm)|eNn%WI8YaPE^BsLst+P)S<+*BzsZ|42~y z*KLc(Tv1&fHbR#QUvXTZ&Ue&%BUwIH^S90r5SKI<0K|Nm!a~#cl({acd-F^gqr@=k zTxB|LGk3Y>m9&5#C#{Pyz(?4|KQ;g`48t%C!!W5PFct)V;p_Js*N1QL=-8oS_^Ne& zBL~AU44v2p0NeOJ3z>5Ot&pNZgY%^EDzU3JyTk0eNE-Z75-KAu<0w?ylvx9 zu*rwDh1`JqiAJVZl{48dF2b+PejM>%7Dhd$IyWB%JgTA2bw2eabWsfhaq3_jm)a(# z?YQ?py1Gd75ic^AFR9Bwl9T~JRYpq5lnJZQak<3Opt{yh%UbS6!A?WLY$`zsSDoJh3+_u;5NifuUpB~KClt~ zVdxien{qspM!GHXRWxd$2;QvNYJ-+kBc(^4@nvkn>A^Z0AssQ zXd`I&!qjFqZ7RkQ&w-k^O&AqwJF4nViOcBQOx0edzM-}=_mw?q6Q_LjQ{1taBCz-p z|7H2>;;8ad&5f$`)OlI9uN$)=Ii{<>sh-rds`gHz4mxD#ExX5(#c{p=ksXI(zJ{TW zzOnfU4u(k**K5u+=49gj!c=$Hc}SHHMM$TVZ^|RFafk4kl=z>-IRW_p>5r`cCIvFO P00000NkvXXu0mjfL!wv* literal 0 HcmV?d00001 From 3c8783f3349f492fe6ee7edf9dfe7258e7e2b577 Mon Sep 17 00:00:00 2001 From: Johannes Schatteiner Date: Fri, 21 Jul 2023 20:08:42 +0200 Subject: [PATCH 4/9] Fix generateSdf2D not working due to missing definition --- cmd/generate_sdf_2d/CMakeLists.txt | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/cmd/generate_sdf_2d/CMakeLists.txt b/cmd/generate_sdf_2d/CMakeLists.txt index 8cae0ff..3e70343 100644 --- a/cmd/generate_sdf_2d/CMakeLists.txt +++ b/cmd/generate_sdf_2d/CMakeLists.txt @@ -13,6 +13,11 @@ if(WIN32) add_definitions(-D_USE_MATH_DEFINES) endif(WIN32) +# Enable PolygonDistance to use clipper2 reliant constructor. +if (USE_CLIPPER2) + add_definitions(-DIS_CLIPPER_ENABLED) +endif() + # OpenMP support. find_package(OpenMP REQUIRED) if(OPENMP_FOUND) From 0ea0c61704d55de86dfaba1f5403cfa88291783b Mon Sep 17 00:00:00 2001 From: Johannes Schatteiner Date: Mon, 24 Jul 2023 12:23:52 +0200 Subject: [PATCH 5/9] Remove SD-Function test sampling and debug SVG output --- cmd/generate_sdf_2d/main.cpp | 35 ++++++++++++----------------------- 1 file changed, 12 insertions(+), 23 deletions(-) diff --git a/cmd/generate_sdf_2d/main.cpp b/cmd/generate_sdf_2d/main.cpp index acc4960..7100112 100644 --- a/cmd/generate_sdf_2d/main.cpp +++ b/cmd/generate_sdf_2d/main.cpp @@ -95,29 +95,18 @@ int main(int argc, char* argv[]) Discregrid::PolygonDistance pd(polygon); std::cout << "DONE" << std::endl; - Eigen::Vector2d sample(0.0, 0.0); - std::cout << "TEST TEST PLS REMOVE ME: Sampling at (" << sample.x() << "|" << sample.y() << ")..." << std::endl; - const Discregrid::Result2D signed_distance = pd.signed_distance(sample); - std::cout << "Closest point on polygon from sample: (" << signed_distance.nearest_point.x() << "|" << signed_distance.nearest_point.y() << ")" << std::endl; - - std::filesystem::path filePath(filename); - std::string svg_name = filePath.filename().stem().string().append(".svg"); - std::cout << "Writing polygon as SVG to " << svg_name << "..." << std::endl; - Clipper2Lib::SvgWriter svg; - svg.AddPaths(polygon, false, Clipper2Lib::FillRule::NonZero, 0x4080ff9C, 0xFF003300, 1.5, false); - Clipper2Lib::PathD signed_distance_path = Clipper2Lib::MakePathD({signed_distance.nearest_point.x(), signed_distance.nearest_point.y(), sample.x(), sample.y()}); - svg.AddPath(signed_distance_path, true, Clipper2Lib::FillRule::NonZero, 0xFFFF00FF, 0xFFFF00FF, 3, false); - std::cout << "TEST TEST PLS REMOVE ME: Sampling from -0.5 to +0.5 in both dimensoins and save to svg..." << std::endl; - for (double xSample = -0.5; xSample <= 0.5; xSample += 0.1) - { - for (double ySample = -0.5; ySample <= 0.5; ySample += 0.1) - { - const Discregrid::Result2D signed_distance_sample = pd.signed_distance(Vector2d{xSample, ySample}); - svg.AddPath(Clipper2Lib::MakePathD({signed_distance_sample.nearest_point.x(), signed_distance_sample.nearest_point.y(), xSample, ySample}), true, Clipper2Lib::FillRule::NonZero, 0xFFFF00FF, 0xFFFF00FF, 3, false); - } - } - svg.SaveToFile(svg_name, 1000, 1000, 10); - std::cout << "DONE" << std::endl; + // The following commented code can be used to test the signed distance function sampling and save the polygon + sample(s) to an SVG file. + // std::filesystem::path filePath(filename); + // std::string svg_name = filePath.filename().stem().string().append(".svg"); + // std::cout << "Writing polygon as SVG to " << svg_name << "..." << std::endl; + // Clipper2Lib::SvgWriter svg; + // svg.AddPaths(polygon, false, Clipper2Lib::FillRule::NonZero, 0x4080ff9C, 0xFF003300, 1.5, false); + // Eigen::Vector2d sample(0.0, 0.0); + // const Discregrid::Result2D signed_distance = pd.signed_distance(sample); + // Clipper2Lib::PathD signed_distance_path = Clipper2Lib::MakePathD({signed_distance.nearest_point.x(), signed_distance.nearest_point.y(), sample.x(), sample.y()}); + // svg.AddPath(signed_distance_path, true, Clipper2Lib::FillRule::NonZero, 0xFFFF00FF, 0xFFFF00FF, 3, false); + // svg.SaveToFile(svg_name, 1000, 1000, 10); + // std::cout << "DONE" << std::endl; Eigen::AlignedBox2d domain; domain.setEmpty(); From 9904cb21368ebd979d0a46126b4605c585f53aae Mon Sep 17 00:00:00 2001 From: Johannes Schatteiner Date: Wed, 2 Aug 2023 15:57:20 +0200 Subject: [PATCH 6/9] Fix z-sort 2D and test --- cmd/generate_sdf_2d/main.cpp | 89 ++++++++++++++++++++++++++++ discregrid/src/data/z_sort_table.hpp | 24 +++++--- 2 files changed, 105 insertions(+), 8 deletions(-) diff --git a/cmd/generate_sdf_2d/main.cpp b/cmd/generate_sdf_2d/main.cpp index 7100112..1595e00 100644 --- a/cmd/generate_sdf_2d/main.cpp +++ b/cmd/generate_sdf_2d/main.cpp @@ -10,6 +10,8 @@ #include #include +#include "../../discregrid/src/data/z_sort_table.hpp" + using namespace Eigen; std::istream& operator>>(std::istream& is, std::array& data) @@ -145,6 +147,93 @@ int main(int argc, char* argv[]) sdf.addFunction(func, true); std::cout << "DONE" << std::endl; + std::cout << "Reduce discrete field..." << std::endl; + constexpr double h = 0.1; + sdf.reduceField(0u, [&](const Vector2d &, double v) + { + return v < h && v > (-h); + }); + std::cout << "DONE" << std::endl; + + std::cout << "Testing z-order..." << std::endl; + for (unsigned int i = 0; i < 8; i++) + { + for (unsigned int j = 0; j < 8; j++) + { + std::array p = {i, j}; + auto morton = morton_lut(p); + std::cout << "(" << i << "|" << j << ") : " << morton << std::endl; + } + } + std::cout << "DONE" << std::endl; + /* + *(0|0) : 0 +(0|1) : 2 +(0|2) : 8 +(0|3) : 10 +(0|4) : 32 +(0|5) : 34 +(0|6) : 40 +(0|7) : 42 +(1|0) : 1 +(1|1) : 3 +(1|2) : 9 +(1|3) : 11 +(1|4) : 33 +(1|5) : 35 +(1|6) : 41 +(1|7) : 43 +(2|0) : 4 +(2|1) : 6 +(2|2) : 12 +(2|3) : 14 +(2|4) : 36 +(2|5) : 38 +(2|6) : 44 +(2|7) : 46 +(3|0) : 5 +(3|1) : 7 +(3|2) : 13 +(3|3) : 15 +(3|4) : 37 +(3|5) : 39 +(3|6) : 45 +(3|7) : 47 +(4|0) : 16 +(4|1) : 18 +(4|2) : 24 +(4|3) : 26 +(4|4) : 48 +(4|5) : 50 +(4|6) : 56 +(4|7) : 58 +(5|0) : 17 +(5|1) : 19 +(5|2) : 25 +(5|3) : 27 +(5|4) : 49 +(5|5) : 51 +(5|6) : 57 +(5|7) : 59 +(6|0) : 20 +(6|1) : 22 +(6|2) : 28 +(6|3) : 30 +(6|4) : 52 +(6|5) : 54 +(6|6) : 60 +(6|7) : 62 +(7|0) : 21 +(7|1) : 23 +(7|2) : 29 +(7|3) : 31 +(7|4) : 53 +(7|5) : 55 +(7|6) : 61 +(7|7) : 63 + + */ + std::cout << "Serialize discretization..."; auto output_file = result["o"].as(); if (output_file == "") diff --git a/discregrid/src/data/z_sort_table.hpp b/discregrid/src/data/z_sort_table.hpp index 841600c..c21b8d7 100755 --- a/discregrid/src/data/z_sort_table.hpp +++ b/discregrid/src/data/z_sort_table.hpp @@ -232,16 +232,24 @@ static const unsigned int Morton2D_encode_y_256[256] = }; inline -uint64_t morton_lut(std::array const& x) +uint64_t morton_lut(std::array const& coords) { uint64_t answer = 0; - answer = answer << 48 | morton256_z[(x[2] >> 8) & 0xFF] | // shifting second byte - morton256_y[(x[1] >> 8) & 0xFF] | - morton256_x[(x[0] >> 8) & 0xFF]; - answer = answer << 24 | - morton256_z[(x[2]) & 0xFF] | // first byte - morton256_y[(x[1]) & 0xFF] | - morton256_x[(x[0]) & 0xFF]; + + // We start by shifting the second byte, since we only look at the first 14 bits + answer = Morton2D_encode_y_256[(coords[1] >> 16) & 0xFF] | + Morton2D_encode_x_256[(coords[0] >> 16) & 0xFF]; + + // Shifting middle byte + answer = (answer << 16) | + Morton2D_encode_y_256[(coords[1] >> 8) & 0xFF] | + Morton2D_encode_x_256[(coords[0] >> 8) & 0xFF]; + + // Shifting first byte + answer = (answer << 16) | + Morton2D_encode_y_256[(coords[1]) & 0xFF] | + Morton2D_encode_x_256[(coords[0]) & 0xFF]; + return answer; } From 6c136cfcd756c19a950f156d5a2239684b7a7cff Mon Sep 17 00:00:00 2001 From: Johannes Schatteiner Date: Wed, 2 Aug 2023 20:30:48 +0200 Subject: [PATCH 7/9] Remove test code and comments --- cmd/generate_sdf_2d/main.cpp | 89 ---------------------------- discregrid/src/data/z_sort_table.hpp | 7 --- 2 files changed, 96 deletions(-) diff --git a/cmd/generate_sdf_2d/main.cpp b/cmd/generate_sdf_2d/main.cpp index 1595e00..7100112 100644 --- a/cmd/generate_sdf_2d/main.cpp +++ b/cmd/generate_sdf_2d/main.cpp @@ -10,8 +10,6 @@ #include #include -#include "../../discregrid/src/data/z_sort_table.hpp" - using namespace Eigen; std::istream& operator>>(std::istream& is, std::array& data) @@ -147,93 +145,6 @@ int main(int argc, char* argv[]) sdf.addFunction(func, true); std::cout << "DONE" << std::endl; - std::cout << "Reduce discrete field..." << std::endl; - constexpr double h = 0.1; - sdf.reduceField(0u, [&](const Vector2d &, double v) - { - return v < h && v > (-h); - }); - std::cout << "DONE" << std::endl; - - std::cout << "Testing z-order..." << std::endl; - for (unsigned int i = 0; i < 8; i++) - { - for (unsigned int j = 0; j < 8; j++) - { - std::array p = {i, j}; - auto morton = morton_lut(p); - std::cout << "(" << i << "|" << j << ") : " << morton << std::endl; - } - } - std::cout << "DONE" << std::endl; - /* - *(0|0) : 0 -(0|1) : 2 -(0|2) : 8 -(0|3) : 10 -(0|4) : 32 -(0|5) : 34 -(0|6) : 40 -(0|7) : 42 -(1|0) : 1 -(1|1) : 3 -(1|2) : 9 -(1|3) : 11 -(1|4) : 33 -(1|5) : 35 -(1|6) : 41 -(1|7) : 43 -(2|0) : 4 -(2|1) : 6 -(2|2) : 12 -(2|3) : 14 -(2|4) : 36 -(2|5) : 38 -(2|6) : 44 -(2|7) : 46 -(3|0) : 5 -(3|1) : 7 -(3|2) : 13 -(3|3) : 15 -(3|4) : 37 -(3|5) : 39 -(3|6) : 45 -(3|7) : 47 -(4|0) : 16 -(4|1) : 18 -(4|2) : 24 -(4|3) : 26 -(4|4) : 48 -(4|5) : 50 -(4|6) : 56 -(4|7) : 58 -(5|0) : 17 -(5|1) : 19 -(5|2) : 25 -(5|3) : 27 -(5|4) : 49 -(5|5) : 51 -(5|6) : 57 -(5|7) : 59 -(6|0) : 20 -(6|1) : 22 -(6|2) : 28 -(6|3) : 30 -(6|4) : 52 -(6|5) : 54 -(6|6) : 60 -(6|7) : 62 -(7|0) : 21 -(7|1) : 23 -(7|2) : 29 -(7|3) : 31 -(7|4) : 53 -(7|5) : 55 -(7|6) : 61 -(7|7) : 63 - - */ - std::cout << "Serialize discretization..."; auto output_file = result["o"].as(); if (output_file == "") diff --git a/discregrid/src/data/z_sort_table.hpp b/discregrid/src/data/z_sort_table.hpp index c21b8d7..e29921c 100755 --- a/discregrid/src/data/z_sort_table.hpp +++ b/discregrid/src/data/z_sort_table.hpp @@ -235,21 +235,14 @@ inline uint64_t morton_lut(std::array const& coords) { uint64_t answer = 0; - - // We start by shifting the second byte, since we only look at the first 14 bits answer = Morton2D_encode_y_256[(coords[1] >> 16) & 0xFF] | Morton2D_encode_x_256[(coords[0] >> 16) & 0xFF]; - - // Shifting middle byte answer = (answer << 16) | Morton2D_encode_y_256[(coords[1] >> 8) & 0xFF] | Morton2D_encode_x_256[(coords[0] >> 8) & 0xFF]; - - // Shifting first byte answer = (answer << 16) | Morton2D_encode_y_256[(coords[1]) & 0xFF] | Morton2D_encode_x_256[(coords[0]) & 0xFF]; - return answer; } From 487d86110f87a6aa16f544bdd3809d6f4481d902 Mon Sep 17 00:00:00 2001 From: Johannes Schatteiner Date: Wed, 16 Aug 2023 16:41:58 +0200 Subject: [PATCH 8/9] Fix vertex pseudo-normal for polygon --- .../include/Discregrid/geometry/PolygonDistance.hpp | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/discregrid/include/Discregrid/geometry/PolygonDistance.hpp b/discregrid/include/Discregrid/geometry/PolygonDistance.hpp index 5d9696e..9486ea7 100644 --- a/discregrid/include/Discregrid/geometry/PolygonDistance.hpp +++ b/discregrid/include/Discregrid/geometry/PolygonDistance.hpp @@ -363,13 +363,7 @@ inline void Discregrid::PolygonDistance::_construct() std::cout << "PolygonDistance error: Polygon is not valid. At least one vertex does not have exactly two incident edges." << std::endl; exit(-1); } - Eigen::Vector2i edge1 = this->edges[edgeNormalIndices[0]]; - Eigen::Vector2i edge2 = this->edges[edgeNormalIndices[1]]; - Eigen::Vector2d a = this->vertices[vertexIndex]; - Eigen::Vector2d b = this->vertices[edge1[0] == edge2[0] || edge1[0] == edge2[1] ? edge1[1] : edge1[0]]; - Eigen::Vector2d c = this->vertices[vertexIndex == edge2[0] ? edge2[1] : edge2[0]]; - double alpha0 = std::acos(std::abs((b - a).normalized().dot((c - a).normalized()))); - this->pseudonormals_vertices[vertexIndex] = (alpha0 * (this->pseudonormals_edges[edgeNormalIndices[0]] + this->pseudonormals_edges[edgeNormalIndices[1]])).normalized(); + this->pseudonormals_vertices[vertexIndex] = ((this->pseudonormals_edges[edgeNormalIndices[0]] + this->pseudonormals_edges[edgeNormalIndices[1]]) / 2.0).normalized(); } this->is_constructed = true; From 599d2825b8833b9e75081855d029ebc9b640faf9 Mon Sep 17 00:00:00 2001 From: Johannes Schatteiner Date: Tue, 22 Aug 2023 10:47:35 +0200 Subject: [PATCH 9/9] Remove unused depth option from SDF to bitmap 2D --- cmd/discrete_field_to_bitmap_2d/main.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/cmd/discrete_field_to_bitmap_2d/main.cpp b/cmd/discrete_field_to_bitmap_2d/main.cpp index 2585c17..459d1e2 100644 --- a/cmd/discrete_field_to_bitmap_2d/main.cpp +++ b/cmd/discrete_field_to_bitmap_2d/main.cpp @@ -67,7 +67,6 @@ int main(int argc, char* argv[]) ("h,help", "Prints this help text") ("f,field_id", "ID in which the SDF to export is stored.", cxxopts::value()->default_value("0")) ("s,samples", "Number of samples in width direction", cxxopts::value()->default_value("1024")) - ("d,depth", "Relative depth value between -1 and 1 in direction of the axis orthogonal to the plane", cxxopts::value()->default_value("0")) ("o,output", "Output (in bmp format)", cxxopts::value()->default_value("")) ("c,colormap", "Color map options: redsequential (rs), green blue inverse diverging (gb) (suitable for visualisation of signed distance fields), 5 colour heatmap (hm) (suitable for visualisation of differences/errors)", cxxopts::value()->default_value("gb")) ("input", "SDF file", cxxopts::value>())