diff --git a/.gitignore b/.gitignore index 55f28f7f..4cb2f278 100644 --- a/.gitignore +++ b/.gitignore @@ -85,7 +85,7 @@ temp/ ## Python ####################################### # Byte-compiled / optimized / DLL files -__pycache__/ +**/__pycache__/ *.py[cod] *$py.class @@ -243,4 +243,7 @@ cython_debug/ # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. -#.idea/ \ No newline at end of file +#.idea/ + +# egg-info +*.egg-info/ \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json index 66ad6a97..257ac4dd 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -104,6 +104,7 @@ "cwctype": "cpp", "memory_resource": "cpp", "scoped_allocator": "cpp", - "strstream": "cpp" + "strstream": "cpp", + "core": "cpp" } } \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index 7daa63f0..8fc24320 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -119,15 +119,6 @@ target_include_directories(${APP_NAME_EXE} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src ) -#-------------------------------------------------------------------------- -# Tests -#-------------------------------------------------------------------------- - -# include(CTest) -# enable_testing() - -# add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/tests/global_registrations) - #-------------------------------------------------------------------------- # pybind11 #-------------------------------------------------------------------------- @@ -171,4 +162,42 @@ if (BUILD_PYTHON_MODULE) ) endforeach() -endif() \ No newline at end of file +endif() + +#-------------------------------------------------------------------------- +# Tests +#-------------------------------------------------------------------------- + +# include(CTest) +# enable_testing() +# add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/deps/googletest) +# set(TESTS_OUT_DIR ${CMAKE_BINARY_DIR}/tests/) + + +# # Unit testing ------------------------------------------------------------ +# set(UNIT_TESTS unit_tests) +# add_executable(${UNIT_TESTS} tests/unit_tests/DFPointCloudTest.cc) +# set_target_properties(${UNIT_TESTS} PROPERTIES +# RUNTIME_OUTPUT_DIRECTORY ${TESTS_OUT_DIR} +# ) + +# target_link_libraries(${UNIT_TESTS} gtest gtest_main) +# target_link_libraries(${UNIT_TESTS} ${SHARED_LIB_NAME}) + +# add_test(NAME ${UNIT_TESTS} COMMAND ${UNIT_TESTS}) + +# Integration testing ----------------------------------------------------- +# Component testing ------------------------------------------------------- +# etc --------------------------------------------------------------------- + +# # TODO: a better way to copy the dlls to the tests directory for the tests +# # get all the files -dlls in the bin directory and copy them one by one to tests dir +# file(GLOB files ${CMAKE_BINARY_DIR}/bin/Release/*.dll) +# foreach(file ${files}) +# message(STATUS "Copying ${file} to ${TESTS_OUT_DIR}") +# add_custom_command(TARGET ${UNIT_TESTS} POST_BUILD +# COMMAND ${CMAKE_COMMAND} -E copy +# ${file} +# ${TESTS_OUT_DIR}/Release +# ) +# endforeach() \ No newline at end of file diff --git a/README.md b/README.md index 60ed853a..c9578dcf 100644 --- a/README.md +++ b/README.md @@ -36,19 +36,6 @@ gantt Data collection and evaluation :dataeval, after fabrob, 4w ``` -```mermaid -gantt - dateFormat YYYY-MM-DD - title diffCheck - backend dev - excludes weekends - - data i/o :active, dataio, 2024-03-15, 3w - global registration :glbreg, 2024-03-29, 2w - semantic seg. from 3D model :semseg, after glbreg, 1w - local registration :locreg, after semseg, 2w - error computation + results :errcomp, after locreg, 1w -``` - ## 3rd party libraries The project uses the following 3rd party libraries: @@ -63,22 +50,22 @@ To build and test the project, follow the following steps: ```terminal cmake/config.bat cmake/build.bat -./build/bin/Release/diffCheckApp.exe <-- for prototyping +./build/bin/Release/diffCheckApp.exe <-- for prototyping in c++ ``` ## Prototype diffCheck in C++ To prototype: 1) add a header/source file in `src/diffCheck` and include the header in `diffCheck.hh` interface -1) test it in `diffCheckApp` (the cmake will output an executable in bin) +2) test it in `diffCheckApp` (the cmake will output an executable in bin) See the [CONTRIBUTING.md](https://github.com/diffCheckOrg/diffCheck/blob/main/CONTRIBUTING.md) for more information on how to prototype with diffCheck (code guidelines, visualizer, utilities, etc). ## Component roadmap From the 3/5/2024 meeting, the architecture of the different grasshopper components was discussed as following: -- [ ] PLY loader point cloud: @eleni: loads the pointcloud ply files and converts it into rg.PointCloud (+ cvt submodule) -- [ ] PLY loader mesh: @eleni: loads the mesh ply files and converts it into rg.Mesh (+ cvt submodule) -- [ ] Global registration: @andrea: to align the scan to the reference model -- [ ] Refined registration: @andrea: to refine the alignement +- [x] PLY loader point cloud: @eleni: loads the pointcloud ply files and converts it into rg.PointCloud (+ cvt submodule) +- [x] PLY loader mesh: @eleni: loads the mesh ply files and converts it into rg.Mesh (+ cvt submodule) +- [x] Global registration: @andrea: to align the scan to the reference model +- [x] Refined registration: @andrea: to refine the alignement - [ ] Semantic segmentation additive: to identify the pieces or joints in the point cloud - [ ] Semantic segmentation subtractive: to identify the pieces or joints in the point cloud - [ ] Per-joint refinement to refine the global registration to each joints (only in the "substractive" case) diff --git a/ScreenCamera_2024-06-30-00-00-53.json b/ScreenCamera_2024-06-30-00-00-53.json new file mode 100644 index 00000000..8f1e3eb1 --- /dev/null +++ b/ScreenCamera_2024-06-30-00-00-53.json @@ -0,0 +1,41 @@ +{ + "class_name" : "PinholeCameraParameters", + "extrinsic" : + [ + 0.78518600604290978, + -0.4688467948733368, + 0.4045560762754441, + 0.0, + -0.61432912235314374, + -0.67201447960085037, + 0.41351695084435719, + 0.0, + 0.077991444038432445, + -0.57321830234544802, + -0.81568260525341763, + 0.0, + 1416.8243739322577, + 908.62300697364822, + 1063.1264987715035, + 1.0 + ], + "intrinsic" : + { + "height" : 800, + "intrinsic_matrix" : + [ + 692.82032302755101, + 0.0, + 0.0, + 0.0, + 692.82032302755101, + 0.0, + 499.5, + 399.5, + 1.0 + ], + "width" : 1000 + }, + "version_major" : 1, + "version_minor" : 0 +} \ No newline at end of file diff --git a/ScreenCamera_2024-06-30-11-58-46.json b/ScreenCamera_2024-06-30-11-58-46.json new file mode 100644 index 00000000..6d0e81ff --- /dev/null +++ b/ScreenCamera_2024-06-30-11-58-46.json @@ -0,0 +1,41 @@ +{ + "class_name" : "PinholeCameraParameters", + "extrinsic" : + [ + 0.76239913059926834, + -0.422274821893041, + 0.49033818988192268, + 0.0, + -0.54132130094127906, + -0.00099240450767756894, + 0.8408152378974435, + 0.0, + -0.35456849099817256, + -0.90646731321570218, + -0.22934296427574399, + 0.0, + 1550.6223360557265, + 197.24908733414611, + 336.92784140962624, + 1.0 + ], + "intrinsic" : + { + "height" : 800, + "intrinsic_matrix" : + [ + 692.82032302755101, + 0.0, + 0.0, + 0.0, + 692.82032302755101, + 0.0, + 499.5, + 399.5, + 1.0 + ], + "width" : 1000 + }, + "version_major" : 1, + "version_minor" : 0 +} \ No newline at end of file diff --git a/ScreenCapture_2024-06-30-00-00-53.png b/ScreenCapture_2024-06-30-00-00-53.png new file mode 100644 index 00000000..a4e45f73 Binary files /dev/null and b/ScreenCapture_2024-06-30-00-00-53.png differ diff --git a/ScreenCapture_2024-06-30-11-58-46.png b/ScreenCapture_2024-06-30-11-58-46.png new file mode 100644 index 00000000..5c71fa25 Binary files /dev/null and b/ScreenCapture_2024-06-30-11-58-46.png differ diff --git a/assets/icon_pool/cloud1.png b/assets/icon_pool/cloud1.png deleted file mode 100644 index 33ecc1b4..00000000 Binary files a/assets/icon_pool/cloud1.png and /dev/null differ diff --git a/assets/icon_pool/cloud1.xcf b/assets/icon_pool/cloud1.xcf deleted file mode 100644 index 9ae84738..00000000 Binary files a/assets/icon_pool/cloud1.xcf and /dev/null differ diff --git a/assets/icon_pool/cloud2.png b/assets/icon_pool/cloud2.png deleted file mode 100644 index fbe9c037..00000000 Binary files a/assets/icon_pool/cloud2.png and /dev/null differ diff --git a/assets/icon_pool/cloud2.xcf b/assets/icon_pool/cloud2.xcf deleted file mode 100644 index e4c0f5fb..00000000 Binary files a/assets/icon_pool/cloud2.xcf and /dev/null differ diff --git a/assets/icon_pool/code_xml_export.png b/assets/icon_pool/code_xml_export.png deleted file mode 100644 index 94a616be..00000000 Binary files a/assets/icon_pool/code_xml_export.png and /dev/null differ diff --git a/assets/icon_pool/code_xml_export.xcf b/assets/icon_pool/code_xml_export.xcf deleted file mode 100644 index f9ab536e..00000000 Binary files a/assets/icon_pool/code_xml_export.xcf and /dev/null differ diff --git a/assets/icon_pool/code_xml_export2.png b/assets/icon_pool/code_xml_export2.png deleted file mode 100644 index 13a4fcfd..00000000 Binary files a/assets/icon_pool/code_xml_export2.png and /dev/null differ diff --git a/assets/icon_pool/code_xml_export2.xcf b/assets/icon_pool/code_xml_export2.xcf deleted file mode 100644 index 64f47d7c..00000000 Binary files a/assets/icon_pool/code_xml_export2.xcf and /dev/null differ diff --git a/assets/icon_pool/df_test_import.png b/assets/icon_pool/df_test_import.png deleted file mode 100644 index 4d26b8ee..00000000 Binary files a/assets/icon_pool/df_test_import.png and /dev/null differ diff --git a/assets/icon_pool/df_test_import.xcf b/assets/icon_pool/df_test_import.xcf deleted file mode 100644 index b266ac53..00000000 Binary files a/assets/icon_pool/df_test_import.xcf and /dev/null differ diff --git a/assets/icon_pool/iconizer/icon.xcf b/assets/icon_pool/icon.xcf similarity index 100% rename from assets/icon_pool/iconizer/icon.xcf rename to assets/icon_pool/icon.xcf diff --git a/assets/icon_pool/iconizer/icon_base.png b/assets/icon_pool/icon_base.png similarity index 100% rename from assets/icon_pool/iconizer/icon_base.png rename to assets/icon_pool/icon_base.png diff --git a/assets/icon_pool/iconizer/icon_blu.png b/assets/icon_pool/icon_blu.png similarity index 100% rename from assets/icon_pool/iconizer/icon_blu.png rename to assets/icon_pool/icon_blu.png diff --git a/assets/icon_pool/iconizer/icon_downsample_size.png b/assets/icon_pool/icon_downsample_size.png similarity index 100% rename from assets/icon_pool/iconizer/icon_downsample_size.png rename to assets/icon_pool/icon_downsample_size.png diff --git a/assets/icon_pool/iconizer/icon_downsample_uniform.png b/assets/icon_pool/icon_downsample_uniform.png similarity index 100% rename from assets/icon_pool/iconizer/icon_downsample_uniform.png rename to assets/icon_pool/icon_downsample_uniform.png diff --git a/assets/icon_pool/iconizer/icon_downsample_voxel.png b/assets/icon_pool/icon_downsample_voxel.png similarity index 100% rename from assets/icon_pool/iconizer/icon_downsample_voxel.png rename to assets/icon_pool/icon_downsample_voxel.png diff --git a/assets/icon_pool/iconizer/icon_fastreg.png b/assets/icon_pool/icon_fastreg.png similarity index 100% rename from assets/icon_pool/iconizer/icon_fastreg.png rename to assets/icon_pool/icon_fastreg.png diff --git a/assets/icon_pool/iconizer/icon_fastreg.xcf b/assets/icon_pool/icon_fastreg.xcf similarity index 100% rename from assets/icon_pool/iconizer/icon_fastreg.xcf rename to assets/icon_pool/icon_fastreg.xcf diff --git a/assets/icon_pool/iconizer/icon_icpreg.png b/assets/icon_pool/icon_icpreg.png similarity index 100% rename from assets/icon_pool/iconizer/icon_icpreg.png rename to assets/icon_pool/icon_icpreg.png diff --git a/assets/icon_pool/icon_large_assemblytoxml.png b/assets/icon_pool/icon_large_assemblytoxml.png new file mode 100644 index 00000000..18066123 Binary files /dev/null and b/assets/icon_pool/icon_large_assemblytoxml.png differ diff --git a/assets/icon_pool/icon_large_buildassembly.png b/assets/icon_pool/icon_large_buildassembly.png new file mode 100644 index 00000000..18066123 Binary files /dev/null and b/assets/icon_pool/icon_large_buildassembly.png differ diff --git a/assets/icon_pool/icon_large_deconstructassembly.png b/assets/icon_pool/icon_large_deconstructassembly.png new file mode 100644 index 00000000..64427f64 Binary files /dev/null and b/assets/icon_pool/icon_large_deconstructassembly.png differ diff --git a/assets/icon_pool/icon_large_deconstructbeam.png b/assets/icon_pool/icon_large_deconstructbeam.png new file mode 100644 index 00000000..7313332b Binary files /dev/null and b/assets/icon_pool/icon_large_deconstructbeam.png differ diff --git a/assets/icon_pool/iconizer/icon_ransactreg.png b/assets/icon_pool/icon_ransactreg.png similarity index 100% rename from assets/icon_pool/iconizer/icon_ransactreg.png rename to assets/icon_pool/icon_ransactreg.png diff --git a/assets/icon_pool/icon_small_buildassembly.png b/assets/icon_pool/icon_small_buildassembly.png new file mode 100644 index 00000000..6735fe70 Binary files /dev/null and b/assets/icon_pool/icon_small_buildassembly.png differ diff --git a/assets/icon_pool/icon_small_buildassembly.xcf b/assets/icon_pool/icon_small_buildassembly.xcf new file mode 100644 index 00000000..1c471098 Binary files /dev/null and b/assets/icon_pool/icon_small_buildassembly.xcf differ diff --git a/assets/icon_pool/icon_small_deconstructassembly.png b/assets/icon_pool/icon_small_deconstructassembly.png new file mode 100644 index 00000000..1c9ebbb4 Binary files /dev/null and b/assets/icon_pool/icon_small_deconstructassembly.png differ diff --git a/assets/icon_pool/icon_small_deconstructbeam.png b/assets/icon_pool/icon_small_deconstructbeam.png new file mode 100644 index 00000000..ed9e81dd Binary files /dev/null and b/assets/icon_pool/icon_small_deconstructbeam.png differ diff --git a/assets/icon_pool/icon_small_xmlexport.png b/assets/icon_pool/icon_small_xmlexport.png new file mode 100644 index 00000000..56e9ae1d Binary files /dev/null and b/assets/icon_pool/icon_small_xmlexport.png differ diff --git a/assets/icon_pool/iconizer/icon_uniform_downsample.png b/assets/icon_pool/icon_uniform_downsample.png similarity index 100% rename from assets/icon_pool/iconizer/icon_uniform_downsample.png rename to assets/icon_pool/icon_uniform_downsample.png diff --git a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit__of_a(5).jpg b/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit__of_a(5).jpg deleted file mode 100644 index 3f696456..00000000 Binary files a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit__of_a(5).jpg and /dev/null differ diff --git a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit__of_t(1).jpg b/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit__of_t(1).jpg deleted file mode 100644 index 804e794f..00000000 Binary files a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit__of_t(1).jpg and /dev/null differ diff --git a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit__of_t(2).jpg b/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit__of_t(2).jpg deleted file mode 100644 index fe024ec2..00000000 Binary files a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit__of_t(2).jpg and /dev/null differ diff --git a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit__of_t(3).jpg b/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit__of_t(3).jpg deleted file mode 100644 index dec4a3c1..00000000 Binary files a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit__of_t(3).jpg and /dev/null differ diff --git a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit__of_t(4).jpg b/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit__of_t(4).jpg deleted file mode 100644 index 7262da87..00000000 Binary files a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit__of_t(4).jpg and /dev/null differ diff --git a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit__of_t.jpg b/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit__of_t.jpg deleted file mode 100644 index 2e3961a7..00000000 Binary files a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit__of_t.jpg and /dev/null differ diff --git a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit_of_a(1).jpg b/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit_of_a(1).jpg deleted file mode 100644 index 588a6fd7..00000000 Binary files a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit_of_a(1).jpg and /dev/null differ diff --git a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit_of_a.jpg b/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit_of_a.jpg deleted file mode 100644 index d98d2659..00000000 Binary files a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__16bit_of_a.jpg and /dev/null differ diff --git a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__of_a_cloud(1).jpg b/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__of_a_cloud(1).jpg deleted file mode 100644 index 19112a0c..00000000 Binary files a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__of_a_cloud(1).jpg and /dev/null differ diff --git a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__of_a_floppy_d(1).jpg b/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__of_a_floppy_d(1).jpg deleted file mode 100644 index 0a3d8196..00000000 Binary files a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__of_a_floppy_d(1).jpg and /dev/null differ diff --git a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__of_a_floppy_d.jpg b/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__of_a_floppy_d.jpg deleted file mode 100644 index 5f52a308..00000000 Binary files a/assets/icon_pool/image_fx_a_pixel_art_game_icon__24x24__of_a_floppy_d.jpg and /dev/null differ diff --git a/assets/icon_pool/logo_pixelized_bwvioelt.png b/assets/icon_pool/logo_pixelized_bwvioelt.png new file mode 100644 index 00000000..2d3b6867 Binary files /dev/null and b/assets/icon_pool/logo_pixelized_bwvioelt.png differ diff --git a/assets/icon_pool/normal.png b/assets/icon_pool/normal.png new file mode 100644 index 00000000..dacb5192 Binary files /dev/null and b/assets/icon_pool/normal.png differ diff --git a/assets/icon_pool/normal_cloud.png b/assets/icon_pool/normal_cloud.png new file mode 100644 index 00000000..c8b9fe65 Binary files /dev/null and b/assets/icon_pool/normal_cloud.png differ diff --git a/assets/icon_pool/normal_cloud.xcf b/assets/icon_pool/normal_cloud.xcf new file mode 100644 index 00000000..10cd5872 Binary files /dev/null and b/assets/icon_pool/normal_cloud.xcf differ diff --git a/assets/icon_pool/normal_segment.png b/assets/icon_pool/normal_segment.png new file mode 100644 index 00000000..ffe0caca Binary files /dev/null and b/assets/icon_pool/normal_segment.png differ diff --git a/assets/icon_pool/normal_segmenter.png b/assets/icon_pool/normal_segmenter.png new file mode 100644 index 00000000..9bf55eef Binary files /dev/null and b/assets/icon_pool/normal_segmenter.png differ diff --git a/assets/icon_pool/normal_segmenter.xcf b/assets/icon_pool/normal_segmenter.xcf new file mode 100644 index 00000000..c13bb1c5 Binary files /dev/null and b/assets/icon_pool/normal_segmenter.xcf differ diff --git a/src/gh/components/DF_scan_segmentation/icon.png b/assets/icon_pool/scan_segmentation.png similarity index 100% rename from src/gh/components/DF_scan_segmentation/icon.png rename to assets/icon_pool/scan_segmentation.png diff --git a/cmake/build_run.bat b/cmake/build_run.bat new file mode 100644 index 00000000..66e77f2e --- /dev/null +++ b/cmake/build_run.bat @@ -0,0 +1 @@ +.\cmake\build.bat ; if ($?) { .\build\bin\Release\diffCheckApp.exe } \ No newline at end of file diff --git a/deps/eigen b/deps/eigen index f78dfe36..d791d488 160000 --- a/deps/eigen +++ b/deps/eigen @@ -1 +1 @@ -Subproject commit f78dfe36b0a995f51fd4287bb3ba92dc6d486e15 +Subproject commit d791d48859c6fc7850c9fd5270d2b236c818068d diff --git a/deps/pybind11 b/deps/pybind11 index aa98d957..51c2aa16 160000 --- a/deps/pybind11 +++ b/deps/pybind11 @@ -1 +1 @@ -Subproject commit aa98d95717d1365b5c32d3942abd0292fbd19021 +Subproject commit 51c2aa16de5b50fe4be6a0016d6090d4a831899e diff --git a/src/diffCheck.hh b/src/diffCheck.hh index 83b3ca64..44fe0dc2 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -3,6 +3,8 @@ #include #include +#include + // diffCheck includes #include "diffCheck/log.hh" const diffCheck::Log LOG = diffCheck::Log(); diff --git a/src/diffCheck/geometry/DFMesh.cc b/src/diffCheck/geometry/DFMesh.cc index 8e66159b..d7d24055 100644 --- a/src/diffCheck/geometry/DFMesh.cc +++ b/src/diffCheck/geometry/DFMesh.cc @@ -71,6 +71,30 @@ namespace diffCheck::geometry this->Cvt2DFMesh(O3DTriangleMesh); } + std::vector DFMesh::GetTightBoundingBox() + { + auto O3DTriangleMesh = this->Cvt2O3DTriangleMesh(); + open3d::geometry::OrientedBoundingBox tightOOBB = O3DTriangleMesh->GetMinimalOrientedBoundingBox(); + std::vector bboxPts = tightOOBB.GetBoxPoints(); + return bboxPts; + } + + Eigen::Vector3d DFMesh::GetFirstNormal() + { + if (this->NormalsFace.size() == 0) + { + std::shared_ptr O3DTriangleMesh = this->Cvt2O3DTriangleMesh(); + O3DTriangleMesh->ComputeTriangleNormals(); + this->NormalsFace.resize(O3DTriangleMesh->triangle_normals_.size()); + for (size_t i = 0; i < O3DTriangleMesh->triangle_normals_.size(); i++) + { + this->NormalsFace[i] = O3DTriangleMesh->triangle_normals_[i]; + } + + } + return this->NormalsFace[0]; + } + void DFMesh::LoadFromPLY(const std::string &path) { std::shared_ptr tempMesh_ptr = diffCheck::io::ReadPLYMeshFromFile(path); diff --git a/src/diffCheck/geometry/DFMesh.hh b/src/diffCheck/geometry/DFMesh.hh index 139276b1..ff37793b 100644 --- a/src/diffCheck/geometry/DFMesh.hh +++ b/src/diffCheck/geometry/DFMesh.hh @@ -62,6 +62,22 @@ namespace diffCheck::geometry */ void ApplyTransformation(const diffCheck::transformation::DFTransformation &transformation); + public: ///< Utils + /** + * @brief Get the mesh tight bounding box + * + * @return std::vector A vector of two Eigen::Vector3d, with the first one being the minimum + * point and the second one the maximum point of the bounding box. + */ + std::vector GetTightBoundingBox(); + + /** + * @brief Get the first normal of the mesh. Meant for planar meshes + * + * @return Eigen::Vector3d the normal + */ + Eigen::Vector3d GetFirstNormal(); + public: ///< I/O loader /** * @brief Read a mesh from a file diff --git a/src/diffCheck/geometry/DFPointCloud.cc b/src/diffCheck/geometry/DFPointCloud.cc index a26b2d91..840188b3 100644 --- a/src/diffCheck/geometry/DFPointCloud.cc +++ b/src/diffCheck/geometry/DFPointCloud.cc @@ -1,4 +1,5 @@ #include "DFPointCloud.hh" +#include "diffCheck/log.hh" #include "diffCheck/IOManager.hh" @@ -7,6 +8,10 @@ namespace diffCheck::geometry { void DFPointCloud::Cvt2DFPointCloud(const std::shared_ptr &O3DPointCloud) { + this->Points.clear(); + this->Colors.clear(); + this->Normals.clear(); + if (O3DPointCloud->points_.size() != 0) for (auto &point : O3DPointCloud->points_) this->Points.push_back(point); @@ -18,6 +23,44 @@ namespace diffCheck::geometry this->Normals.push_back(normal); } + void DFPointCloud::Cvt2DFPointCloud(const std::shared_ptr &cilantroPointCloud) + { + this->Points.clear(); + this->Colors.clear(); + this->Normals.clear(); + + auto ptt = cilantroPointCloud->points; + int n_pt = (int)ptt.cols(); + auto col = cilantroPointCloud->colors; + auto nor = cilantroPointCloud->normals; + + if (n_pt == 0) + throw std::invalid_argument("The point cloud is empty."); + for (int i = 0; i < n_pt; i++) + { + Eigen::Vector3d pt_d = ptt.col(i).cast(); + this->Points.push_back(pt_d); + } + + if (cilantroPointCloud->hasColors()) + { + for (int i = 0; i < n_pt; i++) + { + Eigen::Vector3d cl_d = col.col(i).cast (); + this->Colors.push_back(cl_d); + } + } + + if (cilantroPointCloud->hasNormals()) + { + for (int i = 0; i < n_pt; i++) + { + Eigen::Vector3d no_d = nor.col(i).cast (); + this->Normals.push_back(no_d); + } + } + } + std::shared_ptr DFPointCloud::Cvt2O3DPointCloud() { std::shared_ptr O3DPointCloud(new open3d::geometry::PointCloud()); @@ -33,6 +76,46 @@ namespace diffCheck::geometry return O3DPointCloud; } + std::shared_ptr DFPointCloud::Cvt2CilantroPointCloud() + { + std::shared_ptr cilantroPointCloud = std::make_shared(); + + cilantro::VectorSet3f points; + for (auto& pt : this->Points) + { + Eigen::Vector3f pt_f = pt.cast (); + points.conservativeResize(points.rows(), points.cols() + 1); + points.col(points.cols() - 1) = pt_f; + } + cilantroPointCloud->points = points; + + cilantro::VectorSet3f colors; + if (this->HasColors()) + { + for (auto& color : this->Colors) + { + Eigen::Vector3f color_f = color.cast (); + colors.conservativeResize(colors.rows(), colors.cols() + 1); + colors.col(colors.cols() - 1) = color_f; + } + } + cilantroPointCloud->colors = colors; + + cilantro::VectorSet3f normals; + if (this->HasNormals()) + { + for (auto& normal : this->Normals) + { + Eigen::Vector3f normal_f = normal.cast (); + normals.conservativeResize(normals.rows(), normals.cols() + 1); + normals.col(normals.cols() - 1) = normal_f; + } + } + cilantroPointCloud->normals = normals; + + return cilantroPointCloud; + } + std::vector DFPointCloud::ComputeP2PDistance(std::shared_ptr target) { std::vector errors; @@ -55,6 +138,51 @@ namespace diffCheck::geometry return extremePoints; } + void DFPointCloud::EstimateNormals( + bool useCilantroEvaluator, + std::optional knn, + std::optional searchRadius + ) + { + if (!useCilantroEvaluator) + { + this->Normals.clear(); + auto O3DPointCloud = this->Cvt2O3DPointCloud(); + + if (knn.value() != 30 && searchRadius.has_value() == false) + { + open3d::geometry::KDTreeSearchParamKNN knnSearchParam(knn.value()); + O3DPointCloud->EstimateNormals(knnSearchParam); + DIFFCHECK_INFO(("Estimating normals with knn = " + std::to_string(knn.value())).c_str()); + } + else if (searchRadius.has_value()) + { + open3d::geometry::KDTreeSearchParamHybrid hybridSearchParam(searchRadius.value(), knn.value()); + O3DPointCloud->EstimateNormals(hybridSearchParam); + DIFFCHECK_INFO(("Estimating normals with hybrid search radius = " + std::to_string(searchRadius.value()) + "and knn = " + std::to_string(knn.value())).c_str()); + } + else + { + O3DPointCloud->EstimateNormals(); + DIFFCHECK_INFO("Default estimation of normals with knn = 30"); + } + for (auto &normal : O3DPointCloud->normals_) + this->Normals.push_back(normal); + } + else + { + std::shared_ptr cilantroPointCloud = this->Cvt2CilantroPointCloud(); + cilantro::KNNNeighborhoodSpecification neighborhood(knn.value()); + cilantroPointCloud->estimateNormals(neighborhood, false); + + this->Normals.clear(); + for (int i = 0; i < cilantroPointCloud->normals.cols(); i++) + this->Normals.push_back(cilantroPointCloud->normals.col(i).cast()); + DIFFCHECK_INFO(("Estimating normals with cilantro evaluator with knn = " + std::to_string(knn.value())).c_str()); + } + + } + void DFPointCloud::VoxelDownsample(double voxelSize) { if (voxelSize <= 0) @@ -72,6 +200,18 @@ namespace diffCheck::geometry this->Normals.push_back(normal); } + void DFPointCloud::ApplyColor(const Eigen::Vector3d &color) + { + this->Colors.clear(); + for (auto &point : this->Points) + this->Colors.push_back(color); + } + void DFPointCloud::ApplyColor(int r, int g, int b) + { + Eigen::Vector3d color = Eigen::Vector3d(r / 255.0, g / 255.0, b / 255.0); + this->ApplyColor(color); + } + void DFPointCloud::UniformDownsample(int everyKPoints) { auto O3DPointCloud = this->Cvt2O3DPointCloud(); @@ -106,6 +246,13 @@ namespace diffCheck::geometry for (auto &normal : O3DPointCloudDown->normals_) this->Normals.push_back(normal); } + + std::vector DFPointCloud::GetTightBoundingBox() + { + open3d::geometry::OrientedBoundingBox tightOOBB = this->Cvt2O3DPointCloud()->GetMinimalOrientedBoundingBox(); + std::vector bboxPts = tightOOBB.GetBoxPoints(); + return bboxPts; + } void DFPointCloud::ApplyTransformation(const diffCheck::transformation::DFTransformation &transformation) { diff --git a/src/diffCheck/geometry/DFPointCloud.hh b/src/diffCheck/geometry/DFPointCloud.hh index e6b1444d..9fd53f8a 100644 --- a/src/diffCheck/geometry/DFPointCloud.hh +++ b/src/diffCheck/geometry/DFPointCloud.hh @@ -1,10 +1,13 @@ #pragma once +#include #include #include #include +#include +#include namespace diffCheck::geometry { @@ -28,7 +31,8 @@ namespace diffCheck::geometry * @param pointCloud the open3d point cloud */ void Cvt2DFPointCloud(const std::shared_ptr &O3DPointCloud); - + void Cvt2DFPointCloud(const std::shared_ptr &cilantroPointCloud); + /** * @brief Convert the DFPointCloud to open3d point cloud * @@ -36,6 +40,13 @@ namespace diffCheck::geometry */ std::shared_ptr Cvt2O3DPointCloud(); + /** + * @brief Convert DFPointCloud to cilantro point cloud + * + * @return std::shared_ptr the cilantro point cloud + */ + std::shared_ptr Cvt2CilantroPointCloud(); + public: ///< Utilities /** * @brief Compute the "point to point" distance between this and another point clouds. @@ -58,6 +69,29 @@ namespace diffCheck::geometry */ std::vector ComputeBoundingBox(); + /** + * @brief Estimate the normals of the point cloud by either knn or if the radius + * is provided by hybrid search. + * + * Reference from Open3d. + * + * @param useCilantroEvaluator if true, the cilantro evaluator will be used, otherwise the open3d one + * @param knn the number of nearest neighbors to consider (by default 30) + * @param searchRadius the radius of the search, by default deactivated (only if useCilantroEvaluator is false) + */ + void EstimateNormals( + bool useCilantroEvaluator = false, + std::optional knn = 50, + std::optional searchRadius = std::nullopt); + + /** + * @brief Paint the point cloud with a uniform color + * + * @param color the color to paint the point cloud + */ + void ApplyColor(const Eigen::Vector3d &color); + void ApplyColor(int r, int g, int b); + public: ///< Downsamplers /** * @brief Downsample the point cloud with voxel grid @@ -78,7 +112,33 @@ namespace diffCheck::geometry * * @param targetSize the target size of the cloud */ + void DownsampleBySize(int targetSize); + /** + * @brief Get the tight bounding box of the point cloud + * + * @return std::vector A vector of two Eigen::Vector3d, with the first one being the minimum + * point and the second one the maximum point of the bounding box. + * /// ------- x + * /// /| + * /// / | + * /// / | z + * /// y + * /// 0 ------------------- 1 + * /// /| /| + * /// / | / | + * /// / | / | + * /// / | / | + * /// 2 ------------------- 7 | + * /// | |____________|____| 6 + * /// | /3 | / + * /// | / | / + * /// | / | / + * /// |/ |/ + * /// 5 ------------------- 4 + * /// + */ + std::vector GetTightBoundingBox(); public: ///< Transformers /** diff --git a/src/diffCheck/segmentation/DFSegmentation.cc b/src/diffCheck/segmentation/DFSegmentation.cc index 7bd954c9..383a792f 100644 --- a/src/diffCheck/segmentation/DFSegmentation.cc +++ b/src/diffCheck/segmentation/DFSegmentation.cc @@ -3,98 +3,348 @@ #include #include #include +#include namespace diffCheck::segmentation { - std::vector> DFSegmentation::SmoothSegmentation( - geometry::DFPointCloud &pointCloud, - float voxelSize, + std::vector> DFSegmentation::NormalBasedSegmentation( + std::shared_ptr &pointCloud, float normalThresholdDegree, int minClusterSize, bool useKnnNeighborhood, int knnNeighborhoodSize, - int radiusNeighborhoodSize) + float radiusNeighborhoodSize, + bool colorClusters) { - std::vector> segments; - cilantro::PointCloud3f cilantroPointCloud; - - // Convert the point cloud to cilantro point cloud - for (int i = 0; i < pointCloud.Points.size(); i++) + if (!pointCloud->HasNormals()) { - cilantroPointCloud.points.conservativeResize(3, cilantroPointCloud.points.cols() + 1); - cilantroPointCloud.points.rightCols(1) = pointCloud.Points[i].cast(); + DIFFCHECK_WARN("The point cloud does not have normals. Estimating normals with 50 neighbors."); + pointCloud->EstimateNormals(true, 50); } - // segment the point cloud using knn or radius neighborhood + std::shared_ptr cilantroPointCloud = pointCloud->Cvt2CilantroPointCloud(); + + std::vector> segments; if (useKnnNeighborhood) { cilantro::KNNNeighborhoodSpecification neighborhood(knnNeighborhoodSize); - // conpute the normals and downsample - cilantroPointCloud.estimateNormals(neighborhood, false); - cilantroPointCloud.gridDownsample(voxelSize); - - // Similarity evaluator cilantro::NormalsProximityEvaluator similarityEvaluator( - cilantroPointCloud.normals, + cilantroPointCloud->normals, normalThresholdDegree*M_PI/180.0f); - // Segment the point cloud - cilantro::ConnectedComponentExtraction3f<> segmenter(cilantroPointCloud.points); + cilantro::ConnectedComponentExtraction3f<> segmenter(cilantroPointCloud->points); segmenter.segment(neighborhood, similarityEvaluator, minClusterSize); auto clusterToPointMap = segmenter.getClusterToPointIndicesMap(); int nSegments = segmenter.getNumberOfClusters(); - // Get the segments for (int indice = 0; indice segment = std::make_shared(); for (auto pointIndice : clusterToPointMap[indice]) { - Eigen::Vector3d point = cilantroPointCloud.points.col(pointIndice).cast(); - Eigen::Vector3d normal = cilantroPointCloud.normals.col(pointIndice).cast(); + Eigen::Vector3d point = cilantroPointCloud->points.col(pointIndice).cast(); + Eigen::Vector3d normal = cilantroPointCloud->normals.col(pointIndice).cast(); segment->Points.push_back(point); segment->Normals.push_back(normal); + if (cilantroPointCloud->hasColors()) + { + Eigen::Vector3d color = cilantroPointCloud->colors.col(pointIndice).cast(); + segment->Colors.push_back(color); + } } + if (colorClusters) + segment->ApplyColor(Eigen::Vector3d::Random()); segments.push_back(segment); } } else { cilantro::RadiusNeighborhoodSpecification neighborhood(radiusNeighborhoodSize); - - // conpute the normals and downsample - cilantroPointCloud.estimateNormals(neighborhood, false); - cilantroPointCloud.gridDownsample(voxelSize); - - // Similarity evaluator cilantro::NormalsProximityEvaluator similarityEvaluator( - cilantroPointCloud.normals, + cilantroPointCloud->normals, normalThresholdDegree*M_PI/180.0f); - // Segment the point cloud - cilantro::ConnectedComponentExtraction3f<> segmenter(cilantroPointCloud.points); + cilantro::ConnectedComponentExtraction3f<> segmenter(cilantroPointCloud->points); segmenter.segment(neighborhood, similarityEvaluator, minClusterSize); auto clusterToPointMap = segmenter.getClusterToPointIndicesMap(); int nSegments = segmenter.getNumberOfClusters(); - // Get the segments for (int indice = 0; indice segment = std::make_shared(); for (auto pointIndice : clusterToPointMap[indice]) { - Eigen::Vector3d point = cilantroPointCloud.points.col(pointIndice).cast(); - Eigen::Vector3d normal = cilantroPointCloud.normals.col(pointIndice).cast(); + Eigen::Vector3d point = cilantroPointCloud->points.col(pointIndice).cast(); + Eigen::Vector3d normal = cilantroPointCloud->normals.col(pointIndice).cast(); segment->Points.push_back(point); segment->Normals.push_back(normal); + if (cilantroPointCloud->hasColors()) + { + Eigen::Vector3d color = cilantroPointCloud->colors.col(pointIndice).cast(); + segment->Colors.push_back(color); + } } + if (colorClusters) + segment->ApplyColor(Eigen::Vector3d::Random()); segments.push_back(segment); } } - return segments; } + + std::shared_ptr DFSegmentation::AssociateClustersToMeshes( + std::vector> referenceMesh, + std::vector> &clusters, + double angleThreshold, + double associationThreshold) + { + std::shared_ptr unifiedPointCloud = std::make_shared(); + + // iterate through the mesh faces given as function argument + if (referenceMesh.size() == 0) + { + DIFFCHECK_WARN("No mesh faces to associate with the clusters. Returning the first clusters untouched."); + return clusters[0]; + } + for (std::shared_ptr face : referenceMesh) + { + std::shared_ptr correspondingSegment; + + // Getting the center of the mesh face + Eigen::Vector3d faceCenter = face->Cvt2O3DTriangleMesh()->GetCenter(); + + // Getting the normal of the mesh face + Eigen::Vector3d faceNormal = face->GetFirstNormal(); + faceNormal.normalize(); + + // iterate through the segments to find the closest one compared to the face center taking the normals into account + Eigen::Vector3d segmentCenter; + Eigen::Vector3d segmentNormal; + double faceDistance = std::numeric_limits::max(); + if (clusters.size() == 0) + { + DIFFCHECK_WARN("No clusters to associate with the mesh faces. Returning the first mesh face untouched."); + return clusters[0]; + } + for (auto segment : clusters) + { + for (auto point : segment->Points){segmentCenter += point;} + segmentCenter /= segment->GetNumPoints(); + + for (auto normal : segment->Normals){segmentNormal += normal;} + segmentNormal.normalize(); + + double currentDistance = (faceCenter - segmentCenter).norm() / std::abs(segmentNormal.dot(faceNormal)); + // if the distance is smaller than the previous one, update the distance and the corresponding segment + if (std::abs(sin(acos(faceNormal.dot(segmentNormal)))) < angleThreshold && currentDistance < faceDistance) + { + correspondingSegment = segment; + faceDistance = currentDistance; + } + } + + // get the triangles of the face. + std::vector faceTriangles = face->Faces; + + if (correspondingSegment == nullptr) + { + DIFFCHECK_WARN("No segment found for the face. Skipping the face."); + continue; + } + for (Eigen::Vector3d point : correspondingSegment->Points) + { + bool pointInFace = false; + if (DFSegmentation::IsPointOnFace(face, point, associationThreshold)) + { + unifiedPointCloud->Points.push_back(point); + unifiedPointCloud->Normals.push_back( + correspondingSegment->Normals[std::distance( + correspondingSegment->Points.begin(), + std::find(correspondingSegment->Points.begin(), + correspondingSegment->Points.end(), + point))] + ); + } + } + // removing points from the segment that are in the face + if (unifiedPointCloud->GetNumPoints() == 0) + { + DIFFCHECK_WARN("No point was associated to this segment. Skipping the segment."); + continue; + } + for(Eigen::Vector3d point : unifiedPointCloud->Points) + { + correspondingSegment->Points.erase( + std::remove( + correspondingSegment->Points.begin(), + correspondingSegment->Points.end(), + point), + correspondingSegment->Points.end()); + } + // removing the corresponding segment if it is empty after the point transfer + if (correspondingSegment->GetNumPoints() == 0) + { + clusters.erase( + std::remove( + clusters.begin(), + clusters.end(), + correspondingSegment), + clusters.end()); + } + } + return unifiedPointCloud; + } + + void DFSegmentation::CleanUnassociatedClusters( + std::vector> &unassociatedClusters, + std::vector> &existingPointCloudSegments, + std::vector>> meshes, + double angleThreshold, + double associationThreshold) + { + if (unassociatedClusters.size() == 0) + { + DIFFCHECK_WARN("No unassociated clusters. Nothing is done"); + return; + } + for (std::shared_ptr cluster : unassociatedClusters) + { + Eigen::Vector3d clusterCenter; + Eigen::Vector3d clusterNormal; + + if (cluster->GetNumPoints() == 0) + { + DIFFCHECK_WARN("Empty cluster. Skipping the cluster."); + continue; + } + for (Eigen::Vector3d point : cluster->Points) + { + clusterCenter += point; + } + clusterCenter /= cluster->GetNumPoints(); + for (Eigen::Vector3d normal : cluster->Normals) + { + clusterNormal += normal; + } + clusterNormal.normalize(); + + int meshIndex = std::numeric_limits::max(); + int faceIndex = std::numeric_limits::max() ; + double distance = std::numeric_limits::max(); + + if (meshes.size() == 0) + { + DIFFCHECK_WARN("No meshes to associate with the clusters. Skipping the cluster."); + continue; + } + for (std::vector> piece : meshes) + { + if (piece.size() == 0) + { + DIFFCHECK_WARN("Empty piece in the meshes vector. Skipping the mesh face vector."); + continue; + } + for (std::shared_ptr meshFace : piece) + { + Eigen::Vector3d faceCenter; + Eigen::Vector3d faceNormal; + + std::shared_ptr o3dFace = meshFace->Cvt2O3DTriangleMesh(); + + faceNormal = meshFace->GetFirstNormal(); + faceNormal.normalize(); + faceCenter = o3dFace->GetCenter(); + /* + To make sure we select the right meshFace, we add another metric: + Indeed, from experimentation, sometimes the wrong mesh face is selected, because it is parallel to the correct one + (so the normal don't play a role) and the center of the face is closer to the cluster center than the correct face. + To prevent this, we take into the account the angle between the line linking the center of the meshFace considered + and the center of the point cloud cluster and the normal of the cluster. This value should be close to pi/2 + + The following two lines are not super optimized but more readable than the optimized version + */ + + double clusterNormalToJunctionLineAngle = std::abs(std::acos(clusterNormal.dot((clusterCenter - faceCenter).normalized()))); + + double currentDistance = (clusterCenter - faceCenter).norm() * std::pow(std::cos(clusterNormalToJunctionLineAngle), 2) / std::pow(clusterNormal.dot(faceNormal), 2); + if (std::abs(sin(acos(faceNormal.dot(clusterNormal)))) < angleThreshold && currentDistance < distance) + { + distance = currentDistance; + meshIndex = std::distance(meshes.begin(), std::find(meshes.begin(), meshes.end(), piece)); + faceIndex = std::distance(piece.begin(), std::find(piece.begin(), piece.end(), meshFace)); + } + } + } + if (meshIndex >= meshes.size() || faceIndex >= meshes[meshIndex].size()) + { + // this one generates a lot of warnings + DIFFCHECK_WARN("No mesh face found for the cluster. Skipping the cluster."); + continue; + } + std::shared_ptr completed_segment = existingPointCloudSegments[meshIndex]; + for (Eigen::Vector3d point : cluster->Points) + { + std::vector faceTriangles = meshes[meshIndex][faceIndex]->Faces; + if (IsPointOnFace(meshes[meshIndex][faceIndex], point, associationThreshold)) + { + completed_segment->Points.push_back(point); + completed_segment->Normals.push_back(cluster->Normals[std::distance(cluster->Points.begin(), std::find(cluster->Points.begin(), cluster->Points.end(), point))]); + } + } + std::vector indicesToRemove; + + for (int i = 0; i < cluster->Points.size(); ++i) + { + if (std::find(completed_segment->Points.begin(), completed_segment->Points.end(), cluster->Points[i]) != completed_segment->Points.end()) + { + indicesToRemove.push_back(i); + } + } + for (auto it = indicesToRemove.rbegin(); it != indicesToRemove.rend(); ++it) + { + std::swap(cluster->Points[*it], cluster->Points.back()); + cluster->Points.pop_back(); + std::swap(cluster->Normals[*it], cluster->Normals.back()); + cluster->Normals.pop_back(); + } + } + }; + + bool DFSegmentation::IsPointOnFace( + std::shared_ptr face, + Eigen::Vector3d point, + double associationThreshold) + { + /* + To check if the point is in the face, we take into account all the triangles forming the face. + We calculate the area of each triangle, then check if the sum of the areas of the tree triangles + formed by two of the points of the referencr triangle and our point is equal to the reference triangle area + (within a user-defined margin). If it is the case, the triangle is in the face. + */ + std::vector faceTriangles = face->Faces; + for (Eigen::Vector3i triangle : faceTriangles) + { + Eigen::Vector3d v0 = face->Vertices[triangle[0]]; + Eigen::Vector3d v1 = face->Vertices[triangle[1]]; + Eigen::Vector3d v2 = face->Vertices[triangle[2]]; + Eigen::Vector3d n = (v1 - v0).cross(v2 - v0); + double referenceTriangleArea = n.norm()*0.5; + Eigen::Vector3d n1 = (v1 - v0).cross(point - v0); + double area1 = n1.norm()*0.5; + Eigen::Vector3d n2 = (v2 - v1).cross(point - v1); + double area2 = n2.norm()*0.5; + Eigen::Vector3d n3 = (v0 - v2).cross(point - v2); + double area3 = n3.norm()*0.5; + double res = ( area1 + area2 + area3 - referenceTriangleArea) / referenceTriangleArea; + if (res < associationThreshold) + { + return true; + break; + } + } + return false; + } } // namespace diffCheck::segmentation \ No newline at end of file diff --git a/src/diffCheck/segmentation/DFSegmentation.hh b/src/diffCheck/segmentation/DFSegmentation.hh index c74354ac..33ef92bf 100644 --- a/src/diffCheck/segmentation/DFSegmentation.hh +++ b/src/diffCheck/segmentation/DFSegmentation.hh @@ -5,24 +5,63 @@ namespace diffCheck::segmentation { class DFSegmentation { - public: + public: ///< main segmentation methods /** @brief Downsamples and segments the point cloud using Cilantro's ConnectedComponentExtraction3f method. It uses the normals' variations to detect different parts in the point cloud. * @param pointCloud the point cloud to segment - * @param voxelSize the voxel size for the downsampling of the point cloud. The point cloud is downsampled after the normal calculation. A lower number will result in a denser point cloud * @param normalThresholdDegree the normal threshold in degrees do differentiate segments. The higher the number, the more tolerent the segmentation will be to normal differences * @param minClusterSize the minimum cluster size to consider a segment. A lower number will discard smaller segments * @param useKnnNeighborhood if true, the neighborhood search will be done using the knnNeighborhoodSize, otherwise it will be done using radiusNeighborhoodSize * @param knnNeighborhoodSize the k nearest neighbors size for the "neighborhood search". This is used when useKnnNeighborhood is true. a higher number will result in smoother segmentation, but at the cost of computation time * @param radiusNeighborhoodSize the radius of the neighborhood size for the "radius search". This is used when useKnnNeighborhood is false. A higher number will result in smoother segmentation, but at the cost of computation time. + * @param colorClusters if true, the clusters will be colored with random colors * @return std::vector> the segmented point clouds */ - static std::vector> SmoothSegmentation( - geometry::DFPointCloud &pointCloud, - float voxelSize = 0.2, - float normalThresholdDegree = 20, + static std::vector> NormalBasedSegmentation( + std::shared_ptr &pointCloud, + float normalThresholdDegree = 20.f, int minClusterSize = 10, bool useKnnNeighborhood = true, int knnNeighborhoodSize = 10, - int radiusNeighborhoodSize = 10); + float radiusNeighborhoodSize = 10.f, + bool colorClusters = false); + + public: ///< segmentation refinement methods + /** @brief Associates point cloud segments to mesh faces and merges them. It uses the center of mass of the segments and the mesh faces to find correspondances. For each mesh face it then iteratively associate the points of the segment that are actually on the mesh face. + * @param referenceMesh the vector of mesh faces to associate with the segments + * @param clusters the vector of clusters from cilantro to associate with the mesh faces of the reference mesh + * @param angleThreshold the threshold to consider the a cluster as potential candidate for association. the value passed is the minimum sine of the angles. A value of 0 requires perfect alignment (angle = 0), while a value of 0.1 allows an angle of 5.7 degrees. + * @param associationThreshold the threshold to consider the points of a segment and a mesh face as associable. It is the ratio between the surface of the closest mesh triangle and the sum of the areas of the three triangles that form the rest of the pyramid described by the mesh triangle and the point we want to associate or not. The lower the number, the more strict the association will be and some poinnts on the mesh face might be wrongfully excluded. + * @return std::shared_ptr The unified segments + */ + static std::shared_ptr DFSegmentation::AssociateClustersToMeshes( + std::vector> referenceMesh, + std::vector> &clusters, + double angleThreshold = 0.1, + double associationThreshold = 0.1); + + /** @brief Iterated through clusters and finds the corresponding mesh face. It then associates the points of the cluster that are on the mesh face to the segment already associated with the mesh face. + * @param unassociatedClusters the clusters from the normal-based segmentatinon that haven't been associated yet. + * @param existingPointCloudSegments the already associated segments + * @param Meshes the mesh faces for all the model. This is used to associate the clusters to the mesh faces. + * * @param angleThreshold the threshold to consider the a cluster as potential candidate for association. the value passed is the minimum sine of the angles. A value of 0 requires perfect alignment (angle = 0), while a value of 0.1 allows an angle of 5.7 degrees. + * @param associationThreshold the threshold to consider the points of a segment and a mesh face as associable. It is the ratio between the surface of the closest mesh triangle and the sum of the areas of the three triangles that form the rest of the pyramid described by the mesh triangle and the point we want to associate or not. The lower the number, the more strict the association will be and some poinnts on the mesh face might be wrongfully excluded. + */ + static void DFSegmentation::CleanUnassociatedClusters( + std::vector> &unassociatedClusters, + std::vector> &existingPointCloudSegments, + std::vector>> Meshes, + double angleThreshold = 0.1, + double associationThreshold = 0.1); + + private: ///< helper methods + /** @brief private method to check if a point is on a face of a triangle mesh triangle, within a certain association threshold. This takes into account the fact that, in 3D, a point can be "above" a triangle of a triangle mesh but still considered as being on the mesh face. + * @param face the triangle mesh face to check the point against + * @param point the point to check + * @param associationThreshold the threshold to consider the point associable to the mesh. It is the ratio between the surface of the closest mesh triangle and the sum of the areas of the three triangles that form the rest of the pyramid described by the mesh triangle and the point we want to associate or not. The lower the number, the more strict the association will be and some poinnts on the mesh face might be wrongfully excluded. + */ + static bool DFSegmentation::IsPointOnFace( + std::shared_ptr face, + Eigen::Vector3d point, + double associationThreshold); }; } // namespace diffCheck::segmentation \ No newline at end of file diff --git a/src/diffCheck/visualizer.cc b/src/diffCheck/visualizer.cc index c979b782..4e61b799 100644 --- a/src/diffCheck/visualizer.cc +++ b/src/diffCheck/visualizer.cc @@ -1,5 +1,6 @@ #include "visualizer.hh" +#include namespace diffCheck::visualizer { @@ -17,13 +18,19 @@ namespace diffCheck::visualizer void Visualizer::Run() { - open3d::visualization::DrawGeometries( - this->m_Geometries, - this->Title, - this->Width, - this->Height, - this->PosX, this->PosY, - this->ShowNormals, - this->ShowWireframe); + auto vis = open3d::visualization::Visualizer(); + vis.CreateVisualizerWindow(this->Title, this->Width, this->Height, this->PosX, this->PosY); + for (auto geometry : this->m_Geometries) + { + vis.AddGeometry(geometry); + } + if (this->RenderPcdColorNormals) + vis.GetRenderOption().point_color_option_ = open3d::visualization::RenderOption::PointColorOption::Normal; + else + vis.GetRenderOption().point_color_option_ = open3d::visualization::RenderOption::PointColorOption::Color; + if (this->ShowNormals) + vis.GetRenderOption().TogglePointShowNormal(); + vis.Run(); + vis.DestroyVisualizerWindow(); } } // namespace diffCheck::visualizer \ No newline at end of file diff --git a/src/diffCheck/visualizer.hh b/src/diffCheck/visualizer.hh index ec0743b2..97f7cd07 100644 --- a/src/diffCheck/visualizer.hh +++ b/src/diffCheck/visualizer.hh @@ -21,11 +21,13 @@ namespace diffCheck::visualizer int height = 800, int posX = 50, int posY = 50, - bool showNormals = false, - bool showWireframe = true + bool showNormals = true, + bool showWireframe = true, + bool renderPcdColorNormals = false ) : Title(title), Width(width), Height(height), PosX(posX), PosY(posY), - ShowNormals(showNormals), ShowWireframe(showWireframe) + ShowNormals(showNormals), ShowWireframe(showWireframe), + RenderPcdColorNormals(renderPcdColorNormals) {} ~Visualizer() = default; @@ -62,6 +64,8 @@ namespace diffCheck::visualizer bool ShowNormals; /// @brief weither to show the wireframe bool ShowWireframe; + /// @brief weither to render the point cloud color normals + bool RenderPcdColorNormals; private: /// @brief the geometries to visualize diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index 78e45887..6342b382 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -1,38 +1,100 @@ #include "diffCheck.hh" +#include "diffCheck/log.hh" #include #include +// checking computation time +#include int main() { + auto initTime = std::chrono::high_resolution_clock::now(); + std::shared_ptr pcdSrc = std::make_shared(); - std::shared_ptr meshSrc = std::make_shared(); + std::vector> meshSrc = std::vector>(); std::vector> segments; - std::string pathMeshSrc = R"(C:\Users\localuser\Downloads\02_mesh.ply)"; - std::string pathPcdSrc = R"(C:\Users\localuser\Downloads\02_points_with_errors_1e6_pts.ply)"; + std::vector meshPaths; + + std::string meshesFolderPath = R"(C:\Users\localuser\Desktop\meshes_for_diffCheck\9\)"; + + for (int i = 1; i <= 7; i++) + { + std::string meshPath = meshesFolderPath + std::to_string(i) + ".ply"; + std::shared_ptr mesh = std::make_shared(); + mesh->LoadFromPLY(meshPath); + meshSrc.push_back(mesh); + } + + std::string pathPcdSrc = R"(C:\Users\localuser\Desktop\meshes_for_diffCheck\source_pc_2.ply)"; pcdSrc->LoadFromPLY(pathPcdSrc); - meshSrc->LoadFromPLY(pathMeshSrc); - segments = diffCheck::segmentation::DFSegmentation::SmoothSegmentation(*pcdSrc, 0.01, 1, 30, true, 50, 30); + pcdSrc->EstimateNormals(false, 100); + pcdSrc->VoxelDownsample(0.01); + auto intermediateTime = std::chrono::high_resolution_clock::now(); + segments = diffCheck::segmentation::DFSegmentation::NormalBasedSegmentation( + pcdSrc, + 6.0f, + 25, + true, + 20, + 0.5f, + false); std::cout << "number of segments:" << segments.size()<< std::endl; - diffCheck::visualizer::Visualizer vis; - vis.AddMesh(meshSrc); + std::shared_ptr unifiedSegments = + diffCheck::segmentation::DFSegmentation::AssociateClustersToMeshes( + meshSrc, + segments, + .1, + .9); + + std::cout << "Association done. refinement in progress" << std::endl; + + diffCheck::segmentation::DFSegmentation::CleanUnassociatedClusters(segments, + std::vector>{unifiedSegments}, + std::vector>>{meshSrc}, + .1, + .9); + + std::cout << "number of points in unified segments:" << unifiedSegments->Points.size() << std::endl; + + diffCheck::visualizer::Visualizer vis(std::string("DiffCheckApp"), 1000, 800, 50, 50, false, true, false); for (auto segment : segments) { // colorize the segments with random colors double r = static_cast(rand()) / RAND_MAX; double g = static_cast(rand()) / RAND_MAX; - double b = static_cast(rand()) / RAND_MAX; + double b = static_cast(rand()) / RAND_MAX; + + segment->Colors.clear(); for (int i = 0; i < segment->Points.size(); i++) { - segment->Colors.push_back(Eigen::Vector3d(r, g, b)); + segment->Colors.push_back(Eigen::Vector3d(0, 0, 0)); } - vis.AddPointCloud(segment); + vis.AddPointCloud(segment); } + for(auto mesh : meshSrc) + { + //vis.AddMesh(mesh); + } + + for (int i = 0; i < unifiedSegments->Points.size(); i++) + { + unifiedSegments->Colors.push_back(Eigen::Vector3d(0, 0, 1)); + } + vis.AddPointCloud(unifiedSegments); + + auto endTime = std::chrono::high_resolution_clock::now(); + auto duration = std::chrono::duration_cast(endTime - initTime); + auto segmentationTime = std::chrono::duration_cast(endTime - intermediateTime); + std::cout << "Total computation time:" << duration.count() << std::endl; + std::cout << "Segmentation time:" << segmentationTime.count() << std::endl; + vis.Run(); + + return 0; } \ No newline at end of file diff --git a/src/diffCheckBindings.cc b/src/diffCheckBindings.cc index 9cdcca75..27efd7c8 100644 --- a/src/diffCheckBindings.cc +++ b/src/diffCheckBindings.cc @@ -39,8 +39,18 @@ PYBIND11_MODULE(diffcheck_bindings, m) { .def("downsample_by_size", &diffCheck::geometry::DFPointCloud::DownsampleBySize, py::arg("target_size")) + .def("estimate_normals", &diffCheck::geometry::DFPointCloud::EstimateNormals, + py::arg("use_cilantro_evaluator") = false, + py::arg("knn") = 100, + py::arg("search_radius") = std::nullopt) + + .def("apply_color", (void (diffCheck::geometry::DFPointCloud::*)(int, int, int)) &diffCheck::geometry::DFPointCloud::ApplyColor, + py::arg("r"), py::arg("g"), py::arg("b")) + .def("load_from_PLY", &diffCheck::geometry::DFPointCloud::LoadFromPLY) + .def("get_tight_bounding_box", &diffCheck::geometry::DFPointCloud::GetTightBoundingBox) + .def("get_num_points", &diffCheck::geometry::DFPointCloud::GetNumPoints) .def("get_num_colors", &diffCheck::geometry::DFPointCloud::GetNumColors) .def("get_num_normals", &diffCheck::geometry::DFPointCloud::GetNumNormals) @@ -68,6 +78,8 @@ PYBIND11_MODULE(diffcheck_bindings, m) { .def("sample_points_uniformly", &diffCheck::geometry::DFMesh::SampleCloudUniform) + .def("get_tight_bounding_box", &diffCheck::geometry::DFMesh::GetTightBoundingBox) + .def("get_num_vertices", &diffCheck::geometry::DFMesh::GetNumVertices) .def("get_num_faces", &diffCheck::geometry::DFMesh::GetNumFaces) @@ -159,12 +171,23 @@ PYBIND11_MODULE(diffcheck_bindings, m) { py::module_ submodule_segmentation = m.def_submodule("dfb_segmentation", "A submodule for the `semantic` segmentation methods."); py::class_(submodule_segmentation, "DFSegmentation") - .def_static("smooth_segmentation", &diffCheck::segmentation::DFSegmentation::SmoothSegmentation, + .def_static("segment_by_normal", &diffCheck::segmentation::DFSegmentation::NormalBasedSegmentation, py::arg("point_cloud"), - py::arg("voxel_size") = 1, - py::arg("normal_threshold_degree") = 20, + py::arg("normal_threshold_degree") = 20.0, py::arg("min_cluster_size") = 10, - py::arg("use_knn_neighborhood") = false, + py::arg("use_knn_neighborhood") = true, py::arg("knn_neighborhood_size") = 10, - py::arg("radius_neighborhood_size") = 10); + py::arg("radius_neighborhood_size") = 0.1, + py::arg("color_clusters") = false) + .def_static("associate_clusters", &diffCheck::segmentation::DFSegmentation::AssociateClustersToMeshes, + py::arg("reference_mesh"), + py::arg("clusters"), + py::arg("angle_threshold") = 0.95, + py::arg("association_threshold") = 0.1) + .def_static("clean_unassociated_clusters", &diffCheck::segmentation::DFSegmentation::CleanUnassociatedClusters, + py::arg("unassociated_clusters"), + py::arg("existing_point_cloud_segments"), + py::arg("meshes"), + py::arg("angle_threshold") = 0.95, + py::arg("association_threshold") = 0.1); } \ No newline at end of file diff --git a/src/gh/components/DF_bind_tester/icon.png b/src/gh/components/DF_bind_tester/icon.png deleted file mode 100644 index 4d26b8ee..00000000 Binary files a/src/gh/components/DF_bind_tester/icon.png and /dev/null differ diff --git a/src/gh/components/DF_build_assembly/code.py b/src/gh/components/DF_build_assembly/code.py new file mode 100644 index 00000000..7581d872 --- /dev/null +++ b/src/gh/components/DF_build_assembly/code.py @@ -0,0 +1,44 @@ +#! python3 + +import System +import typing + +import Rhino +import Rhino.Geometry as rg +import scriptcontext as sc + +from ghpythonlib.componentbase import executingcomponent as component + +import diffCheck +from diffCheck.df_geometries import DFBeam, DFAssembly + + +class DFBuildAssembly(component): + def RunScript(self, + i_assembly_name, + i_breps : System.Collections.Generic.IList[Rhino.Geometry.Brep]): + """ + This component parse a series of breps representing a timber structure or a + timber elements into a DFAssembly object. + + :param i_assembly_name: the name of the assembly + :param i_breps: list of breps + + :return o_assembly: the DFAssembly object + """ + beams: typing.List[DFBeam] = [] + for brep in i_breps: + beam = DFBeam.from_brep_face(brep) + beams.append(beam) + + o_assembly = DFAssembly(beams, i_assembly_name) + + return o_assembly + + +# if __name__ == "__main__": +# comp = DFBuildAssembly() +# o_assembly = comp.RunScript( +# i_assembly_name, +# i_breps +# ) diff --git a/src/gh/components/DF_build_assembly/icon.png b/src/gh/components/DF_build_assembly/icon.png new file mode 100644 index 00000000..6735fe70 Binary files /dev/null and b/src/gh/components/DF_build_assembly/icon.png differ diff --git a/src/gh/components/DF_scan_segmentation/metadata.json b/src/gh/components/DF_build_assembly/metadata.json similarity index 56% rename from src/gh/components/DF_scan_segmentation/metadata.json rename to src/gh/components/DF_build_assembly/metadata.json index 0863eaf1..a0355271 100644 --- a/src/gh/components/DF_scan_segmentation/metadata.json +++ b/src/gh/components/DF_build_assembly/metadata.json @@ -1,11 +1,11 @@ { - "name": "DFScanSegmentation", - "nickname": "Geo2Pcd", + "name": "DFBuildAssembly", + "nickname": "DFBuildAssembly", "category": "diffCheck", - "subcategory": "Cloud", - "description": "Segments a point cloud from a list of breps.", + "subcategory": "Structure", + "description": "This component parse a series of breps representing a timber structure or a timber elements into a DFAssembly object.", "exposure": 4, - "instanceGuid": "08a53777-80c0-454a-b016-4d924fc5934c", + "instanceGuid": "bf6f47fe-2a7e-47b5-b1c4-c716c524d245", "ghpython": { "hideOutput": true, "hideInput": true, @@ -14,35 +14,35 @@ "iconDisplay": 2, "inputParameters": [ { - "name": "i_breps", - "nickname": "i_breps", - "description": "Breps to segment the point cloud.", - "optional": true, + "name": "i_assembly_name", + "nickname": "i_assembly_name", + "description": "The name of the assembly to export.", + "optional": false, "allowTreeAccess": true, "showTypeHints": true, "scriptParamAccess": "item", "wireDisplay": "default", "sourceCount": 0, - "typeHintID": "brep" + "typeHintID": "str" }, { - "name": "i_scan", - "nickname": "i_scan", - "description": "The point cloud of the scan.", - "optional": false, + "name": "i_breps", + "nickname": "i_breps", + "description": "The breps of the structure.", + "optional": true, "allowTreeAccess": true, "showTypeHints": true, - "scriptParamAccess": "item", + "scriptParamAccess": "list", "wireDisplay": "default", "sourceCount": 0, - "typeHintID": "pointcloud" + "typeHintID": "brep" } ], "outputParameters": [ { - "name": "o_rh_segmented_cloud", - "nickname": "o_rh_segmented_cloud", - "description": "The output segmented cloud.", + "name": "o_assembly", + "nickname": "o_assembly", + "description": "The create DFAssembly object representing the timber elements.", "optional": false, "sourceCount": 0, "graft": false diff --git a/src/gh/components/DF_cloud_normal_estimator/code.py b/src/gh/components/DF_cloud_normal_estimator/code.py new file mode 100644 index 00000000..92fa9691 --- /dev/null +++ b/src/gh/components/DF_cloud_normal_estimator/code.py @@ -0,0 +1,52 @@ +#! python3 + +import System + +import Rhino +import Rhino.Geometry as rg +from ghpythonlib.componentbase import executingcomponent as component + +import diffCheck +import diffCheck.df_geometries +from diffCheck import df_cvt_bindings + +class DFCloudNormalEstimator(component): + def RunScript(self, + i_cloud : rg.PointCloud = None, + i_knn : int = None, + i_radius : float = None, + i_switch_mode : bool = True + ): + """ + Evaluaate the n ormals of a point cloud. + + :param i_cloud: Point cloud to evaluate normals. + :i_knn: Number of nearest neighbors to consider. + :i_radius: Radius of the search. + :i_switch_mode: Switch between Open3d (true) or Cilantro (false) library. + """ + o_cloud = rg.PointCloud() + + df_cloud = df_cvt_bindings.cvt_rhcloud_2_dfcloud(i_cloud) + + if i_knn is None: + i_knn = 100 + + df_cloud.estimate_normals( + use_cilantro_evaluator=i_switch_mode, + knn=i_knn, + search_radius=i_radius + ) + + o_cloud = df_cvt_bindings.cvt_dfcloud_2_rhcloud(df_cloud) + + return o_cloud + +# if __name__ == "__main__": +# comp = DFCloudNormalEstimator() +# o_cloud = comp.RunScript( +# i_cloud, +# i_knn, +# i_radius, +# i_switch_mode +# ) \ No newline at end of file diff --git a/src/gh/components/DF_cloud_normal_estimator/icon.png b/src/gh/components/DF_cloud_normal_estimator/icon.png new file mode 100644 index 00000000..c8b9fe65 Binary files /dev/null and b/src/gh/components/DF_cloud_normal_estimator/icon.png differ diff --git a/src/gh/components/DF_cloud_normal_estimator/metadata.json b/src/gh/components/DF_cloud_normal_estimator/metadata.json new file mode 100644 index 00000000..5d95e4e8 --- /dev/null +++ b/src/gh/components/DF_cloud_normal_estimator/metadata.json @@ -0,0 +1,76 @@ +{ + "name": "DFCloudNormalEstimator", + "nickname": "DFCNormEstim", + "category": "diffCheck", + "subcategory": "Cloud", + "description": "Evaluate the normals of a point cloud.", + "exposure": 4, + "instanceGuid": "9dbd7326-edf4-42ca-960e-818ab22dabfc", + "ghpython": { + "hideOutput": true, + "hideInput": true, + "isAdvancedMode": true, + "marshalOutGuids": true, + "iconDisplay": 2, + "inputParameters": [ + { + "name": "i_cloud", + "nickname": "i_cloud", + "description": "The point cloud to evaluate.", + "optional": true, + "allowTreeAccess": true, + "showTypeHints": true, + "scriptParamAccess": "item", + "wireDisplay": "default", + "sourceCount": 0, + "typeHintID": "pointcloud" + }, + { + "name": "i_knn", + "nickname": "i_knn", + "description": "The knn search value (by default 100).", + "optional": true, + "allowTreeAccess": true, + "showTypeHints": true, + "scriptParamAccess": "item", + "wireDisplay": "default", + "sourceCount": 0, + "typeHintID": "int" + }, + { + "name": "i_radius", + "nickname": "i_radius", + "description": "The radius search. If value is provided the search will be hybrid.", + "optional": true, + "allowTreeAccess": true, + "showTypeHints": true, + "scriptParamAccess": "item", + "wireDisplay": "default", + "sourceCount": 0, + "typeHintID": "int" + }, + { + "name": "i_bool", + "nickname": "i_bool", + "description": "Switch between Open3d (true) or Cilantro (false) library. Default is Open3d.", + "optional": true, + "allowTreeAccess": true, + "showTypeHints": true, + "scriptParamAccess": "item", + "wireDisplay": "default", + "sourceCount": 0, + "typeHintID": "bool" + } + ], + "outputParameters": [ + { + "name": "o_cloud", + "nickname": "o_cloud", + "description": "The cloud with normals computed.", + "optional": false, + "sourceCount": 0, + "graft": false + } + ] + } +} \ No newline at end of file diff --git a/src/gh/components/DF_deconstruct_assembly/code.py b/src/gh/components/DF_deconstruct_assembly/code.py new file mode 100644 index 00000000..f4c0686a --- /dev/null +++ b/src/gh/components/DF_deconstruct_assembly/code.py @@ -0,0 +1,35 @@ +#! python3 + +import System +import typing + +import Rhino +import Rhino.Geometry as rg +import scriptcontext as sc + +from ghpythonlib.componentbase import executingcomponent as component + +import diffCheck +from diffCheck.df_geometries import DFBeam, DFAssembly + + +class DFDeconstructAssembly(component): + def RunScript(self, + i_assembly): + """ + Deconstruct the DFAssembly into a set of df_beams objects. + + :param i_assembly: the DFAssembly object + + :return o_beams + """ + o_beams = i_assembly.beams + + return o_beams + + +# if __name__ == "__main__": +# comp = DFDeconstructAssembly() +# o_beams = comp.RunScript( +# i_assembly +# ) diff --git a/src/gh/components/DF_deconstruct_assembly/icon.png b/src/gh/components/DF_deconstruct_assembly/icon.png new file mode 100644 index 00000000..1c9ebbb4 Binary files /dev/null and b/src/gh/components/DF_deconstruct_assembly/icon.png differ diff --git a/src/gh/components/DF_deconstruct_assembly/metadata.json b/src/gh/components/DF_deconstruct_assembly/metadata.json new file mode 100644 index 00000000..8bed1bef --- /dev/null +++ b/src/gh/components/DF_deconstruct_assembly/metadata.json @@ -0,0 +1,40 @@ +{ + "name": "DFDeconstructAssembly", + "nickname": "DFDeconstructAssembly", + "category": "diffCheck", + "subcategory": "Structure", + "description": "Deconstruct the DFAssembly into a set of df_beams objects.", + "exposure": 4, + "instanceGuid": "43098147-78a1-41ce-863d-e48337cb8cd5", + "ghpython": { + "hideOutput": true, + "hideInput": true, + "isAdvancedMode": true, + "marshalOutGuids": true, + "iconDisplay": 2, + "inputParameters": [ + { + "name": "i_assembly", + "nickname": "i_assembly", + "description": "The DFAssembly object to deconstruct.", + "optional": false, + "allowTreeAccess": true, + "showTypeHints": true, + "scriptParamAccess": "item", + "wireDisplay": "default", + "sourceCount": 0, + "typeHintID": "ghdoc" + } + ], + "outputParameters": [ + { + "name": "o_beams", + "nickname": "o_beams", + "description": "The set of beams contained by this DFAssembly object.", + "optional": false, + "sourceCount": 0, + "graft": false + } + ] + } +} \ No newline at end of file diff --git a/src/gh/components/DF_deconstruct_beam/code.py b/src/gh/components/DF_deconstruct_beam/code.py new file mode 100644 index 00000000..89f46070 --- /dev/null +++ b/src/gh/components/DF_deconstruct_beam/code.py @@ -0,0 +1,41 @@ +#! python3 + +import System +import typing + +import Rhino +import Rhino.Geometry as rg +import scriptcontext as sc + +from ghpythonlib.componentbase import executingcomponent as component + +import diffCheck +from diffCheck.df_geometries import DFBeam, DFAssembly + + +class DFDeconstructBeam(component): + def RunScript(self, + i_beams : typing.List[DFBeam]): + """ + Deconstruct the DFBeam object into Rhino objects. + + :param i_beams: the DFBeam objects + + :return o_side_faces: the side joints of the beam + :return o_joint_faces: the face joints of the beam + :return o_joint_ids: the ids for each face joint + """ + o_side_faces, o_joint_faces, o_joint_ids, o_breps = [], [], [], [] + + for i_b in i_beams: + o_side_faces = [f.to_brep_face() for f in i_b.side_faces] + o_joint_faces = [f.to_brep_face() for f in i_b.joint_faces] + o_joint_ids = [f.joint_id for f in i_b.joint_faces] + + return o_side_faces, o_joint_faces, o_joint_ids + +# if __name__ == "__main__": +# comp = DFDeconstructBeam() +# o_side_faces, o_joint_faces, o_joint_ids = comp.RunScript( +# i_beams +# ) diff --git a/src/gh/components/DF_deconstruct_beam/icon.png b/src/gh/components/DF_deconstruct_beam/icon.png new file mode 100644 index 00000000..ed9e81dd Binary files /dev/null and b/src/gh/components/DF_deconstruct_beam/icon.png differ diff --git a/src/gh/components/DF_deconstruct_beam/metadata.json b/src/gh/components/DF_deconstruct_beam/metadata.json new file mode 100644 index 00000000..d6077a73 --- /dev/null +++ b/src/gh/components/DF_deconstruct_beam/metadata.json @@ -0,0 +1,57 @@ +{ + "name": "DFDeconstructBeam", + "nickname": "DFDeconstructBeam", + "category": "diffCheck", + "subcategory": "Structure", + "description": "Deconstruct the DFBeam objects into semantic Rhino objects.", + "exposure": 4, + "instanceGuid": "c052b02b-87f2-44ed-8fe7-e2b1f34edcf0", + "ghpython": { + "hideOutput": true, + "hideInput": true, + "isAdvancedMode": true, + "marshalOutGuids": true, + "iconDisplay": 2, + "inputParameters": [ + { + "name": "i_beams", + "nickname": "i_beams", + "description": "The DFBeam objects to deconstruct.", + "optional": false, + "allowTreeAccess": true, + "showTypeHints": true, + "scriptParamAccess": "list", + "wireDisplay": "default", + "sourceCount": 0, + "typeHintID": "ghdoc", + "graft": true + } + ], + "outputParameters": [ + { + "name": "o_side_faces", + "nickname": "o_side_faces", + "description": "The side faces of as Breps of the beam.", + "optional": false, + "sourceCount": 0, + "graft": false + }, + { + "name": "o_joint_faces", + "nickname": "o_joint_faces", + "description": "The faces as Breps belonging to joints of the beam.", + "optional": false, + "sourceCount": 0, + "graft": false + }, + { + "name": "o_joint_ids", + "nickname": "o_joint_ids", + "description": "An integer indicating to which joint the joint faces are belonging to.", + "optional": false, + "sourceCount": 0, + "graft": false + } + ] + } +} \ No newline at end of file diff --git a/src/gh/components/DF_normal_segmentator/code.py b/src/gh/components/DF_normal_segmentator/code.py new file mode 100644 index 00000000..65573326 --- /dev/null +++ b/src/gh/components/DF_normal_segmentator/code.py @@ -0,0 +1,74 @@ +#! python3 + +import System +import typing + +import Rhino +import Rhino.Geometry as rg +from ghpythonlib.componentbase import executingcomponent as component + +import Grasshopper as gh +from Grasshopper.Kernel import GH_RuntimeMessageLevel as RML + +import diffCheck +import diffCheck.df_geometries +from diffCheck.diffcheck_bindings import dfb_segmentation + +from diffCheck import df_cvt_bindings + + +class DFCloudNormalSegmentator(component): + def RunScript(self, + i_cloud, + i_normal_threshold_degree=None, + i_min_cluster_size=None, + i_use_knn_neighborhood=None, + i_knn_neighborhood_size=None, + i_radius_neighborhood_size=None + ) -> rg.PointCloud: + """ + Segment a point cloud into clusters based on normals. + + :param i_cloud: Point cloud to segment. + :param i_normal_threshold_degree: Threshold in degrees to consider a normal as a cluster. + :param i_min_cluster_size: Minimum size of a cluster. + :param i_use_knn_neighborhood: Use KNN neighborhood. + :param i_knn_neighborhood_size: Size of the KNN neighborhood. + :param i_radius_neighborhood_size: Size of the radius neighborhood. + """ + o_clusters = [] + df_cloud = df_cvt_bindings.cvt_rhcloud_2_dfcloud(i_cloud) + + if i_normal_threshold_degree is None: + i_normal_threshold_degree = 20 + if i_min_cluster_size is None: + i_min_cluster_size = 10 + if i_use_knn_neighborhood is None: + i_use_knn_neighborhood = True + if i_knn_neighborhood_size is None: + i_knn_neighborhood_size = 30 + if i_radius_neighborhood_size is None: + i_radius_neighborhood_size = 0.1 + + o_clusters = dfb_segmentation.DFSegmentation.segment_by_normal( + point_cloud=df_cloud, + + normal_threshold_degree=i_normal_threshold_degree, + min_cluster_size=i_min_cluster_size, + use_knn_neighborhood=i_use_knn_neighborhood, + knn_neighborhood_size=i_knn_neighborhood_size, + radius_neighborhood_size=i_radius_neighborhood_size + ) + + return [df_cvt_bindings.cvt_dfcloud_2_rhcloud(cluster) for cluster in o_clusters] + +# if __name__ == "__main__": +# com = DFCloudNormalSegmentator() +# o_clusters = com.RunScript( +# i_cloud, +# i_normal_threshold_degree, +# i_min_cluster_size, +# i_use_knn_neighborhood, +# i_knn_neighborhood_size, +# i_radius_neighborhood_size +# ) \ No newline at end of file diff --git a/src/gh/components/DF_normal_segmentator/icon.png b/src/gh/components/DF_normal_segmentator/icon.png new file mode 100644 index 00000000..9bf55eef Binary files /dev/null and b/src/gh/components/DF_normal_segmentator/icon.png differ diff --git a/src/gh/components/DF_normal_segmentator/metadata.json b/src/gh/components/DF_normal_segmentator/metadata.json new file mode 100644 index 00000000..da03f461 --- /dev/null +++ b/src/gh/components/DF_normal_segmentator/metadata.json @@ -0,0 +1,100 @@ +{ + "name": "DFNormalSegmentator", + "nickname": "DFCNorSeg", + "category": "diffCheck", + "subcategory": "Segmentation", + "description": "Cluster a point cloud based on normals.", + "exposure": 4, + "instanceGuid": "8f732cef-771c-41b8-acca-562211fd3a80", + "ghpython": { + "hideOutput": true, + "hideInput": true, + "isAdvancedMode": true, + "marshalOutGuids": true, + "iconDisplay": 2, + "inputParameters": [ + { + "name": "i_cloud", + "nickname": "i_cloud", + "description": "The point cloud to reduce the size.", + "optional": true, + "allowTreeAccess": true, + "showTypeHints": true, + "scriptParamAccess": "item", + "wireDisplay": "default", + "sourceCount": 0, + "typeHintID": "pointcloud" + }, + { + "name": "i_normal_threshold_degree", + "nickname": "i_normal_threshold_degree", + "description": "The normal threshold in degrees (under that it consider to the same cluster).", + "optional": false, + "allowTreeAccess": true, + "showTypeHints": true, + "scriptParamAccess": "item", + "wireDisplay": "default", + "sourceCount": 0, + "typeHintID": "float" + }, + { + "name": "i_min_cluster_size", + "nickname": "i_min_cluster_size", + "description": "The smallest cluster allowed.", + "optional": false, + "allowTreeAccess": true, + "showTypeHints": true, + "scriptParamAccess": "item", + "wireDisplay": "default", + "sourceCount": 0, + "typeHintID": "int" + }, + { + "name": "i_use_knn_neighborhood", + "nickname": "i_use_knn_neighborhood", + "description": "If true use knn, otherwise radius search.", + "optional": false, + "allowTreeAccess": true, + "showTypeHints": true, + "scriptParamAccess": "item", + "wireDisplay": "default", + "sourceCount": 0, + "typeHintID": "bool" + }, + { + "name": "i_knn_neighborhood_size", + "nickname": "i_knn_neighborhood_size", + "description": "The knn size.", + "optional": false, + "allowTreeAccess": true, + "showTypeHints": true, + "scriptParamAccess": "item", + "wireDisplay": "default", + "sourceCount": 0, + "typeHintID": "int" + }, + { + "name": "i_radius_neighborhood_size", + "nickname": "i_radius_neighborhood_size", + "description": "The size of the radius.", + "optional": false, + "allowTreeAccess": true, + "showTypeHints": true, + "scriptParamAccess": "item", + "wireDisplay": "default", + "sourceCount": 0, + "typeHintID": "float" + } + ], + "outputParameters": [ + { + "name": "o_clusters", + "nickname": "o_clusters", + "description": "The segmented clouds.", + "optional": false, + "sourceCount": 0, + "graft": false + } + ] + } +} \ No newline at end of file diff --git a/src/gh/components/DF_scan_segmentation/code.py b/src/gh/components/DF_scan_segmentation/code.py deleted file mode 100644 index 101cbd56..00000000 --- a/src/gh/components/DF_scan_segmentation/code.py +++ /dev/null @@ -1,18 +0,0 @@ -import Rhino -import diffCheck.df_cvt_bindings as df_cvt -import diffCheck.df_geometries as df_geo -import diffCheck.diffcheck_bindings as df_bindings - -def main(scan, voxel_size, normal_threshold, min_cluster_size, knn_neighborhood_size): - a = [] - df_scan = df_cvt.cvt_rhcloud_2_dfcloud(scan) - res = df_bindings.dfb_segmentation.DFSegmentation.segmentation_point_cloud(df_scan, voxel_size, normal_threshold, min_cluster_size, True, 10, knn_neighborhood_size) - print(len(res)) - for pc in res: - rh_pc = df_cvt.cvt_dfcloud_2_rhcloud(pc) - a.append(rh_pc) - return a - -if __name__ == "__main__": - a = main(scan, voxel_size, normal_threshold, min_cluster_size, knn) - pass \ No newline at end of file diff --git a/src/gh/components/DF_bind_tester/code.py b/src/gh/components/DF_tester/code.py similarity index 96% rename from src/gh/components/DF_bind_tester/code.py rename to src/gh/components/DF_tester/code.py index a2913c89..6292bdbd 100644 --- a/src/gh/components/DF_bind_tester/code.py +++ b/src/gh/components/DF_tester/code.py @@ -12,7 +12,7 @@ import diffCheck from diffCheck import diffcheck_bindings -class DFBindTester(component): +class DFTester(component): def RunScript(self): """ The component test and import bind module for diffCheck. diff --git a/src/gh/components/DF_tester/icon.png b/src/gh/components/DF_tester/icon.png new file mode 100644 index 00000000..2d3b6867 Binary files /dev/null and b/src/gh/components/DF_tester/icon.png differ diff --git a/src/gh/components/DF_bind_tester/metadata.json b/src/gh/components/DF_tester/metadata.json similarity index 83% rename from src/gh/components/DF_bind_tester/metadata.json rename to src/gh/components/DF_tester/metadata.json index 96debba5..6ed3ebac 100644 --- a/src/gh/components/DF_bind_tester/metadata.json +++ b/src/gh/components/DF_tester/metadata.json @@ -1,9 +1,9 @@ { - "name": "DFBindTester", - "nickname": "BindT", + "name": "DFTester", + "nickname": "DFT", "category": "diffCheck", "subcategory": "Utility", - "description": "This component is testing the binding import of diffCheck.", + "description": "This component is testing diffCheck imports and bindings.", "exposure": 4, "instanceGuid": "7a600924-29bb-4682-8b95-a37752cefdbc", "ghpython": { diff --git a/src/gh/components/DF_xml_exporter/code.py b/src/gh/components/DF_xml_exporter/code.py index aeca5c84..01ec7e76 100644 --- a/src/gh/components/DF_xml_exporter/code.py +++ b/src/gh/components/DF_xml_exporter/code.py @@ -5,73 +5,38 @@ import Rhino import Rhino.Geometry as rg +import scriptcontext as sc from ghpythonlib.componentbase import executingcomponent as component -import diffCheck -from diffCheck.df_geometries import DFBeam, DFAssembly - class DFXMLExporter(component): def RunScript(self, i_dump: bool, - i_assembly_name, i_export_dir, - i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep]): + i_assembly): """ - This read breps from Rhino, converts them to DFBeams and DFAssemblies, and exports them to XML. + Export the DFAssembly to XML. :param i_dump: whether to dump the xml - :param i_export_dir: directory to export the xml - :param i_breps: list of breps - """ - # beams - # beams: typing.List[DFBeam] = [] - # for brep in i_breps: - # beam = DFBeam.from_brep(brep) - # beams.append(beam) - - # # assembly - # assembly1 = DFAssembly(beams, i_assembly_name) - - # # dump the xml - # xml: str = assembly1.to_xml() - # if i_dump: - # assembly1.dump_xml(xml, i_export_dir) - # o_xml = xml - - # # show the joint/side faces - # o_joints = [jf.to_brep() for jf in assembly1.all_joint_faces] - # o_sides = [sf.to_brep() for sf in assembly1.all_side_faces] - - ########################### - - faces, o_debug = diffCheck.df_joint_detector.JointDetector(i_breps[0]).run() - - # o_joints = [f.to_brep() for f in faces] - # o_sides = [f.to_brep() for f in faces] + :param i_assembly: the assembly to export - o_xml = "" - o_joints = [] - o_sides = [] - - for f in faces: - if f[1] != None: - o_joints.append(f[0]) - else: - o_sides.append(f[0]) - - - - - return o_xml, o_joints, o_sides, o_debug - - -if __name__ == "__main__": - com = DFXMLExporter() - o_xml, o_joints, o_sides, o_debug = com.RunScript( - i_dump, - i_assembly_name, - i_export_dir, - i_breps - ) \ No newline at end of file + :return o_xml: the xml string + """ + # dump the xml + o_xml = None + xml: str = i_assembly.to_xml() + if i_dump: + i_assembly.dump_xml(xml, i_export_dir) + o_xml = xml + + return o_xml + + +# if __name__ == "__main__": +# com = DFXMLExporter() +# o_xml = com.RunScript( +# i_dump, +# i_export_dir, +# i_assembly, +# ) \ No newline at end of file diff --git a/src/gh/components/DF_xml_exporter/icon.png b/src/gh/components/DF_xml_exporter/icon.png index 13a4fcfd..56e9ae1d 100644 Binary files a/src/gh/components/DF_xml_exporter/icon.png and b/src/gh/components/DF_xml_exporter/icon.png differ diff --git a/src/gh/components/DF_xml_exporter/metadata.json b/src/gh/components/DF_xml_exporter/metadata.json index a9d8cda0..bc51edab 100644 --- a/src/gh/components/DF_xml_exporter/metadata.json +++ b/src/gh/components/DF_xml_exporter/metadata.json @@ -3,7 +3,7 @@ "nickname": "XMLout", "category": "diffCheck", "subcategory": "Utility", - "description": "This component reads breps, convert them to DFBeams and DFAssemblies and export it to XML.", + "description": "This component reads a DFAssembly object to export it to XML.", "exposure": 4, "instanceGuid": "cdae4bd5-d18e-4b06-9367-791b6b1f6837", "ghpython": { @@ -16,7 +16,7 @@ { "name": "i_dump", "nickname": "i_dump", - "description": "Press button to export xml", + "description": "Button to export the xml.", "optional": true, "allowTreeAccess": true, "showTypeHints": true, @@ -25,22 +25,10 @@ "sourceCount": 0, "typeHintID": "bool" }, - { - "name": "i_assembly_name", - "nickname": "i_assembly_name", - "description": "The name of the assembly to export.", - "optional": false, - "allowTreeAccess": true, - "showTypeHints": true, - "scriptParamAccess": "item", - "wireDisplay": "default", - "sourceCount": 0, - "typeHintID": "str" - }, { "name": "i_export_dir", "nickname": "i_export_dir", - "description": "The directors where to export the xml file.", + "description": "The folder where to export the xml.", "optional": true, "allowTreeAccess": true, "showTypeHints": true, @@ -50,16 +38,16 @@ "typeHintID": "str" }, { - "name": "i_breps", - "nickname": "i_breps", - "description": "The breps of the structure.", + "name": "i_assembly", + "nickname": "i_assembly", + "description": "The assembly object", "optional": true, "allowTreeAccess": true, "showTypeHints": true, - "scriptParamAccess": "list", + "scriptParamAccess": "item", "wireDisplay": "default", "sourceCount": 0, - "typeHintID": "brep" + "typeHintID": "ghdoc" } ], "outputParameters": [ @@ -70,22 +58,6 @@ "optional": false, "sourceCount": 0, "graft": false - }, - { - "name": "o_joints", - "nickname": "o_joints", - "description": "The breps of the faces belonging to joints.", - "optional": false, - "sourceCount": 0, - "graft": false - }, - { - "name": "o_sides", - "nickname": "o_sides", - "description": "The breps of the faces belonging to sides.", - "optional": false, - "sourceCount": 0, - "graft": false } ] } diff --git a/src/gh/diffCheck/diffCheck.egg-info/SOURCES.txt b/src/gh/diffCheck/diffCheck.egg-info/SOURCES.txt index 612daf74..6fa596bc 100644 --- a/src/gh/diffCheck/diffCheck.egg-info/SOURCES.txt +++ b/src/gh/diffCheck/diffCheck.egg-info/SOURCES.txt @@ -6,7 +6,6 @@ diffCheck/df_geometries.py diffCheck/df_joint_detector.py diffCheck/df_transformations.py diffCheck/df_util.py -diffCheck/diffcheck_bindings.cp39-win_amd64.pyd diffCheck.egg-info/PKG-INFO diffCheck.egg-info/SOURCES.txt diffCheck.egg-info/dependency_links.txt diff --git a/src/gh/diffCheck/diffCheck/__pycache__/__init__.cpython-39.pyc b/src/gh/diffCheck/diffCheck/__pycache__/__init__.cpython-39.pyc deleted file mode 100644 index 7a72282f..00000000 Binary files a/src/gh/diffCheck/diffCheck/__pycache__/__init__.cpython-39.pyc and /dev/null differ diff --git a/src/gh/diffCheck/diffCheck/__pycache__/df_geometries.cpython-39.pyc b/src/gh/diffCheck/diffCheck/__pycache__/df_geometries.cpython-39.pyc deleted file mode 100644 index 1eb2ab9b..00000000 Binary files a/src/gh/diffCheck/diffCheck/__pycache__/df_geometries.cpython-39.pyc and /dev/null differ diff --git a/src/gh/diffCheck/diffCheck/__pycache__/df_joint_detector.cpython-39.pyc b/src/gh/diffCheck/diffCheck/__pycache__/df_joint_detector.cpython-39.pyc deleted file mode 100644 index e1552964..00000000 Binary files a/src/gh/diffCheck/diffCheck/__pycache__/df_joint_detector.cpython-39.pyc and /dev/null differ diff --git a/src/gh/diffCheck/diffCheck/__pycache__/df_transformations.cpython-39.pyc b/src/gh/diffCheck/diffCheck/__pycache__/df_transformations.cpython-39.pyc deleted file mode 100644 index 2cf666ee..00000000 Binary files a/src/gh/diffCheck/diffCheck/__pycache__/df_transformations.cpython-39.pyc and /dev/null differ diff --git a/src/gh/diffCheck/diffCheck/__pycache__/df_util.cpython-39.pyc b/src/gh/diffCheck/diffCheck/__pycache__/df_util.cpython-39.pyc deleted file mode 100644 index ebe829d4..00000000 Binary files a/src/gh/diffCheck/diffCheck/__pycache__/df_util.cpython-39.pyc and /dev/null differ diff --git a/src/gh/diffCheck/diffCheck/df_cvt_bindings.py b/src/gh/diffCheck/diffCheck/df_cvt_bindings.py index 6baca61d..dc614ccd 100644 --- a/src/gh/diffCheck/diffCheck/df_cvt_bindings.py +++ b/src/gh/diffCheck/diffCheck/df_cvt_bindings.py @@ -6,6 +6,7 @@ import Rhino import Rhino.Geometry as rg +import scriptcontext as sc from diffCheck import diffcheck_bindings @@ -35,8 +36,7 @@ def cvt_rhcloud_2_dfcloud(rh_cloud) -> diffcheck_bindings.dfb_geometry.DFPointCl # colors if rh_cloud.ContainsColors: - # df_cloud.colors = [c for c in rh_cloud.GetColors()] - df_cloud.colors = [[c.R, c.G, c.B] for c in rh_cloud.GetColors()] + df_cloud.colors = [[c.R / 255.0, c.G / 255.0, c.B / 255.0] for c in rh_cloud.GetColors()] return df_cloud @@ -64,6 +64,12 @@ def cvt_dfcloud_2_rhcloud(df_cloud): df_cloud_points = [rg.Point3d(pt[0], pt[1], pt[2]) for pt in df_cloud_points] df_cloud_normals = [rg.Vector3d(n[0], n[1], n[2]) for n in df_cloud_normals] df_cloud_colors = [Rhino.Display.Color4f(c[0], c[1], c[2], 1.0) for c in df_cloud_colors] + + + # df_cloud_colors = [] + # # convert the colors from 0-1 to 0-255 + # for c in df_cloud_colors: + # df_cloud_colors.append(Rhino.Display.Color4f(c[0] * 255, c[1] * 255, c[2] * 255, 255)) rh_cloud = rg.PointCloud() @@ -188,3 +194,32 @@ def cvt_dfxform_2_rhxform(df_xform : diffcheck_bindings.dfb_transformation.DFTra rh_xform = rh_xform * rg.Transform.Rotation(rotation[0], rg.Vector3d(rotation[1], rotation[2], rotation[3]), rg.Point3d(0, 0, 0)) return rh_xform +def cvt_dfOBB_2_rhbrep(df_OBB) -> rg.Box: + """ Convert a diffCheck OBB to a Rhino Brep. + + :param df_OBB: diffCheck OBB + + :return rh_obb_brep: the brep box object + """ + rh_pts = [] + for pt in df_OBB: + rh_pts.append(rg.Point3d(pt[0], pt[1], pt[2])) + + surfaces = [] + surfaces.append(rg.NurbsSurface.CreateFromCorners(rh_pts[0], rh_pts[1], rh_pts[7], rh_pts[2])) + surfaces.append(rg.NurbsSurface.CreateFromCorners(rh_pts[0], rh_pts[1], rh_pts[6], rh_pts[3])) + surfaces.append(rg.NurbsSurface.CreateFromCorners(rh_pts[3], rh_pts[6], rh_pts[4], rh_pts[5])) + surfaces.append(rg.NurbsSurface.CreateFromCorners(rh_pts[2], rh_pts[7], rh_pts[4], rh_pts[5])) + surfaces.append(rg.NurbsSurface.CreateFromCorners(rh_pts[1], rh_pts[6], rh_pts[4], rh_pts[7])) + surfaces.append(rg.NurbsSurface.CreateFromCorners(rh_pts[0], rh_pts[3], rh_pts[5], rh_pts[2])) + + rh_obb_brep = rg.Brep.JoinBreps([rg.Brep.CreateFromSurface(srf) for srf in surfaces], sc.doc.ModelAbsoluteTolerance)[0] + + if rh_obb_brep is None: + raise ValueError("The OBB could not be converted to a Rhino Brep") + if not rh_obb_brep.IsValid: + raise ValueError("The OBB Rhino Brep is not valid") + if not rh_obb_brep.IsSolid: + raise ValueError("The OBB Rhino Brep is not solid") + + return rh_obb_brep diff --git a/src/gh/diffCheck/diffCheck/df_geometries.py b/src/gh/diffCheck/diffCheck/df_geometries.py index 47dbff55..6f0811ce 100644 --- a/src/gh/diffCheck/diffCheck/df_geometries.py +++ b/src/gh/diffCheck/diffCheck/df_geometries.py @@ -7,6 +7,8 @@ import Rhino import Rhino.Geometry as rg +from Grasshopper.Kernel import GH_RuntimeMessageLevel as RML + import xml.etree.ElementTree as ET from xml.dom.minidom import parseString @@ -77,6 +79,11 @@ def __post_init__(self): self.__is_joint = False self.__id = uuid.uuid4().int + # if df_face is created from a rhino brep face, we store the rhino brep face + self._rh_brepface = None + + self.is_cylinder = False + def __repr__(self): return f"Face id: {len(self.id)}, IsJoint: {self.is_joint} Loops: {len(self.all_loops)}" @@ -93,11 +100,12 @@ def __hash__(self): def __eq__(self, other): if isinstance(other, DFFace): + # check if return self.all_loops == other.all_loops return False @classmethod - def from_brep(cls, brep_face: rg.BrepFace, joint_id: int = None): + def from_brep_face(cls, brep_face: rg.BrepFace, joint_id: int = None): """ Create a DFFace from a Rhino Brep face @@ -107,6 +115,11 @@ def from_brep(cls, brep_face: rg.BrepFace, joint_id: int = None): """ all_loops = [] + if brep_face.IsCylinder(): + cls.is_cylinder = True + df_face._rh_brepface = brep_face + return df_face + for idx, loop in enumerate(brep_face.Loops): loop_trims = loop.Trims loop_curve = loop.To3dCurve() @@ -119,16 +132,24 @@ def from_brep(cls, brep_face: rg.BrepFace, joint_id: int = None): all_loops.append(loop) df_face = cls(all_loops, joint_id) - df_face._brepface = brep_face + df_face._rh_brepface = brep_face return df_face - def to_brep(self): + def to_brep_face(self): """ Convert the face to a Rhino Brep planar face :return brep_face: The Rhino Brep planar face """ + if self._rh_brepface is not None: + return self._rh_brepface + + if self.is_cylinder: + ghenv.Component.AddRuntimeMessage( + RML.Warning, "The DFFace was a cylinder created from scratch \n \ + , it cannot convert to brep.") + brep_curves = [] for loop in self.all_loops: @@ -151,7 +172,15 @@ def to_mesh(self): :return mesh: The Rhino Mesh object """ - mesh = rg.Mesh.CreateFromBrep(self.to_brep())[0] + mesh = Rhino.Geometry.Mesh() + mesh_parts = Rhino.Geometry.Mesh.CreateFromBrep( + self.to_brep_face().ToBrep(), + Rhino.Geometry.MeshingParameters.Coarse) + for mesh_part in mesh_parts: mesh.Append(mesh_part) + mesh.Compact() + + + # mesh = rg.Mesh.CreateFromBrep(self.to_brep_face())[0] return mesh @property @@ -185,7 +214,7 @@ def __post_init__(self): self.__id = uuid.uuid4().int @classmethod - def from_brep(cls, brep): + def from_brep_face(cls, brep): """ Create a DFBeam from a RhinoBrep object. It also removes duplicates and creates a list of unique faces. @@ -193,11 +222,22 @@ def from_brep(cls, brep): faces : typing.List[DFFace] = [] data_faces = diffCheck.df_joint_detector.JointDetector(brep).run() for data in data_faces: - face = DFFace.from_brep(data[0], data[1]) + face = DFFace.from_brep_face(data[0], data[1]) faces.append(face) beam = cls("Beam", faces) return beam + def to_brep(self): + """ + Convert the beam to a Rhino Brep object + """ + brep = rg.Brep() + for face in self.faces: + brep.Append(face.to_brep_face()) + brep.Compact() + + return brep + def __repr__(self): return f"Beam: {self.name}, Faces: {len(self.faces)}" diff --git a/src/gh/diffCheck/diffCheck/df_joint_detector.py b/src/gh/diffCheck/diffCheck/df_joint_detector.py index 2bc12de2..9601eca7 100644 --- a/src/gh/diffCheck/diffCheck/df_joint_detector.py +++ b/src/gh/diffCheck/diffCheck/df_joint_detector.py @@ -8,9 +8,7 @@ import diffCheck.df_util import diffCheck.df_transformations -from Grasshopper.Kernel import GH_RuntimeMessageLevel as RML - -# import numpy as np +import numpy as np @dataclass @@ -18,211 +16,77 @@ class JointDetector: """ This class is responsible for detecting joints in a brep """ - brep : Rhino.Geometry.Brep + brep: Rhino.Geometry.Brep + def __post_init__(self): - self.brep = self.brep or None - # list of straight cuts - self._cuts : typing.List[rg.Brep] = [] - # list of holes - self._holes : typing.List[rg.Brep] = [] - # list of mixed joints (cuts+holes) - self._mix : typing.List[rg.Brep]= [] - - # list of DFFaces from joints and sides self._faces = [] - # debug list of various geometries - self._debug = [] + def _assign_ids(self, joint_face_ids): + """ Return the extended joint ids for each face in the brep """ + joint_ids_is_found = [False] * len(joint_face_ids) + joint_ids = [None] * len(joint_face_ids) + id_counter = 0 + + for idx_1, joint_face_id_1 in enumerate(joint_face_ids): + if joint_ids_is_found[idx_1]: + continue + + joint_ids_is_found[idx_1] = True + joint_ids[idx_1] = id_counter + + for idx_2, joint_face_id_2 in enumerate(joint_face_ids): + if any(item in joint_face_id_1 for item in joint_face_id_2): + joint_ids_is_found[idx_2] = True + joint_ids[idx_2] = id_counter + + id_counter += 1 - def _compute_mass_center(self, b_face: rg.BrepFace) -> rg.Point3d: + extended_ids = [None] * self.brep.Faces.Count + for idx, joint_id in enumerate(joint_ids): + for joint_face_id in joint_face_ids[idx]: + extended_ids[joint_face_id] = joint_id + + return extended_ids + + def run(self): """ - Compute the mass center of a brep face in 3d space + Run the joint detector. We use a dictionary to store the faces of the cuts based wethear they are cuts or holes. + - for cuts: If it is a cut we return the face, and the id of the joint the faces belongs to. + - for sides: If it is a face from the sides, we return the face and None. - :param b_face: The brep face to compute the mass center from - :return mass_center: The mass center of the brep face + :return: a list of faces from joins and faces """ - # vertices = b_face.DuplicateFace(False).DuplicateVertices() + # brep vertices to cloud + df_cloud = diffCheck.diffcheck_bindings.dfb_geometry.DFPointCloud() + df_cloud.points = [np.array([vertex.Location.X, vertex.Location.Y, vertex.Location.Z]).reshape(3, 1) for vertex in self.brep.Vertices] - # points_x = [v.X for v in vertices] - # points_y = [v.Y for v in vertices] - # points_z = [v.Z for v in vertices] - # points_xyz = np.array([points_x, points_y, points_z]) + rh_OBB = diffCheck.df_cvt_bindings.cvt_dfOBB_2_rhbrep(df_cloud.get_tight_bounding_box()) + # scale the box in the longest edge direction by 1.5 from center on both directions + rh_OBB_center = rh_OBB.GetBoundingBox(True).Center + edges = rh_OBB.Edges + edge_lengths = [edge.GetLength() for edge in edges] + longest_edge = edges[edge_lengths.index(max(edge_lengths))] - # centroid = np.mean(points_xyz, axis=1) + rh_OBB_zaxis = rg.Vector3d(longest_edge.PointAt(1) - longest_edge.PointAt(0)) + rh_OBB_plane = rg.Plane(rh_OBB_center, rh_OBB_zaxis) + scale_factor = 0.09 + xform = rg.Transform.Scale( + rh_OBB_plane, + 1 - scale_factor, + 1 - scale_factor, + 1 + scale_factor + ) + rh_OBB.Transform(xform) - # return rg.Point3d(centroid[0], centroid[1], centroid[2]) + # check if face's centers are inside the OBB + faces = {idx: (face, rh_OBB.IsPointInside(rg.AreaMassProperties.Compute(face).Centroid, sc.doc.ModelAbsoluteTolerance, True)) for idx, face in enumerate(self.brep.Faces)} + # get the proximity faces of the joint faces + joint_face_ids = [[key] + [adj_face for adj_face in value[0].AdjacentFaces() if faces[adj_face][1] and adj_face != key] for key, value in faces.items() if value[1]] - amp = rg.AreaMassProperties.Compute(b_face) - if amp: - return amp.Centroid - return None + face_ids = self._assign_ids(joint_face_ids) - def run(self) : - """ - Run the joint detector + self._faces = [(face, face_ids[idx]) for idx, face in enumerate(self.brep.Faces)] - :return: a list of faces from joins and faces - """ - ############################################################################ - # 1. Bring to XY, mamke AABB and get negative boolean difference - ############################################################################ - # bring to plane xy - x_form = diffCheck.df_transformations.pln_2_pln_world_transform(self.brep) - - # reverse the transformation - x_form_back = diffCheck.df_transformations.get_inverse_transformation(x_form) - - # compute the bounding box and inflate to include butt joints typo - bbox = self.brep.GetBoundingBox(True) - diagonal = bbox.Diagonal - scaling_factor = diagonal.Length / 10 - bbox.Inflate(scaling_factor, 0, 0) - bbox_b = bbox.ToBrep() - - # boolean difference between the bounding box and the brep transformed - breps_from_booldiff = Rhino.Geometry.Brep.CreateBooleanDifference( - bbox_b, self.brep, sc.doc.ModelAbsoluteTolerance) - if breps_from_booldiff is None or len(breps_from_booldiff) == 0: - ghenv.Component.AddRuntimeMessage(RML.Error, "No breps found after boolean difference.") - - ############################################################################ - # 2. Distinguish holes, cuts, and mix boolean difference results - ############################################################################ - is_hole = False - is_cut = False - is_tenon_mortise = False - is_mix = False - - # parse holes, cuts and mix - for b in breps_from_booldiff: - is_cut = True - for f in b.Faces: - f_brep = f.ToBrep() - f = f_brep.Faces[0] - if not f.IsPlanar(): - is_cut = False - is_hole = True - b_faces = diffCheck.df_util.explode_brep(b) - for b_face in b_faces: - if b_face.Faces[0].IsPlanar(): - b_face_edges = b_face.Edges - for b_face_edge in b_face_edges: - if not b_face_edge.IsClosed: - is_mix = True - is_hole = False - break - if is_mix: - break - break - - if is_hole: - # TODO: for future development get rid of error - raise NotImplementedError("Hole detected, not implemented yet.") - self._holes.append(b) - elif is_cut: - self._cuts.append(b) - elif is_mix: - self._mix.append(b) - - is_hole = False - is_cut = False - is_mix = False - - # deal with mix - candidate_cuts = [] - candidate_holes = [] - for b in self._mix: - # -- algorithm draft -- - # (1) explode - # (2) seperate in tow list flat surfaces (cuts + cylinder's bases) and non flat surfaces (cylinders) - # (3) cap each object in both lists - # (4) boolunion every object in both lists - # (5) check if closed, if it is - # ---------------------- - # (1) explode - faces_b = diffCheck.df_util.explode_brep(b) - - # (2) seperate in tow list flat surfaces (cuts + cylinder's bases) and non flat surfaces (cylinders) - flat_faces_b = [] - non_flat_faces_b = [] - for f_b in faces_b: - if f_b.Faces[0].IsPlanar(): - flat_faces_b.append(f_b) - else: - non_flat_faces_b.append(f_b) - - # (*) cap the cylinders - non_flat_faces_b = [f_b.CapPlanarHoles(sc.doc.ModelAbsoluteTolerance) for f_b in non_flat_faces_b] - - # (4) boolunion every object in both lists - flat_faces_b = Rhino.Geometry.Brep.CreateBooleanUnion(flat_faces_b, sc.doc.ModelAbsoluteTolerance) - non_flat_faces_b = Rhino.Geometry.Brep.CreateBooleanUnion(non_flat_faces_b, sc.doc.ModelAbsoluteTolerance) - - # (3) cap candidate cuts - flat_faces_b = [f_b.CapPlanarHoles(sc.doc.ModelAbsoluteTolerance) for f_b in flat_faces_b] - # non_flat_faces_b = [f_b.CapPlanarHoles(sc.doc.ModelAbsoluteTolerance) for f_b in non_flat_faces_b] - - # (*) merge all coplanar faces in breps cut candidates - for f_b in flat_faces_b: - if f_b is not None: - f_b.MergeCoplanarFaces(sc.doc.ModelAbsoluteTolerance) - - # (5) check if closed, if it is add to cuts, if not add to holes - for f_b in flat_faces_b: - if f_b is not None: - if f_b.IsSolid: - self._cuts.append(f_b) - if non_flat_faces_b is not None and len(non_flat_faces_b) > 0: - for f_b in non_flat_faces_b: - if f_b is not None: - if f_b.IsSolid: - self._holes.append(f_b) - - ############################################################################ - # 3. Sort faces from joints and faces from sides - ############################################################################ - # retransform back everything - # for b in self._holes: - # b.Transform(x_form_back) - # for b in self._cuts: - # b.Transform(x_form_back) - # for b in self._mix: - # b.Transform(x_form_back) - # self.brep.Transform(x_form_back) - - # TODO: get rid debugging - # bbox_b.Transform(x_form_back) - self._debug.append(bbox_b) - - # get all the medians of the faces of cuts only - cuts_faces_centroids : typing.Dict[int, typing.List[rg.Point3d]] = {} - for idx, b in enumerate(self._cuts): - idx = idx + 1 - temp_face_centroids = [] - for f in b.Faces: - centroid = self._compute_mass_center(f) - temp_face_centroids.append(centroid) - self._debug.append(centroid) - cuts_faces_centroids[idx] = temp_face_centroids - - # compare with the brep medians faces to get the joint/sides's faces - for f in self.brep.Faces: - centroid_2test = self._compute_mass_center(f) - for key, centroids in cuts_faces_centroids.items(): - is_joint = False - for centroid in centroids: - if centroid_2test.DistanceTo(centroid) < sc.doc.ModelAbsoluteTolerance: - self._faces.append([f, key]) - is_joint = True - break - if is_joint: - break - if not is_joint: - self._faces.append([f, None]) - - if self._faces is None or len(self._faces) == 0: - ghenv.Component.AddRuntimeMessage(RML.Error, "No faces found after joint detection.") - - return self._faces, self._debug \ No newline at end of file + return self._faces \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck/df_transformations.py b/src/gh/diffCheck/diffCheck/df_transformations.py index 20d529b8..e7bca57f 100644 --- a/src/gh/diffCheck/diffCheck/df_transformations.py +++ b/src/gh/diffCheck/diffCheck/df_transformations.py @@ -82,8 +82,8 @@ def _get_lowest_brep_vertex(brep) -> Rhino.Geometry.Point3d: # get the plane of the biggest face if biggest_face.TryGetPlane()[0] is False: - log.error("Could not find plane for longest edge. Exiting...") - return + raise ValueError("The face is not planar") + return None plane_src = biggest_face.TryGetPlane()[1] plane_tgt = Rhino.Geometry.Plane.WorldXY diff --git a/src/gh/examples/assembly_beam_system.ghx b/src/gh/examples/assembly_beam_system.ghx new file mode 100644 index 00000000..324f6ecd --- /dev/null +++ b/src/gh/examples/assembly_beam_system.ghx @@ -0,0 +1,2824 @@ + + + + + + + + 0 + 2 + 2 + + + + + + + 1 + 0 + 8 + + + + + + d5e887b6-b770-4141-aafc-5d8da5356208 + Shaded + 1 + + 100;102;0;255 + + + 100;0;150;0 + + + + + + 638537389965512241 + + false + assembly_beam_system.ghx + + + + + 0 + + + + + + -102 + 263 + + 1.2750001 + + + + + 0 + + + + + + + 0 + + + + + not_found + not_found + F:\diffCheck\temp\test.py + + + + + IBOIS, EPFL + andrea.settimi@epfl.ch + Andrea Settimi + + + + + 3 + + + + + Robert McNeel & Associates + 00000000-0000-0000-0000-000000000000 + Grasshopper + 8.8.24170.13001 + + + + + Robert McNeel & Associates + 00000000-0000-0000-0000-000000000000 + Grasshopper + 8.8.24170.13001 + + + + + RhinoCodePluginGH, Version=8.8.24170.13001, Culture=neutral, PublicKeyToken=552281e97c755530 + 8.8.24170.13001 + + 066d0a87-236f-4eae-a0f4-9e42f5327962 + RhinoCodePluginGH + + + + + + + + 27 + + + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + e21a1698-c3e4-4e2b-93d3-6b294e27116f + Colour Swatch + Colour Swatch + false + 0 + + 255;121;64;255 + + + + + + + 876 + 111 + 124 + 20 + + + 876.63965 + 111.0538 + + + + + + + + + + 537b0419-bbc2-4ff4-bf08-afe526367b2c + Custom Preview + + + + + Allows for customized geometry previews + true + 5bf07fe5-2865-40fa-8a93-913fa72c51c5 + Custom Preview + Custom Preview + + + + + + + 1023 + 151 + 86 + 44 + + + 1095 + 173 + + + + + + Geometry to preview + true + d50bb1a7-9ae3-491c-926e-b458321f97f7 + Geometry + Geometry + false + c85939e6-bd31-49b6-8051-7f4e388b84eb + 1 + + + + + + 1025 + 153 + 55 + 20 + + + 1054 + 163 + + + + + + + + The material override + bcfe0c02-ddb4-4763-ab1e-3dad1a373c7f + Material + Material + false + 3006909c-e805-4c62-8255-1e8e709f8f20 + 1 + + + + + + 1025 + 173 + 55 + 20 + + + 1054 + 183 + + + + + + 1 + + + + + 1 + {0} + + + + + + 255;221;160;221 + + + 255;66;48;66 + + 0.5 + + 255;255;255;255 + + 0 + + + + + + + + + + + + + + + 537b0419-bbc2-4ff4-bf08-afe526367b2c + Custom Preview + + + + + Allows for customized geometry previews + true + 9a94cc6b-9644-47f9-8c58-2f2ab4354d2c + Custom Preview + Custom Preview + + + + + + + 1027 + 86 + 86 + 44 + + + 1099 + 108 + + + + + + Geometry to preview + true + eb874ada-ad47-435e-a4c1-24fb8d4640d4 + Geometry + Geometry + false + 3212063a-9455-4e0d-9d9a-e22a4bafda0c + 1 + + + + + + 1029 + 88 + 55 + 20 + + + 1058 + 98 + + + + + + + + The material override + 965aa5b5-ecd9-4f5c-baac-8e60df11af91 + Material + Material + false + e21a1698-c3e4-4e2b-93d3-6b294e27116f + 1 + + + + + + 1029 + 108 + 55 + 20 + + + 1058 + 118 + + + + + + 1 + + + + + 1 + {0} + + + + + + 255;221;160;221 + + + 255;66;48;66 + + 0.5 + + 255;255;255;255 + + 0 + + + + + + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + 339266f0-2362-4309-95c6-49cc7bf5056a + Panel + + false + 0 + 0 + test_name + + + + + + 171 + 178 + 91 + 20 + + 0 + 0 + 0 + + 171.56699 + 178.15656 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + da566c9a-242e-4f9a-9d79-924508ca764b + Panel + + false + 0 + 0dc0a83b-9dd1-46f8-9764-98720c7595d9 + 1 + Double click to edit panel content… + + + + + + 1140 + 118 + 84 + 209 + + 0 + 0 + 0 + + 1140.481 + 118.96353 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 919e146f-30ae-4aae-be34-4d72f555e7da + Brep + + + + + Contains a collection of Breps (Boundary REPresentations) + e96ace3f-1930-4d2a-ae94-1a0648c7d34a + Brep + Brep + false + 0 + + + + + + 206 + 200 + 50 + 24 + + + 231.88025 + 212.31995 + + + + + + 1 + + + + + 9 + {0} + + + + + + 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 + + 00000000-0000-0000-0000-000000000000 + + + + + + 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 + + 00000000-0000-0000-0000-000000000000 + + + + + + 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 + + 00000000-0000-0000-0000-000000000000 + + + + + + 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 + + 00000000-0000-0000-0000-000000000000 + + + + + + 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 + + 00000000-0000-0000-0000-000000000000 + + + + + + 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 + + 00000000-0000-0000-0000-000000000000 + + + + + + 5L0JPFXd9z9udo3XPE+hSZTMZbjHMc9zmkyVooiUoSiKDFGkFFFCEymVShOOlJIhpRERQslQpsx+51z31O10b5/H//N5/i/1Pa/nPLe7z977rvde++z3Wmuv49DQ0tDQTMEH8okc7HTw/1bYenhu9dHz8fb22SovtcLdb7unz1ZtjcUai5VUlqorLl6qrKi4VF5Kz99rh7+fu/ZWd/8dfm5e8lLW/uu8PNebue+099nivlVbVVVJSWOp+zL19eqqqqrKiozIj/AS+15s5O7j7b7Db+di0M/dlwEuZw6Y/hlWN7/1Hp4B7sobvFl8fN23bvX3W7edYYPbDjekEg6Ho0Mk5JpPQ6MEf8rv5GJnoYf/gUf+ZyJES0M3GkpHow3/AznGpuho+EjI9O77fJHLwhmefHP++YNqObUFk7nLx+HrjKS6SjRhNMDVZdOVuYzh/yHlSG+FpB7IexPmznO2YXvBXTxJwxVOK/3FVGSnINLbftJ1LkRK5EA+0X//OL4QfimaLi/GlpC3NdC/WTG0rJXwa38/rqHf4wVG5k2F0oWh32cdmG7mDV9jO/uIYLDCo997SHV4Lm+4NavBkGsG/Xcbm0DnMxd5AK2Dfk+o+/J6VoP5SqYZrPDo944Dn7aE0ckBfqmeq2clGFRAVHByzaDXsJpa/1FfclaC6WQp7F58dj6ACk4OBr2GBaeuGcE3K8F0RSf4vDOaC6CCk4NBr2HBubpymM1KMNMrlDSACk4OBr2GBZd1uDRrVoL5Eqm+fflBKQAVnBwMeg0L7sHed1dnJZjpm1oMQAX/dWkW+w4GrbO8+Ur/rATzmXgfCJJWMzEKC4AgZjUTA1450+nMSjC9xKnDA6Cgfr1neDALgCDABlbsnJVg2omjzQ6goH6dZuyYe4YH2Kf0aXaS5rSAdAAK6lfN0GGmGTtQtXFL16wEgxqYqOC/gukjYMHVZp+z/GPMGfRAwWDbJTDmfftjzJmfwdABWHBKgi0Cf4w5gx7oPYIFlzDHcv8fY878LDwPxp9hB96m4YNmJZivFMwZ9EB5BQuu7V1v5awEg7I6CurXaSYGYMG55Vnr/jHmzPcWJIBYcCyP7wz+MeYMeqBTDwtOpKY98Y8xZ9ADXRSw4HwGNNpnsQXwszmDHuhyjQUnpyThOSvBoFEZFBR5fyiRYsHJnXHnnZVgfhfRpGyb9RG+ZN18OivBkARFr4VRMjSx4FQOr147K8H8Z838cAHQ7/EZ+xv/UM1gDU06wOyIp8WsBPM7zWA9TfT7Bef39/44zWCtZvS7lxf7klkJ5j/fMz8CGuj3st4Pd/7Qe+aHC4B+p3uHWzgrwfxOM9i4GfpdKHjM+I/TDNafQb83mAjWz0ow/3k1+xGeRb83c+1984euZj+cM/T7XGnv2bml8TvNYHcB0O+TqbGif5xmsJ7m912A7E3RsxLMf+aZH5tN6HdxbSOBP5RnfrjN6Pe3+IuzM272O81g9zTR7x+MnAP/OM1gYwDodyn/ax9mJZj/bAH82DpHv5dmr/zwh1oAPwIa6Hfm1Ouzc5r9TjPYDA30excz264/TjPY6Az6fYFqx6c/brMJPcTDnslwfuP7DupbTt2BWQnmIxHMcmBjxZTcwqWa02DAdc6JHUnFUv0RAxc0oV/6y2pqmJ0btJ6mtbmvazUAFBRSdq+FsbDrHDz1NrV9YDM5ScCCczJsZZmVYKZXKHUABYWUtZdMSXPshsGEqWnmZS8nYMEZPWecnf7MlvJziyMD1EjbgOpEMI6Xk8o+XYXrh/XEDMkoErDg+DmuuMxKMNOsrgqgoIhlovNvPkPAfNYzNG9tIWDB8ehN1MxKMN7Gu66oCKuQ9jRViWCYk3haq1f1E3yHVa40fmghYMGdsc0unJVgpi1hJQAFhZRFqbsa5Cr2E6xVCrncDjUTsOCOtvvkzUowPo8slFrvLiVt0CoRwZSnVWu6HBgnuI6f8tA4V0fAgsuvP/p+VoKZ9h4VARQUUnb33inNOPkJQpjZupux8LTCgpuYd212Ls2tcaCHTOFiUvKcIhFM6sdbanww418IThwzam4hYMHt+jx3dsaaUTMGBUVHwXzBgluiG7NhVoL5fpVCkjZ6rKc32vpk3w9wd49b1f5BhuZKbZXqiaL3uX16iCZ+6Wlc4fwfk9WEe0MfwBfOCgxvP0t3qA0B8zM42a1emX9MVtNKV5dy4SZW4Ev4dkM93bcELDgWti/b/pispqNaLEtfHcADGnuY7uFfvCdgwW2NsLn5xyRpe3OMzdvuhQfeyB3N7G6HGR8DLo5XxO2PSdKW0hSeu1dGGNB4vONBKcwrWHBfBVpXzUownRSympjyqzKiYTA0wMQb8TZlAhbcSKPAjlkJBt3aQ0EhZevED4l69QkANNBLfjGcJgELrm541dZZCeYDaQf5+34lXKaFu5OTMSoAhDnvY96kdIGABXdV4gbDrATTRUpUQEEhZZ+Pr/BvSYUZHxi/Yh55n4AFpwHpX5qVYFAzBgVFR8F8wYJbztjMRQ4mIpGpDHl48500SUBZMoTitP8cYRuKEHmYFDmQB1MZ/guETJQrEg80Ooj9RH5PRVlZObFTFErcmOffxWMOnEhJEVbz5wWQ8oFwMUibe7VGKr05UFVZWWlnPF2+Qlwc6rjLMGYyYIaMXNg20enyWzfFkX4Khz+YAfBX5fgeHoBXnZ0iH1TR/PPBSsIO1v/SukXTpJAyaiDQchflkLVTT6ZBN8zlBzYwO9bPSnAkKxciGYgQ3W80jbTBARxI+adobVOkPIV+ETswwuR2claCo2TKb9q4sf25FBf0MKVlYAmjKVFjze9ZqU5LZ1ZWrVkJjpJpD9975qd5iOD0z06YADDYjcblbAA10OMfxrfOSnCUTH1E6NM8HNBwJT/XzQoT4kKztpoFoAZajsfv6qwER8n0R8B5ChPvrZQtVSbEe+3DCRaAGuiOS1nKsxIcJVcAEbr5DSuiIbHss0RwYbuv4gBqoHlvlYfPSnCUXAMUHAzidl7sNAghKQ6AGuizugu/zUpwlFwFZOFw0ONFwNF2rDJFVsX8U11cADXQwukXqmYlOEquAzL9crWI4JqfrzYlgrhTwgVQA32FhqN8VoJro+BKIBryh/ggeRoTTdlj0yDWNnEB1EA38pvyzUpwaA40CpLUX9idOj5kVQTEEqctEfnD3AA10MOsiemzGNzPz4NSsyGpgU775p04m8H9lH+A2pYwCL7+YTMieYfn8gPUbE4366XesxgcHYSCJIHL32c3fW/Fl5sSp2O78rRXQAl07D7f2UnipHuNBI6O6BUg0y1flRe5t2R4q4nTT3jnFm6AGujAWrW2WQmOtEpCKEikDLH2Da9xIxpa+TZxGgSnBTdADXQB79ZNsxIcid9ImuNBNScscY8b0VDG6sPTS/6qeG6AGugr/OWPZyU4kmUCoSBRnksCmBENbc+6bULUmLsCJ0AN9Le3m4dnJTiSTUmalmJYcLVptSbEhaSiiOjyUATdI3F796wER/IGIBQkybbcWCFINJDjHsBOKfKdqY0VoAZ62ZEx01kJjuTHke45aSI45JjPwYrcWxeG6abvrafLiZ44RdDRUXUlsxIcyQOHUJBof2GSHAgIr88q0+EEeRUOgBpoaYGcpFkJDo16oSDR/ihFuaiBzpCT76ME7o8O8lIyz5AgLwz+VcYnMyA6OhqXEcr/PciLePDWdWaAvr7+gyLb6XJKNmySQ/mxv2mwKFo+MtLSmZ0veSGWxnm0fAWmwL27d+9emOAGeLi5D9uu5IP2OpySSj5jClzMycnZ/IibqmG/9LjA6b9msKhZUsggmNwmli/aetcUCAoM/PZAi5s4aE1aRFdOufyCKbDCweElFyd1F281nWXzXzNY1CyzGPi+K1TlgV7l9O+XDyOCVz4pwQ00vnv3TuU2D3Q9+ll+qPf0DFr0hbqzzxozwv/XDBY1Sw8eLFykDg9SXtK4xxSAmbZdZBU3cYZ1Q8Ty5nVe04PbIM1NNeyzozpQ5q8ZLGqWYzVcvmo7DrKU3qJqm2OCrFXcGbXTUUzxcyyQr/7BbzSpJsjCH92wk4NqAFCAuafhbxysnyxRdLBgdjtm9sAEkIYXfCZ3lu+DBQ/KqtHrJgA8htwgGwvVUHDmerHuv2awqFm28MLt4CDEhqxNmuN9JkBvT0/PaAArYiroNwmxQ1mBUKfyexPktgzsxbFS3RTouunb9dcMFjVLGbntRjnZkHKpg1+IM0vavoSV+FnFxY6UJ89pnB6sN0asVLeHph48uPNXDRYlyxthvc1zOJHy63ukp1lP9S470XRwkMEj5ePcXNOEQADZqW4UxiqbVf5Vg0XJffkC33aHAU7iDILkTBEjVXr4HhvQBA+iqC4eWcsMhwVNgVzYHuuypL5lPKaR1UI+WL2VoYxIogtegDQAnGQjmEJhBAUfuxq1ko3gxQWHipARdKOlMIKIQ4Z+/v85kpSyB3C/GV1q4Wtqo04taYaaNqgl08w0m0GAZic3pan+RysKPdDNFNx/yFb6nYNLKYvpd44vpeym3znE/zRhKOomr+Nfpyjsbhe5oigohOpeCiWFUHO6qSmEmjM+090328DMU3+pon7suZIURVEh1Bx7agqh5vBTUwi1QAA1hVALEHQW7mT86xSF3flHFEVNIdSCCtQUQi3YQE0h1IIQM81EWDMai//rFIXNP8H9ftORWkCDokKoBTqoKYRaAGSm+TAOyc+F/zpFYbOgSHcURYVQC6ZQUwi1IAs1hVALvsw0KwtyYqr66xSFzcVDFEVNIf8pkINVyH8K8FCKhv0u8PNPcwMzTywz/+sUhc0IxSjqJ4VQCyJRUwi14BI1hVALOs00Q3W5HM+nv05R2LxkRFHUFEItgEVNIdQCW9QU8ruA10zypCNXz9n21ykKmx2PRiYoKYRa8IyaQqgF1agphFqwbabZ+heWxJ3+6xSFfUYD9x+SJyiFlqgphFpoiZpCqIWWZvrMiODEoVRKipqg+VVRTS9eWxp9quUubptW1PbXb74hinpIus5N7Ucgxr6zwfc+FItZPqOLa2kn7KmHNvk/qCHQnJ73xvbCqM5A13BNJP2rYjXRkYey7D0E7yH1QXOXj4RcVaGNp4NaCb52Cw/LRFVSLd/ov9rxnaM2FHS+stkh/2tx67lIbR91fiCY77JR866I4vtX7FSfqLUS/uP1JepV/7PBoBazWpB97Tw8GIQ999I2729pL96ltcsl5UFNMS20z8ZgNQ2BdsLhViY8GGGrQ7Ml4cFwrUjrh0EXa9Nr6MGgi8fmjcrMjaosplaeft3Jo6NHGzC9ZRqWLnSl+HC1bm7reuHvYOVar81/q9FK+E/XVdyHOMkHIzg5zRYJDX8ixaW5hEgXqAElT+1Bwsjko0otgEZPVgf590bNxfL5fA46v3vWC6mHnIhcMmS/g5RRux3Q+ozwiTzTWd14UHl5iKkOmjVDaa2jJ9VHlo858NkjtS5zY220DlJGjcjoSfWZ4VMKPhVeuTJ2J4XqIGXUrBR6Un1keZFE5NQ/my92OFIHKaNmgtKT6rPApwTZGJBIn6J/QU+qzwqf4vD5sUvphJvTFh2kjJrzSE+qzwafYvAZguue4rfZpoOUUYsM0JPqs8OnKHy2dxufkcF76iBl1MI+9KT6HPApAp9njiSEczR76SBl1GJ69KT6yNwRJhsDjt/EJelJcxNPauP3IH+1jetKHc7fhMiIL4NFbgCSbBybFwgfynXVwf8mWkNPqs9NGoOg+VwT+/JidLh+EzigJ9XnIY014/CncN8qLx3u3/iw9KT6vCSdogfPb9wpelJ9PtLcqW4N8L6TtU+H9zeWPT2pPj9pjqIH32+MTHpSfQHSvfBFbVtU8fm9OkgZNXuHnlRfkHTPmZZkdJyf2qEj8BvqpSfVFyLd2/mdxg9aPwfrCKL3BAVapifVpyOtIR8N14/GP9+r03NU5SSy6C1EJjj64DelA7UTaEgTELVP6H5TF6lHsnG+H2hQHSlnJ7VH/q2JDNBxtylLvIMOti557iT2CWCkTJB0HQGphQxkKd0c2uq9Oti66EJKQ+VhWxQXskgqksmDrUu+WYq1mZD+UXmRhXMpfN6o2qW0w99UB1sXuY6cNBSMZKR/tC9kMUVe1Tx26rMhR1W0DrYuE5nNh/WKGMnsSWSBVSbrB1sXuY6cNBTcYKR/RlI/xPg6fKYFcmo7xkbqUHKZUdsRG/dA+mci9YMsxKpk/WDrItdZfhrnnwNdzKR+kLmrBp+77iswrFuxRQdbF7lOmt+/RDaR/nGkfpAFWx0+Txhs07tgvk0HWxe5TlrUfwllI/2zkPpB5rUGWT/Yush19p/k+bF3gfTPSuoHWdiRt2kzjwQ/znnrpYOti1znwNwraB2kfzYy42T5L/38qMtJZsBgn4JC+0f6QQhAGz7NGp54869eqYOti1zH/4zr+wNHSP8cpH4QUkBucqg92df0gqsOti5ynevncf7+bA/SPyepH4QokAXpHP7liq8XYnSwdZHr3D/r/ftjNEj/eFI/CHkAZP1g6yLXeX6eh9+fWEH65yL1gxCKLny+rOqq5Cnz0sHWRa7z/oTrx8MhSP/cpH4QkgHh02aklX/o1D4dbF3kOmqmY5/DQPrnIfWDEI8eWT/Yush1lJywjzwg/fOS+kHISB8+dwrLZGhmwaSBqYtcRwkL+3QB0j8fqR9knTYg6wdbF7mOkhg2kR/pn5/UD0JkhvB5Y87Ce8UfgnWwdZHrqPGOzZlH+hcg9YMYREZkfIGtK4wxtMi5jYOMv0RIRg8NlbrIdREq1zjJ7lMxjFGDrStK4XfQa3iydUMCY7Rg6yK/I0blGhfZOiZFMkqo9SNOQV70GjfZuiqNcVywdSUwRj35NR6ydR6xTeb+ph9JCrjRa7xkvDMPPuf/ph8EtxSVa3xkPLgAPhf+pp85FMYPvcZPxsty8LnoN/0g4ydN5ZoAmZ0gD58Kv+lHhoIe0GuoDYWci+FzyW/6KfeUMSQajSRlcBn/pjL6HTUEUQMLaxj+ru0/PbAGJ/r+WrQcJV3UOPudDGjbmcqAfdAHazijn6hhR/MvjAO5oUtD9uI7VC50kUWN5t8daNuZyoAayVjjGZ2s5PMBNYKxB7btf/rN5+LKpwqH26bQT9TAxhre5MY1uQyocUd+YNvOVAbUOMca7ahhTh5FYiQzVMkPbNuZyoAa9liDHzXqGTAyoEY3+YFtO1MZUKcA6yygDgEjRgbUgSA/sG1nKgPqUFDajEXlIJcBdYbID2zbmcqAOiPYF7iijggzRgZKawS27UxlQB0Z7HtXUScGh5GB0v2JbTtTGVAnCPu6VNQBYsHI8Gt28q9tZyoD6kBhX9qOOk+sGBkorZXYtjOVAXW+sO9aRw1MNowMlAIu2LYzlQF13LDrLeq00WD4gvZfWKtRpw+73qIOH7kjSr52/y/XatRhxK63qLPIiZGB/l9Yq1FnE7veoo4mHiMDw7+wVqOOKvb136iTyoWRgdL6gG07UxlQJxf71m7UweXGyEBpncS2nakMqIOMXW9R55gHIwPzv7BWo841dr1FHWtejAy4f2GtRh1z7HqLOuV8GBlY/oW1GnXqsW+kRh16fowMlOwobNuZyoAGBLAvkkbkQuUgl4GSPYltO1MZsMEE1EdA5EI5g+a3iQS/tp2pDGggAvvKJmGyXS1yH4cSX2DbzlQGbBCDPNiCBlXIx4H+XxgHNACCxSJC+n1OzDjQ/QvjgA2ekAeL0KAQ+ThQ4gts25nKgAZesFhESb+Px4wD/b8wDtigDXmwCw1qkY8DNZ+TvO1MZUADPlgsYqTf58KMA8O/MA7YYBF5sA4NypGPwz9JFpqpDGigCYtFnPT73JhxYPwXxgEJFspSCTaiQUXycaDE3di2M5UBiY/NpYBFgvR7PJhxYPoXxgEJds6jgAW5X9GgKPk4ULIfsG1nKgMSbJ1PAYsk6fd5MePA/C+MAxKsXUABC7JmoEFd8nGgZMNg285UBiRYvJACFinS7/NhxgH3L4wDEmyWo4AFWbfQoDT5OFCyo7BtZyoDEuxeRAHLHNJv8mPGgeVfGAckWC5PAQuydqJBdfJxoGTLYdvOVAYkWK9AAQsiA5oZQj4OrP/COCDB/sUUsCDrN7opQD4ONP/COCCbDUsoYJEh2zgkHwe2f2EckIQPxX8Yr0Y3+f/XMRAkWWQphRduUopX01CRAdt2pjIgiSZKFN6TSSleTU0GbNuZyoAkqShTeL0lpXg1NRmwbWcqA5LgokLhrZSU4tXUZMC2nakMSHKMKoWXSVKKV1OTAdt2pjIgiTVqFN4BSSleTU0GbNuZyoAk5ahTeHUjpXg1NRmwbWcqA5LQo0HhjYuU4tXUZMC2nakMSDLQMgovSqQUr6YmA7btTGVAEomWU3i/IaV4NTUZsG1nKgOSLKhJ4bWElPZ5qcmAbTtTGZBEQ+Sk9jZB8j1WNJmL2oG2nakMSDKW9j+M29NQkeG/5SwkkUvnH8btqcnw38btkYEj/MO4PTUZ/tu4PdIA+Idxe2oy/LdxeyT5TJfCPimluD01Gf7bPVYkcQ2ksE9KKW5PTYb/do8VSXpDzs5/ELenJgO27UxlQBLmkBObREopbk9NBmzbmcqAJNsZUHh5G6W4PTUZsG1nKgOSqGdI4Z1rlOL21GTAtp2pDEiSnxGFV6VRittTkwHbdqYyHGqovogkTbHQkf3lKRqSMbuYLFhPvsFKSyrHk31Hgqoo0aFOGfqoBtKnONk1dIMQuenESMAkyR4/QgPCyA0hQSLKOWS/ixrbyGSVIpG7DOk6mpzAQJpI0iQDZC7pOhrIQR16WZKRNJ90HX0EiIGkgHmk7wtJ19HHfRhISlpAarOIdB19tAe5LkQKajCRHGpassd4kOvCJGefkeRo0pI9ssNOcvw0SYbNMpKhp04yfFVJjoAyyTFaSmZkoEaPFmmCGZJuOH3SAgSSFmSARFA6JMKmJbVt9/FsQSbFMtKk4EYnBaUdE1Tp2Cw31DvFZp6hEwm7U41m32F3A9CMOGzGB7qDg41QMpMpkjxihyNTIHkEi4VMceQRHVYyhZFHONjIFEXu8bOTKQD9Nw3ZrhOa1fG77L6/6ci/lreGL+jgPN/34tCUiOWB4P0mQOp9t3NcITggIVcXL9vNBB1n35kqIWwOBIYFTZ57xA8gk26B13R7WuQRUFfmXx8B/YB5BFThtuha5BHQBaS6qnNIywrDRGavyYFH0/brQC/hUuGyS22pnYR6jfkVBie6Cdj4ENbm/L5HQXql+JMb3VDQQmuQjtkR0KDZDHkddwVvZ6fCd1EY3Nf3E471fD9/KpuCD1oE4jHSDxNJhtLjSMihoCf2uUVN5BfrG7WWsEeUfoepkOMrwvTnTWI74n2HPGyVkvKJQEP8bZRUyNfa6duTyYntyiLlqjj0KgsTI46VmYmFnQXHxsHKwk5LIyJCR8vIxEgrIsIoKiYmhmNkxImJi4uIMjLSMwsz0NMxMTOzCggyCwoJCTMLCeEk2NjY2fBcbBKSkng2SSkpTjxegJWfn5WDn5+Dj5+fj4OXl4Obh5eLm4MdJy4hEQf/aJ9a7RaimKmkIQmqo42j3T4JwMNt1GUDiq90A7SS4iHO4w5gz6sAYJVcDvRSdxX4Xi4S8C9+AJ3sWgsadyYAifZN0AZYPVdh9UTeS4TiFzmAvG47AMvAS1BM/UpwwVQEIKD0GAqPXQs+rIoHnrYmQVyQPbjs8zZA78EVSMt/JehTGw7cPFMBecitBcGrhwAhthQowd4edPb3ATS4r0O9nCvBgvP7AEfBp5Bl+Rqw+OhB4DjTXigMniKs8BRZp5QGcX+yAyOmvAB55wIo64IjOBW8F/gW8xxS8VgDagXFAffhKVU23wXcteM4kPbpM3THwQWUGjsOBIh3QpfCXcBHe5MBa5uPUMZVF3ArLgWQ298OJTW5gPzxKQDD7Q9QDIcreI//BNDY1QKFaLqC69NOALekmiFfT1eQVSYVaKT1hnrybcBRDlcghN4XSgq2Ad+UOgPCjNshLT0b8OZOJ6CAKQBqZbUBjyxZCzjgdkKxz63BbW2rgX6WEEjphDVomboKOMwWCr11swblbVYCOp23AFsz9VeIvq693yFB1JfNd33x1xCMQRu+R9sMYjLPSqlaeHoG8T0Q3cVlL8gnbRBx5XRJ4qTU4jk+O3Fz9r5YGWtoYK9va3f/0oXgxI8G4VwWbS1HeTiFOdX0pQwmGnTWFq2tXvb1BvOTlctEV9r7539O1nqXliRor+1/8sy1k/kKyeI7PW5EKS/RslNMrH349um9nLwlkrbzR+Uab3jsu/YR/74gj7svA38/Y1wiyTttt5qoRRa/yvkrPCsusFngOL/11iw7wbT2zaHDghxRFx/qyi3TiIUSpxI3C1TTJW/3VLcwGZgX1LXQVG1A3WOxNM/JjPiSI5GCzQF+r16PP1rNl++7ZPz8vQMaXWHK2/kP71P4MtYe9fi+uO9CF8F4X817TaMKcr5s8lYTrPQB6vfbB7S9329V2ohLazjMhC+ZbFDY3+x262taFksQ36nL3OVXRDlvslwrbfV1uiPN2xU+RcsUUai/bE+zAQ4e2C0vzO4TR/kw6eYNqlOtLmEJt+aKcFv0+CWr1jz+6EZ+9mgp3D74vze6V+i3XNl3tPlZuHQkgwVzdsk4fe9ASWXw3S0cJ0Mn5hX149wT3vZ5GOF7r35OmfxW/kJGO5Hgst9P1qgv4NJRmWWrp3YX3LaJHzCO71K2NFMYiTp+6Wjlo48nzXqgPVaqTcaH7ulNztle01B6ipfvnpej8Zzlh9BFiNJChrxWeJHF5lwigsrvCNa7hoV1OC3JF02+LnZ6LdONl3PP51Xqf6m1nHr9XOVFZP/xwp7OHO297wltAsH+S50flZS713/yORbV7TbqFpK8R0jyXBNjZTG7I7619EXpsOKgsCcvB8HpLv33gsuuE/HdbpPhX9EGToTK0LsXuwnexQM01U8j6phbo5yc1jre30ZfHbj/jmQZnvYigb5jk24pfdk3hn71rE9Nce2Tpb57lr3QEmri2CwZh9+Oh88lcaFinZJCkjR+r/uvzKm0cEZwnSEbAEqDME/Sb87v/2AG9vjf10PkOmpl3AB/MJTtYv7pTy4Q/1Qv0z8n2zZGMrKVICPb64scDYzOPSOYvHOt/9jfROA2d0/Z39nyC9mi39Gn/kBBzgaj5hZCHd2zMeQTIdt+R2fQD14ZD8CrOUK20hsu/a1ky87MxMaBY2bnghkT5kMuWhpBQUYmQUFaQSYmNiFWViE2+JNVWJhRiImJiZmOFidFT08vxQCTLjMOJ8nCguPglJTCsbDghUVEuPC8fKJ4ERFeUR4eUV48no+fm0uCg5ubQ4KTU4JbXFycW0yMm19ATBjPxoYs4qV+hAqiuFbfF3HxKosFpW5izF9iM5PWLji8euGTvXX8gwP+92nb2obGJ6/GGh+N/jDX4pL40eehPteqIt8+eP5ky6kAwDTbwLYxaqejn4hBcX3Hl90pm+/ZbnTSk/3IYzfV41lrnfrZDX/cMyj5S773wvsfv0nXX7V6rLwktuL1GlX7yxlV3RvW1KqOi2x8uyvNVTJ5/dgmlnMf6DSf62ps5ozlqQg/UST9wXz5myIut8HAyMLnVhc+DVwNzMF96+jvKpW/b+xvPMCvdfHScvDz+dTdCVbDh52HyrMi9vBxXf2YWrdoHvtQZ9fwcf2hk7G7Cxddff7erbheNicp/eTmw8ZHmR7e+WroX7BFke+Ofp0huEpZ1atDw2C3nu1OmYjL7MyhCvG8Q4+67k8MZKql4sqOVk9eMX6TqVvdcNkkWe7YreBdMtsE1rRUnTQFn22LLqbjBHsNVo7T8qa9kLfRMrVCxvjuRu3XxDHeRZoSQXVONbc5whRp9J4t9PiUvPdQsNqrdayHEi66cvOUHy56rm1wkzfaJdDcgnAnQBLsS+s6srvNIMDP+FBn0cfVHzzP98gZtXHcYdo5alDQkPTUZ4PEzqSKyZjxmEqHZb0+dfJN7hcDBbZPRd7uf191fa9C2lQ3fo5nzkOflyHlCKP0reHlIooT/10c7aoMTl03oUfNZxK81J7cjrDTz98u3V2ZwaLmwMWwKpEhVTom56Ivi1rge1Z7rd4hE6vhqcbei51uS++EHOjsmHi1YGT5zfvt58Tb87eOhJhnZR1a3nlhTbXjMxsjcf8Xha/vvvE8v7uG8EC7+7pyd4/VyW073u7kds73/ig+NG+s+BOh8+PiwtIlBXPXCzuJ84dQue2m70n4Dko8m1hKlP/cd/nXu0KcjVfPh3Tt8S+XSJrCVYc+URjqXDcuqjJiNXR5cb1laL4Wu2DUV7f2jD7JkhHFfus2t3YnQ+VepRM7jz+rvBu3sdH91k6URV7HPwll6MjqDI3bOLVeZUwy6+2UkB4hJ1SttCqWvj6QqRp/+86tyxGtTGnpLP74uOLzdZO1Q2Z4xWHFfmWb8f5yHfbNEnHprDfw77QVdWg8mT5/Ui9/4v8HMsXUIRuOX5gibAZumTG5WyZOxhQXaVwHdTrbCasYjeMVbV8SAMOilJ2m9b8wBfa58Doz10fpi1oJ1QelbVoc2YhuWV2CPegUEwdwpp2AMh65/M1MwcrEyMLGzMSKuGScbKwctDR8fNNuGR8fI7+AAKMACwsfP+KSSRFdMilmSUkJSWZmCTZxcWY2CQkBmCXYWQSFcIIsLDDRcLMLc3EJ47m4hITZ2dk4xcQ5YddOlFNEhJNHRISHV0SEm4eTA1nB8plzlSi5ZoirlQIPuQg85NvnVUPPPZzAZr9zgP3wPYiddQ14YW86oPrkImRwEXapEpIBAVhFoeYrQLX0w4BR2jNoEc4JPOB4FrhqBkFnzqwGjVaeAkTHLkMSuitBxlXHiS7PE7wLGGpyERDjeQmFn18LKmudAfDppZA2YTXYvvgkQCd/Dfr2yhE8MecY8DXqDdRguBZskMoCvPvKoFdvV4H7GdOAT2tvQDVejuCSzqNEt2sMNi4+LM4GyibqIdX2NWAEYyZQYfAE2rpjFSjbcAJ4evAWdIHOEXx47Qjw4uU5qAWeYu7wFEPcq7MpLuCOd7lEt+vqFhewakUu0R0r1HYB59VcJLpsr5qdwTf3c4iuXEu+M6iklUN08Xr3O4OxN7KBNMuz0IrH9qCk/EFgw6MsqHzKHnxbfRBQADIhbXUH8Mi2Q8DgrdPQ1a0OoCVfPFC4NB2SPecA4grigf05J6Hkdw7g/VUJgIVMGsTGvwIMGU8AFj9/uGuXaZ05oi/VwtS1RH1t/64vjhqzBQ9g1+zrfkbbxtIa9vCyLLdx7Xlqd6IPjhgdU3JeL206cfboAhPhqitci9QWxO/XEI4Pfnz4ofwGXdMNK4PMj4IL2A7kj8kXTfR82pNUbazK45HvxJt0QGKQBXhpaRHh6P8+i/vjNQfep8dWMShbO8bOs/Qy0jjKPFB7Jib/Im6tCcOod23EjSJap2zArmHMqdbjCd2TD86bCiqeCUnR97K9TrdPDLt5SzLZ9usrhjN+TXPn1xzhGKjJjbk+Of+TGVNncyT45KqO+II40TXtQkVtNAp+vP3bCjQl8R+aNTlK7LKFwq7dKnZefL+UXYpQvGWrWNlqtoQjY07feBoF6CaWqdi80FzMYQPwhjz9+jgsxC3w2jt/y4VZe+Xe5O1+aHuQcbR9d+9Vm86WsOq374ashV3z8pfsu+jRWsU3yexTJWIpQJN0talA/Yszrd8V/7c68m74a1kCATVH8CqPJlW6mw/ye6TvvuoXdruLZkzS1QtqqeXfYYdQbcxSEVGiHhJJt3hQ3Ri3x9YmpW1J70Lm2yi+OzJUyanf5OfCcG4i3KvLta/Foh7qkxKRxWeG0gzmyS9nOMb8TGonF0diVMya+en0seEeCRrRTJ80RUPY5PGZutNVdYf2eSTc2X5SFFKpLIrI0XYdtXvFosihnDd3lPVBobWILGembieg8lhbSuSMpH54Jf0zqX7a7JodmTfdrTu+r+1U2Ha7lYotEcLDn7y3wK6Fkndddl+L8hN23taz+2LBgGba1NE1XS8fDhN8J6PU+tdddGZiZuKbMOc8NM2/Xvha2DsbgL2ziWrXSffg5AlFHXNC3HTp+bMWKuM7ujnXasfh7RAn7u6+QUJkPTOpgaJOwIS59eRGlX7O0pEU17Gn0Miko+DrJN+GsP4tGT3hX7/Z14fW7flEmxYqtv/ph4SYTInHRkvxApPHn71I193e66ZBEHgIi0IzYM0sZCPYX/QHkvE68bNBv5Bx+gzIeBOWjAue3DvaYPyC4ABxZ5w2efVdqDT6twtlmwuokPGPP/aCkrHQ473vne6UExrglRIh48bRSCDpUgqU4bsC1IFX+v9DZMzIREfLx0hLywjHOFkQRoYJV5AFh6NnlpSadtngOCkcE5VghuOjcKwUIWFhdiEhmIXxwlzs7AjhIkQsxikqipA2QsY8IpycCBkLsrOwIIu718Y96ymRMTm5BrqegCIdVoBrOBOAt7InoDjnFWDY7kOA5qcU6MimFeCZrjjgJKyiFFhF5WtigVzfk5BbuwOo9uIQUKt2EpLrdQCzLQ8Co+NpUN83B1C8PPYnQmoOOw1pBTqAXCcOAlXGp6FHoQ7gc8k44DbXacg22gFMOnsAEDicBQniHMDPLnHAo9VZ0AYuB3D8ywFgp2wWdE3IAeTYF/MTuZplnIP6ku3Bh3NjgRKvcxBdhj04934MoKFxDuLJtgf3O0cDl+nPQdJX7cF2eIqRkx85KZKTJTmhkhMtOQF3BZ2BY7X2IF1UFCDXkwnRzHEAJXijAY/1GVDvSgdQMz0aOPcmHXqX4AA6LooBWi1OQZWPHcAdBTHAnNI06C7NCjBB7wDgopEK5WisAHOfHgC4dQrxMspZooi+NKruZRH1deQHGSdYGNduE3pUUD7kuE7vTleian3bWwM+uvKIjm1nt8ZcHElMrODYHMSrG7JsMxPLzmguWUYfmeUeO6IfN4XHs0csWMoTn21tvH17VaGGy5ezTYNsTUvSnxbkhX+xENjgudOqSkfqusTekFSTnBtjEVmbpIqZbDszDyu6Dxm/Ks7LEcWlC0ksbfB8+c5S4zB9drx4ThFN8+D6hG9LDmx+bDXcJvZgpMvYQC9if7FU02dzsY/S9p4J3Yy8r29yH+rQ7VusfHc1S6oV8ORclVajnpBZGHtv3Zux6C/dhATROeEKuvez6R6/5giXsQE7BKKVutay8zaO0Nv2N1TbxbOUBp9orqxW11Rdw3TG70FJ+o3Xd/USbueGh+/KN+mozonrC+SdN6S757LAC7134hb7QoJ25jgPbn7klHArL8JROkIyNDz3W/2bINOgK/S2RSvL0lW27x8qHBxlfbQG98hSl2ni7L1L70I/NjW8zl3bKXPdZd8tdrb1vM3eE833X7Kpbou/kv9A5khg/MtzxxXXDRr76ZyfpF9uXlD2UjrMHiFrzYWN7kQ9xf5gusF3Gx7RMNxo/AwNOD51cF3+er1w8p7Om7jFeY9vNzEh3NsndYL/gsvh2kYBaR8ftsMFBfsf6z3wuTMY/lBXxVhMX2+gO6qzHv+yQDLHp1jhsTMXh6rkZvyDotSt465fc2t33uTSeXCvuLOiZNQVqR7+QrcyP+pAf2llwd4D9TQ0a/mdlnrg35Z9X/SpsLTgg89DRNkrKLD00mXAbXaf5fM+NPlv2t/vQqTro+LVoc8Gle7ujWEjOcta8eFZFTdrm+Tx9SjpmhcrJ4e+ldiIsjRS6kkp1No8VDLdgBAXf1my3QUXqnxiZ1TzuPmViU3vx89cjP1sqrH1dHnT3n6r70TN8CTqrSONA741Srcq/Gvh6Wb61tIuI3+Yq13oO+GILc1hp4F53/Y9tf8DuTrhSQf7L1ztMQOuVsTuZy7ewyfx8k0L4crmxOrdL9q+h1iLBw590Rj6NcSK/QNvUe2PQyIWtBIaC/20vOVbCTfhhTT+lS34mCMSkEs8SOTqZzAR/J/Zz+TlnXaceXkRruZH9jNhuublQ5xnmKthnkb4mplVQlKCVVycDScgSNzPhDkbzyYkLAzvZ4qzwvugrBwcHIjTzCEiwsGNOMxwCBaO4SLrft2x4+OUeJqcd++fOwbNG3UAByRigY70I9C1cAdQquUAwJ6SAOlwOIBmMI8qweqpOGYPBngcAITupUBaBxxASeYDAP7GMaiQ1wG8/CQGYL58BNI+aQ/qHIoBfJ6lQbYiDqBpbzSg8SQFepRlD2rnRwO0pccgLQV7UDEwGnjYng555tiD/q+jANemNOi5sj1YmRoFjL1OgTQL7UAZ16ifuFZ0PBMKXW4Pni6OBKIH0qGGUjtwTUQkMNiVBi23sAP5TSKBdW0p0HF4StXAU4qcC8k5kpw7yTmVnGvJOZicm8dXJ0MnOe3AuSmRwLGaY9AZQztwl2wUoGiYBOXssQOr86KAJ3ePQFdvwvJrRgMbliZCBT12YFBZNDB5LgEqmmcPVtnEAMli8dADZ3tQ+l0M8GhrURiYWA8g+vrMeOcrUV/OZE6z9gIGX6FHX+8lbfgy7r2jdOESYd/bU9tvlxJul3gLlHJIh9t2MFUM9j5fWl6/Sp6vYm4P0zL1N3s+3Cu77+rLzbLUptF2+dMhcR1t7af5X/Q+4nYpdt803IRztMSvqM8tP8hzPy9ux3nVq0zgtsirTd4WVXqMxzLjYiW22DZF9BuVXRou8r7/eF6rU4iOrM79BQNrsur4qxPZo16f6BKco1LmsfRV3FmWNh3D48lfIu4/XCCz4Nyr81xuhsaVg/MzluctXXzudC5PD7eh+Zr84NO+HevkD8SX8W3co/rqYb5jhurFqzKT3eEJqS81WFdutz17ereEbFsZ4e35t80l2TsqwsD1p75Ka2tk1/g+XZA00s/yST7LcleHdaVI6ZLd/bk1Kg+FEhvvyt42k1nY37qGQWxLpQlza0RlluHKuoWhxvxLd51Np4uIONKc2Hhhfq4Qkwn+ONexsTafvqeh3hcvz22j0zyCUK7Renw7ccgP/QhFP81gpbPhYqzZoLSKT5eLQdd6PGK3RWz5FG8pfAuKqHlxbQjvep1sLjDIrlW7N7ij6kvOI0Xv+PTM0dudu2IGCyUFqqS6LmcNFFlknj816qQdm+b3BN9h8OGo3aT8623xuzpTgr8NdWu0N7i9NdcbG7lTqRd8e5nC1K4l55ftMgruC+0T30OrZuSntyGc7xKV1Wl66YIXGrcSxYNE8Z/8xLrnG9blLS7r14BZNz44Tenot76SEcm6ythLuxjfj4+3FhnGB7LdH+l9Y6cTUMzj5xvwNmA0tc0tmLivKVkW9SmQtn9J6UuEW2FG3b26Tr/U6nUPhBYULlo5tT44ecp1eiNUsszoNb5fMqJYuOoevF85782ksm+R+osJxT1vXj70nyum/n485EKw23jry6H0my67wkqi3rpwwKxrpFel59/krlHM0ilhP1LqW8T0ggBHq9m1e9+48PXO+QNJd+fx9Vd+Id2DMyBdB3LSRXIXow5nHio784SgpVW95tu3iu9CcUcYcVN3kH8kx1YJns9HHGSdRx8vvWC4SigQOQEpPv1BurXwql6zK+7/YLSaH41W/9NINRc7TLpwpPrnKDXv9wi1yiaDaqJ4x38s3tUVZvbbhJjer1iY1H5OgN9ElUm3Zv8+IPp1gVDEgo8hxav19Z0FEhftl984x12jQ0lcq6qkNW0vLlP6zImIxeyGu2Ojrc/Py/bISLb+UMa9plLu4ani98vSBv2VlLo+9ylO1by29bi17Vnpycy8NuiLsxWTwlyX87tLZV6yHwsdHa1SHk++c/DSQ0Bdlj3d4paGovDHEafIEhb8pfy9jU2eb8bKSh8EXVifFxF8QjztBKvqCOihHWB9gsV/o3nQ9thY5diMIb6Ip8xrG5JjB16ZuPnXGAbOfR7AGjz1RqOAZ6FU7vXlHlPinx8HxrbdUXGePDj4zjF2m5HIjc99dxS9r2Yllz28c08t5Oqt0PyD92/ekxjzulrnKVOw3rjJRalB+/O6QZvTPt9EjlXf+ah19OVr/uZBPCfnvCj/6y7D2a4yckajUgvN53qN302ovTt4/5zGwS1ulum5U6GXt4VZyNQFrQ1yf6Hb/f5KpOP+mNrFTxZlvNLir1a4/XjQXXXQTGiT9lpn1uvX3lkf2nglb4tx/YMrk0ZMW7KmoHlVNokdiK6OKVzxxuoq3sLY3o0v0s3jDFdJOrC9FYzpZY8zbZVqPFI03/Sox+hZ9tqrxnOXmjgeuLWNd24kC48Ny+ZVXHz7CcoNbBJc0oI3H6s56spLXxMyFrerNWjszg9K/7bs3dzlipu+XJvCu2wW3D36Vur27TL/An0XBWH7Vz6+rf7PYnqZSiUTQ8ZyPprfd1UfPk54GXt5XCVZPLlloCKz/zOT+O2lRUGGKkWbXMtaczsMur3DXw2JVOfyHBzBbdmqoJ4Ua3mOu+dUtJ+87KhOFFfI7vBeRi1HneaqfK3PTqcu5CVb37b3uB1lsERs/tEP9itThTPncI1WPBDuj5WI5eLMvba9R/L6sMic0Qsv3poB4QoR88+D1cOOHqePuPrwLe8RfxbPxlRcKVjUJH9irZpGS/qGi5Yq4/WuuzYnFJ8c0DnD9cpJ0qg0Uz2fxZvj0yvTvR4BYVcavkGHfHTvZjHMt90yRZBdbmvxsYjnaoCfQXwkS1abcEjNlp2fb4w/9mo5ZftMX6DZ7dl6ib4hl2Ft5w3be1c969Bk2top3Uuv5J89HJ7+ygFhaJ11nqNEXR0g3fZBdfWFhMZDtDjpuetLBuIzFyhqd5trJKvZsO2vWOTXU0BbDseotaIbOV7kPfYkOcT19eCHOS3qDaMlLXDAmjNzzuiQ3iDJL24S2LAkOvIE/gbzuiYO9T1Xgto/aa3BSa5rlBxsc92tOB28lmp/q/dwxK29HnjoTVO7cOWO5vNfNn1f56mw89SrbFmi6GUUfGIWxCe+LeEgai5r8H5cXZy3r/dO7P2RZfOPf7qRFFMykqfxrejlGrme9y3XugfUK0qHSO4tvraXtd3lZtRb1B+GS0MNf6bonN3xz7qC4zY2wZvHEus/Ro04slQ2wVvMbhrFTF5TwhqErs6WOzyHRD36At+PZ03zMk1H794+t6GzANxHinW/awizxzDUljEE9/gto0+9dIRmz/OvikqLD9z8A5lZ3Tzk6C/MHD4DZjajlt5bqEiz8fzpZoKa79k4FrM2wi3Xas7FRh9/YWbsozMoM4fGBMyPr6MDEGYOcDIHb9F4AucYlkPvDvzVzEzJHUZC17xI6JqXjw+H+MQCOJwgTkAAZejpsDUrK8LUiBtMdIcRUhbm5ESyiRC3l5UDDl1zwKFr2GWedol5RATZcDhk1e93PphNyR3++v4g9BIe7sfwcJtm74U21duCITFRgHHrZmh4kQ24JHkfMLbdFjoQYgWWWQQDl2H1iFVZgApbtgFL6yIgwjZbkNs2EmA4sA06XGYNVm/dC5x1WQW1ilqBgoI74dTdaEiI2RY8J7IfKFYMguTgVFZvgzDAyswV0rxrCXq8DwAmNWOhr2k2oGZrOBD8eg90f8wKFNLYA4yobYKOrrYE72TvAPLgKaIBG29DG6KANq9DULmSDVhzcR8gWrwPWnPMClzRFgxkSm+FukYsQLbtfgDnoxXQHnhKQfCUWugRD7nZ2YOcb2IB194EqEfUHrRTjQWSAxKhXR/swJTEA0DNxBGI+ZId2NQbA+D2J0FH/O1AWYsYAGA/Dknq2IGbc6KBwCPJUC6THXiFORq4v9gO8os1Bzk5NwMBx6wg99vm4BrRLYDcpBm0qsMczF7gBTS6G0MW/BbgkKo3kFilDwF6FqC+3lbAUFUXUtlmASZa+wCjadrQgnQLsMnJFyhadiXm/IXOpYi+mqS1Naezln6k9ya8W6QHh63tosGscysS71dvvCnst2dTLWdqgajN4nuVN49mK7esNW54XLFfVLBlX0C46NyUTXP3zN/VsGAy7JJMW0CEfpztk/y7Tx+e7/02ppUR5bN4B/0Q+8W+sc9C6T70ayVs2j456N5LollCl6N1+lFyNouics4TfrfwMy/ol4M5a58XllsVhpn0zc9p3SQp7Sq8rOgeY/sO2iFGh1WSWm2fVgCL2hpkDz3lUAiz8ZOYaqjsZtCSnt/yYudVZt+YNL+HDy6m0uaVf03eo1/OuTKh+8TgFoG6m7pOmuUuW896B35IddzX8Aq30mDZljU2z7bS2z+eOiCmZMThKp37pLhs7aViNt/IrePm/J7bT4bVPxiZb6jwijbI4N5dl2ynUdr06M+t+wJ66eXPXs6xDx+q5fw4Z8+iwC1MLTg4zTb/5mrI4EnB9aZrOsquS742nqmmo3Nl/GqtUlWmELbk7UQju13ugFVLxVMxzxxO35PDp7OtT2RW6baEGjBeZ0guowMRIr7hY+eFydpSrb7KQqcLu8oAu0Ul+0MAdpa5Dmn62HCxC/AtvcJ+8FIzmModfIVe9ArL7ixB7eHQgI0VW5e01coeHO098bRE5h5nqm/ghc6bxd2bntlZjWy5Gw37yo8uyvk9WbWn92Ss/8ALO6tvHj1+aZE9X051ZEx0eR248i71+KdvTcV+J7ICr0cNPT+J7zhgoXhSOW3n97WdChsHnX/+jij/45/Y2DEtuKlTgT8wzE9YqXBx3u09q+hIgWkT1morzQkXs1prEVKE+l5ceOwvEepFyaHClyXKorLh7K5O5efzRPbcCWAmFdhUhXrBvnFc/ObvVLyEBqViboSKm5jgUDOhdZqPffeIvChUnDy1ecyqfok29L60K29vTtTX9RntJcM61mOu4+YXgmGvO9hmJLU5hCaJ8WvRwRPXD/+BfBznuY/nFz62nUEGsAgTZitZ8qXPXSfndoJaDVNTj+UngkZpOTOLzUPC56ETr87F1FAJT/94nDbxXUEXkvnLznTlEfIpAC+eCB9/iDUg8nFvmiWoCi/4fzkfc7Dg2DlZWX7xlAWQ8LSAoOB3LiaGpdnYEC7GCbGzE3O5YC5mF+HiEoG9ZGEROJ8L5mBWTnFx2GEmbidz8oiK8vCKiiIeMw7mb2SNf9dOP4p5hEO8Gs7+3Sb2aNsTjrvGLII7Vx+QvZtb9nRT3NvesXytce9XhPsq7Z5HY29pGMe2nH7Ron9b3g8wIciev/1Y98CRYy2nTTSCPgYHixfhe4MinQTn4ZKao6On6hMvf7kttu58Pd/ioV1ve+fsTxINPxm3cCAkwfetyI4RtZI0iXUdTdy5n+dpLlozx//FQol9CncaLTT6Oa5tacdV5NMGfNIpKXhbXR0szZd++2HlrtShQtOjLwfztQ0iCnQIdy/H+l57z39skd7TVJ7l3sniq5KiBb5dZV48l91RvX44cYHICq/Auc1z62SL1nN6v5PWOnGkYZXonNyd8x+szrRhm5/xbFm19lGz4SsHYw5Ixg/NnxtwKauBS+sYji/i4U6HqFMHTFfKy3gZhbk2+X41H+Rx23Y+JdCMk6WAWSGEoGzk1ncnaWqSdX9tMP7bmTL+a6fODtPPw2ddPng0/RYyyh7Gj5Zglm6Lp7e5wwEu/WcLfNu4w80P7X/BJyBbMsd1iRT3rpwTOUOnvm7aqN7k/pKvadvoeCSu4As785sStq5mTudm+p5Pj98SglPfvdEc9eb0vKdyStM71NWl9HBh1bwhhZPNrNXP05+7PHdp8ClaVv/FJSX/YhBvr19FbLjGtuIjaw75BJ/8ED/a5OQVKLk25W7Ut9unlyH00jtUxECUMYE8KZgj3JrPsJmRKzmAWY77OivPPg9jawbdGvawXUwxkJTiynMfxWQZSmg8GHiP9s8/XfThVGCv8jzOou6Kp5HGdwgudRVGPVHB396yvjx8qDJW57VYikywcZNE0vLnz9Kmio4Yin8yNho6HOjUZTJZ2nHUuKc1+Vjfnc+5N4aWpMj0Juz+IOE3hV91ZqMM7a3UvO9rFRV+sT8JuRIBPKIQi61AYrELdZYvuji6oXncSNtS+Elw2/vxB/ncnZucK0pJ0Vl+sbVrb56c3LjzjQQxDgszyqhTyXiFLxJ21YZ3NiU2uqCu3uA0/+RMPhpSnLo/fGGIYJg/tTRyT/IEp+tPeUqnrL+VDrtNJysBdqHM1U123lOeY2eZfSf3LJDcSIA7luRQxZflRdbBLmUDc2uw7jt8Kz3NqNDHC3Nx/Av/QHp5wOOw+Rd68ZmBu6eOzVSaH8XX9PJNHSFjv0/c2vnvv9MLLnPdBf2zv9IL9i9G1HjlhSHljxsq1D9ENxNsKzwgXQWL7/Qiv9ga1Fzg+H9195ORH4dDdj5hcqFHKIVZip4e3v+kQ3c/EVeQDScoKCCIw2F3QVnh7U/E1UN2Q7E7oOxLzr+h5PIhLlwHzOirhywAkXwCpEZrBdaA1sB+NwNov7sVaBhvC3zBm0Evy63Awnp7YE2RNSQLq0gZVtGaZENI7LQl+ITFEvAZM4OWTVmCr9StgXBnG2iFsxXY4m4LpO62gOgIluDDGjNgZZIt1JVsCW58bwHwX3KEXvVZgrgvVkDDOnvo4zsLsPi4CQAuWQWlK1mCQ9FmwIUxJ8gxyhJU2GVBdOFM4GnSBU8TceM1UHWIBXjb2QiQL3eB7CotwMilJoCm6QbojaglaMdgBpjC08ppiyUo9dqc6Fb1b7UE2T+ZE92tKcASLKo3I7phbLyWoG+1KdE9E2qzAGVKTIhum2yBBfgy35jozinGWIBR54yIbp72GgtweYohkFvuDt3MsgTBOZYA5+N1EL7BEnTfYgX4lrlAHnxWYNQNa+D5g7VQibkVmDNlA6iWroJE9luBlSZ2wPGSFZBfoRXYc8QeGCm2gyoGrUDuRgfgnPflGinONU8QfSWqRdgQ9eX6XV8cNRWL9LeJMX7pk1zgXnV/vVZkxekSx3UybLkb2ZlY2J6dPbz/pOPKII7OV0FJHesGqsrEys9+XRnNMeSR0KUtEJk/NvA55Gn3qc5LO6BsHq+l3cZWjCLb7XnGz510D/rSai18+nXRmKv7Ba1ndpeyfM9nvyg4MZS7q+bweZ733UEvHij7NH3qi196fVP2cApen9nX4XRfjVddcxXLmQ8XVRTzJwUe+F5+wuF0QyPm7Lok+42jAce22Vy4ZrHGKHV4g86RlJoRlVP6bXWb6i5f2N9hy+9zxLPpVLf0ikyerLtW+K8ttp86upvK5zpzJLnc6asGVIM3v11/CbcuJL5/94KrAnP2bEk/tfBbZkH0yR0nnzFKarZ27ZjHnll76Zrpo3pDRZdztmAeXqI1dqrHfdNAO41ng6L5lMFQzVPxPZ8YHzH13NbjCHxsedP6qXbHR2NXifiG/lNqDbVCZo4mLaemoO1P6BWbnB8izJua+SpjOj2MdD8H1QWve+jR+yzD/dGLwXec+vWVwfTnzNS1GWo/xzvlh5cHr9Dc2wYnF0nohz/sz5RqAUTkOc/otjjHGLhu4+LgYX5mFTaUvfnGPlKdD7oqj3W4OGwDrz1jNw/vou03G5cKOT0iNWq/SyQ5MiVYLoczV9Iw/EFJyOnlXBzPmTN128NGgO3wV20ae5qtHVm5Kr3fV3Iq5JvD4XaQQqgV793+cEUhK6f14vCSPr3jo/Z8zaT9T5nhz6eakj0kchk6itdbjbyZMC0vqcI+4yl5vzju3KTSiVGYgf/JE545U2pZKYFC1XlM9aFMFpNKaZIB/tucWB5xaBSLdToLTbnemDjffVwCGok6HZI8MWI9qLhHCnm8U+LH451yocppeJodIQMCh1uWbf0DuVfg/UXwF+6NmAH3mlMLtd7pSLr1OOTxd6HyaL8dpumntgn64y9Gody7NeCmVYrDBSL3XnCyBIXgRVLR05rIvZGvVv0f5F4+hHtxsH9HjXepcS551hEl3l3B0rjql81Q4gYbk2vN2QQVnIHsmZXRD7zAmIT2Nu/1bSEdtZ/XFgYxf3r1QnWO+doXZXNGhbmfgGNXV5xdPA/MzRDCdUfPPZaPO+g3x53h8hmDpdZsCwuedn5Ku7Ga94aWff0h41edVasr9icFhAhdXZ17c+C5+C0lV9VVnrdXdTT7FrwMvCvPrBPskeY36OX80YB3eLLGYcn8NBfz94ZlL4ePKu6qM5Dr2JJrcmvZmwOE+N0ntW92czPrFez2jmMJllx2Kwm/41uO22jUaS1Rj8H5pVctY5uvAvg9KpWXVqatZFV9u/5Wr5lyn3LG5PJNQstEHu39ZK28id1sfqvQbp7ORrvIh0rhiXczLOdzqI+yTxZt25G9oGFEde/Y9stDVbjQQ9cz9jTWar/ev7+V81jT6PLX8iGjeYyFbE4iK3DKSxQC5JlWF21M7uTWCk5/7tgamaskJGb5qddGr7d+aOeCmsh9bs0b2HqcPj83O3t/ZRF/kqeLiyR30QXP0gfuVgWLWb81mZy+3OSwYT/+5lqt4vcfX/q7vR3hHGcW57ysK7asYwDR1fHLo3FEXUWSZQcTjJPchB7KNDGrfGyRmqO2jOFTIsedlR176/tX2YBcCtz60qszDS2519nW2Gc5ygnedfU4HhkpG9TUGyLFumvL4wil41tFkk6vZDpuNtBRz7lpWXH/lgnvOLZM5uqd9pPCmukHDqV/jXZ6cMPk2egRicDN0s6pXLuTBz8+1pfv0Bd9bzPs6VW8cLm1uPVi0TWR+swX6a6FxkWNGuRNDb5ZILxEUlChm+ne1GaxLbxVW5nlvYVjjfTTQ9ge31OznPI94SO74vjB1KaTN8Vl+y6WtT+1FPwc3XD069vk2paLDFlPD9p9O3lq9+HTvWe39V2uVVdmqX5UFrPGUrOf5ZCC0COfMxOtDPtdDNOVilOHbiX2BMRFD/XiNUYf3nqXNCnC+WaVslrKR4+5p8cufbXP+vikUGh++0HHRZZb8LxV+WWXM2vf8jy7u65BvfX6xr1Cwxu6xj4O2EYm16s4+2ZKMq0fdmo9Ne9ZzmCYUXZH7Hm7+YW0+CFDr48m2x+WOhqtLVK4c7h/GP9y7k3BHZsu3EeYOcAXFMDsfW4PbveCE4Il4ixd69aU0ZqPnajf6zklJXpL63PchBrxSR3mZ1zbgtdE3ypU0G9oFJCtvpctKQ/vYbZI1XF4SFqnK7zQulA0Yb17zFt3aK9H9PJg0Qu7FKvuxUjO4zz3trPPe04L1/ZVxxYzf456JgXTuS3z0tcSctX4/EdMclvpaeZyW/AQTJm2fF/eqRByGOduOap7nwuRvc9dIr30EipypSPTm6AO78dVhXPpTopykTZDLy6/ddtLc6Kq74r296d09IaPP3vhYmgHR1x1ZLwzm89vCXzfCbPvLpisG/lzp65qV4Z+f6gn63PUyFMuUrSVwAtHW1VGKnwxWUnh6O5n+j5493MTiOygwpufybsV90i+0L7QF/VsGIm11lX26L0s/7rkDyTkuyHZy/53WUliZM5w53yDnMeb338XqsrVrsLjy6+EjP0zkl4X7qU3q7cSrm1aG9ABX2dNCiMScqOfJZGQ15+3ATdneP5fIuT/L3ufwmwwIf/DvU/tBhcnSo6wBjzcDwWtwT2w/dN5cAV0MdgaVC93AtKurYUSmqzBL3fdAMvX66AAPRsw+7I7QDPuAa2B1bMOUU/KWkiWwxoU/roaeFW4DsJtswZTPjgDF1s8oM8vrEGRN+sAgTProJOnrMBRoZUAV7kHFEpnDYIcawGWnq2Q20Zr8ACtKyCf5wEJKFqBDYADYPJiKzR0xArsUl0FbBrZAb36ZgWOyTkBdEke0BV4irTDUwS8sxWKL4GdWQ9bILxpB+Q91wpMcl4BPGAIhsxjrEAv+9Vw/TBIrtsK1DN1Bq5utYPC31uBbJtXAnI7VkBAthWYPLECOLNzFTSxzQqce9gBEA9dC91dbgVek7UHjkW4QEH0ViDhli2AP7AOUqu0BCvNbIDoeHeo/6gluKrJCtCX3QP5ylqD82+4ABESwdDNNdYgm5QbUCoUBE0kWoO9B9YBdLz+kN4Ta/D54HoA5PCDYmhtwJuu7sBeZh/oqYYNeKJiI1BC6wXx+9qAe9Q8gH3Sl3jl/JYQH7FyPsE8ra8IMlK2Qgyoh2twCte7rY03bIg257CVObSskX23RfXKN6dtRTPM9PYx7P8SLWVtrSuYR7dGLYNtjq5QuUXJ17IwVl0DXO/YqaXcMQ8YOeiuzsGN3ozqj+oPdsTZiDssf1mq5Mhio3laZefBtsnTJeXXnz/VEejNKhkxPNuYKj94yuCOpadnQltpgq6n/qce/mMt88P9ip+fe9T3JefhCtPsZRV+w2+lpvSzO3gqDMsyra1XyxbMFZj0P5v1Tv5RsMIeguPy7YfdOwoNqtafzVY71mYfIbSoO+BK3AYFiUsL+VNXrn4iUJL5/PB2+dA6mUpm04b7+5JwF4tsl5UrPbt3cNDtbG23fIEg+CFtMje27f2a6OOti+vLeV6Ijp9w2PVea5OPcA3b2d5L8j4d7PscTScEV/q5sMvlJcmW9A0mG4Q4LOTeNFIgWBKY23hm1bhtxLncxI7Rb4+kkytMM8b8zyvc33HxeSF7xSuX2A1rszuTd+StGvewPnG7xPbElSARu+WHN43gg/e+sbP3kUxBKDlv0Hx6w+LgD0rmWH9zEw3d4ariLmCg4WQvdL1ur5HrromrWwIUdxa0U2Zl5zsXUFbmp8rKTneiEVaeazvNyr0Wqzlf4bPgNiJnONdd1rZPk9wYz2HfwERjGu01yJbofPb7Gk+FlVvv/D/27jwa6v3/A7ilyL7vY+z7WokkSyOurCOh7EKSmErITojU1SJ7aLHmZjfWmEiyF4qxJLvsIkvIb3RvXXf7nd/vnN8/9/t7Pc7xx8wxf3zOzHk/X+/P5/V5fVoE/qZf+HvgElL5kERaG9f7n+YLDaQ7nCWMghdNq+WmK+qyacerh/rWTTBZ5cGFf7kESvXfXAK1nbR8/oWnt3bj91tpy/3jttqfb7ScHeO+trj/+XJK0GLSw9mwhdoc6RyJwdKg9K+09wOe/DrT4sOGMlql2Z+Q8KrE55A35yiLCWeqA8vJjb/Kcn7bKltlL4bZqnf9G6+C9u5W5fq/O029ncwZn16W0m+0qp5rXKL2W/r9tPQlvPPc322V/zxk+vv7pW1zyy0NNaopZEE4fsIyuj10cHX9LM5g+v9dMv/zTTo7r4Ryc39L5n+4SYeQzIh/ukkH5Rw1+HfJvDNp6ZWdcDGlhI3XLUc1Xn8n3JsGQ1S1r4OabLUTjrrXEOV6zk5t55DCQE0MLuiYIepJg72afygGt8/MEFVWf1rN7wUGN3LOEPWqzkZt3sAd59yDRqnvOq3Wf9MdFzWJRhUy2qg1NrjjKr6gUQJ8VmrWp3xwxs5oVJ+KtZrSPR/ckjca9dTSUo2tzQcXFUGoGnzN/5C0Z/MDcWobBih3Lwu1lpZAnDEVGpWeaaa2bzIQd44TjeruOvmHIYU7029nKu5My50pujNdd6buzjTeOSxw5xDBncMFdw4d3DmMcOeQwp3DCzeUsq2c43rit7+v5qjuX2/SdP49mdE6Wsw27MwLvb69B6iv0lde1qbfNTWQ5s9GUpuWqR4myxr7Yj6PT+WqWohkrNpCqsQeJHU5y3E52QG+CXqUiMzViqX56LcxrAxWCb2yzQq35i7rUWfJjMlQfUity/vSUBlA1mfw4vXSm40Rprxc+WvrDm76wbmTp7v79vF472rVKawQ8EfoakX1yVfvJ4s8VjiP79N83iVyml1FNreKyiMioBBTdZu0a9JOazo+hYdIonxmzen9JdL79Kprtb4L5Ye57D4oLC47f4iQ+1g99lHHpkRuTXVs7vgHTXXqpp/GYqM+XDCinqpuHrDa5Wx+etV0r4ElUWzRAtZbJZmk7dyw0ShWhSiFKmD1XHJTsGVP+3K/7wV6CzbpiWVd1TjjrXL1xaxEm+hDzAGJbZ+vmiYU63x5K3cwu89urfJVoIO7dKOqJ9U0favoih+rZOa42GbZZbrD6C2BzWX8nivGpakDyT57vpJH1mP5AgoebW0HcCjzSM2f9sQ++aX9hH7grxhn4o7TGZzPL4/kmMn2Lz9ASLep2FXT/HYOejt2+V0xVAwlJbuvF7pMkv86y8KfuIgus431HPLEgD8hgbG862pyR5Oe0ZxQjjvT+4KOibzjvvsalv5iZplOrPqSutP2+Ius4DhnOpbxMLwdKUsJMZHg3vNI6rbBiR/r+D+kr8BFoZh/7EAy3u5AKio67JvoIvdhgzq3yTnHWnPe1L5uYcLeuWatrcLqjIKsk+LBv+yJKwLXYge/b4L/Z7tiuprfWpCYv2+Kh75vinX/sCnm2W4J3j7dbbvdEeyZ6Zc5SbiivBu98mid/CU5Eevox4pyvtnRf2H28puT6P8leykp/+fZ2/7buOYDsn96WFSyKrKKWOz3rJ3SKKuvGJlTvZLRPGhcuFA9nH5NGaPA8mNY+oVVubz3I0OquNdrxUdTOdRcf3u9PVnqewcSGeE6YKuINWpaOus/NXtZWWho2FgJfzTMzOxsTExszExMNCwIBDsTIyMZNRUVAzsjoW8IgaBAEDqJEHR0PKKcnBy8nJycvDw8dAh6ekoKMjIeJB8flxAFBRenkBAVJRkZPYKCEOnU1JzCQkJC5BQUnCLCwhIykpJCktLSnKIiIsR7yMmJifbsIREiJSUWIiEhJif8nzQpqSgPHx8/UkBAEMnNLYAUFOTnQyJlpCUlpaVIScXFZGQkxGVkpAinzAmlAoUa4XAUBXu0vh2uDMmPLqZGjO5NYgT5vMnafqkATkzEz+H5dh3dZs3+62al5eNl5T59b94yRXsNFTXgb18UMuiX3tJsd8qmLXGWj34qxrUi0Xj33lGXHvYc21GNF/w6Pu/9rHx7EutL3fRY9RXFs/xe5ga8OrnxMX2MjpiDxqk4obrCYWINO1ZtwpGi0Gk0Os3vkaNXV6lo0hiZO6Zh3SIaj43S98eVbJjosrG+wZiqYo6f7/Z+dB8lcb/StTl8pmGfmJ5+uphAZErzg2SkyFykVmhbiv7CwH1f0UMs6sE+Z6pqfo7n16Q8WlPrW9UpPJR/+pHbHLevYGs4JR5lUEuF/7CvRjrN6FJJTXyYhiSPHLpJILSeLiK8R/j1pGaojptGSD/DRILpYNq6hu7RcLmt+NDPU7tvlkedxUtzVR+WemD8/lh5jqR8Nf0D186OmBELZASDLa3Bm6/xuqQHBQ0W30iQlZrOdtzvsA10CDMudGgPZPHiP3DU5+DDrhDrsjTmIuuRnFW5pX6p9Di1vb05XLYUrHcV5FN+Etl9FCHxYNqGxbTqwEOZ42ljC+K01HHo6MftffR0AR8V+DKM025q0cn4Olx1PSLWT7V48XxUyB1V8Tpdr7Xzj0J6ArUdVJ2vrF7nwDJGC2tmKxrK2l23SgtSUPl65VQNsaliWufalY1rIZEHFYrxfggzEb6cfg0KCpXIJ7EXrKQftwbMXVkMpxEqrOxMWrq/yO2Tf65b/RmbWTfPOY36zewlHlM07WNS+co327+hh7VF77/9hrafRfDrb6hpdbQoZS1zyf9U0z0/jsfThvLXzxNpiZAHvu0R2wjcvudsbi/Jn07dDy92O01VFr38+qVaupeX1yXFxSlxTyqbS5+TEdEQz0x+Jnm7r5q7dgSZB2+C6leiOBVOYRJWx6zFPLbs+LNTxUb1+oIB2Keb9pZKD1PTsGfKvD1IHk65uPd9njmz6pK3iXWPnLkVL3HeISUZSxNQjnunMVIy4xEcj+1l1pgZeuvZI70n0TF7/WKiy8eKMmyAh0v+Z9dEZ58nDlFPr/ZZmJtGJWHD6ljOX6H27PF4OVBQllrR4aGZemdG92kSVrFlFCsx7rd/IC3dpuNuUcfYrbtXW7wddcx9vHZzVXVZYn9up5SnVsNxV9XSZraeN7NTuC293/NmXvH6ikvYWkLmMPaijIyZiKdLiV1DinN/hWeF5XyT2tQMD7bX4Vnl2c9orzBuZ7xUYvRG27RgFSaPoq3CIcP0jWut9/J9y0UR50SpnrCZ07QpCpj9Pk6elvPYz2X32TysTTXxWpL+rl3zl/P1alocPbpGL0mpSEYUKHRP29wpwtWovDB9MdRusdeHSNHgcchyUE/39zXy79bZ7VXQ+92UwrevrevHcmHZ7ifZeZGwXFifPnk/Lrt53/EoqTNeHpNu3Ybnao8nx6BFozLyLywWaSEfNdfRZxwzRR4a30u30uFlwlFyWDCjYiAp4/GZ2cMv4v1dZ75OLA5Mra9VVae08Qx0fGR6GeJiue9TLmJzkd2slKPzkbICMTnJL6JnekpvjI6RRF94nRqs9NUOl2KcqyhqPZv3xrivnmgtV250TodlnOyShMTYqSilp04XzSgFWvmCNHTkOtF3xRxuez+sdrLPGxx0K+K9JCpel0varR+2Kdmp9t4RFdpHkZnQd3ni5Qnvd+dCRRmreA95fGY5229CqVwz+jDEcmuPXu+hVcn+Bdlnn2miTTjqIiMSgnwmHWumYohPZNw6qyk7F1JnQO4oZzTvW07zsVaJ/LVbG7qtkfXRUsshP0ERlsOl2lMFbKjL3KVvfxlznO9WdROvQoXTVkhG1zlV70rR7Pmg3XEoeSup0OE8sTnFEo3AggwzhWBJP1fpHtfQowNx7HsjrrDZ9sk6izqMLOeVsBoKHj964Xhh8AG/KOz12o0nN6bc+chOPWtN6iglbX/J3p7oZsPO+WpsEKlsgJi3+IC65b3vp/DeivSk4ZIaYuOEyAvNBiR7lUyavRjINKwMoqrkw9UeFwfH3UxURNBXkTzFRbinMl5UKFB/gHVGft47N7p/wQuPPXLPm4riitlnBJ00Pe5Td+yBrOBdG63RIvz8xKVheDbrR1q8q0cZqxuRwSXrGC2Dwxeyv1gEoag1xV9qeV5yoBfMrsSYKlHdijRLdz05i3qxNNJ5fgARd/Te0pkFLN+dtCPHGJprO1eT71otCy/RmQTI6A6rm3oKiW3VqKRaUzk11a4cMX8/x9e4fgF7T4EjSZhI38/ctIaO4+YNXwXMxOLD3GvqLIX2edw1sj9fHyK+9zk3qblLOFazIsJxfuugBSqj+5DzbbfZ2dbDONnX/c6YckQWqnXeCdFTt8lG3ukvEyYwHfkvLAudvuj4/aUspPtflIVdfy4Lv5WD10tUv3UxmP32PIgdZaF2qXZgCnte9Z3WI78M23H8KAu7xe89mhkbUr20hhLXJJSFXb+9TjgxgGNu0UMdJ7SubXcO/oePpt7e8hGTU1Ftl2pk1OTkJMQ0NGKEEpGEhpRUjFAiUtLS0DCKEUpFYioqOlpKSipyaurtko+OklAS0hAujFBSUDAyiIkhGNjZEWysrAhWFhY2BDu7GCkNDT+hBOTnExWVIpWWRgoSSj9BAQFhAX5+EWF+fiEBYWFJJOEtQgkoQ0r4PBcDA5cYA4MYFw8Pj7iYmAyhTBTnQSJ5uHh5t8tQXi5OTqSEuLgEUlJyF6mU1Hakp3DXs307XNnfy8ImSy2ji+z1F0NzGnXLM29TUzDsbcwsmvi8wBZj77ol4Fj/1KlVoY9aPIq6PZ2V0wWZFNkZX0ByoAvd6Bph5TtRl5AvqyFQiaa6ax8aFGHPVle2buFbLfVJjq341PwrzzBpumeDOWja9nFLe21fHFOWcLPgu47BXj0E/gwut4HyUd5xFY679HbNGTFbueOWyEc3vhxQMl1EF3Zm4JPtn698cW1xCGW1P1+mk3hIqfRL0VVmzH6hW6uKLZgXu02VGiTaFE8/5fArthK/tfXK7p1Fs9VkWo4/nY+0+J64pMsTYWH9QpTl6jRLQjnBXK3imWXvtEwluS0waJvIy2+SWaNVixoz8w6J1gwPPZ6ieTVx8fX9rpZgBerwzckHps+eIrbqA+tc9L8oP/4Uov5yPZvmHucJL93ofAz+WIuBMdK9YT5G0Qn70+gD85flKbScJ91ul5Dtz1+04Hga45j/WPvWYLO29pZJo4SSoGCxdYZRlZl0fCPq7dNEM9WurNr4Ud2WGybcnPUsLYMNhyr94zIU91mEsbzVHou9OuxBMa33Kj2UhuMww+vhunu67mtOFqa/1F9Pl4zw971pVPOZPfQBqfxzjAJVt4jeCWe2+1wC9Npyb8LN59s9iI2K78h/2ZVNQVI7jGde7mocW2eknMVrrZQFSkTqzNMwG43b0Fak72ZNHu2ofJJXfdwmgDfWgw5/8LR2zVo7KqK4d9VIrQZtvFeDO//iFBOFoZ7QEp1gHY0iEVHZyPaPaIHvY/Jf60L7tssneqw69tVJ291TbhS+Q0PUnf48iH0wU2y7LjxwrYnx22eu/6gLF6vtHcYfp9kM06V26YTigyZONtyw8R4WdPKhf+Z1LcXv1Cayt3aIUp5cv7JAL9owz3ZmJN/O9ETeqWITvGvak6t65hNIczy1vE96iDLW0FMf/9ZhJv+p/xvblWz7W09HdayU7lCpuqiyX+pmY64qePq+zTXAZAIrlShT8exdTAeWCZOPD0jyeR6jbP2+avmtVK/6otDMqeaUHhNreuyckz/G+eUrx7bx/PrlMXfF9cjuYKzO10b8flaeQil0TEnu7EEX52ExjMzdqvp3l51+9kNvIHsrrmUtM9WudGPnFotV56rrTQZ6m61m46ItldFVlx4WWErfrjpea8e2O3VYvrLAnbx9ndYMn2WtU1jt8apxNtcxcrOi1sQjdoW1p5C7uMDc6aRr2x3b8556yv1Vza2d0uYH+7/mh5f1bwU4LQflSk0LV2sXKtw2ztdJHMFsTT8r73/4Cb2uGFY0M3L68Uxw+mSvsZJQj1tmQo+YxUqhKjoH0yUwibG+qN0x65hXrUwU8SB+0pzzQdCPXPm7xZOwEipEPUn49s11/1gy7GzUdh9pnvXKSKjqrl1tsFG5QXpTZiCh+MTWnhTSJ5XhpDUhe8yj3AJWlE8uNuA3BwV8rlEEuMf+5Nc73rQx9jEbp7RMTZGstlayrh88KoPfL7dKvOb5cEN9GaEQ13Q0oQzhzyzjMOnz5ZWK8Lm2w3M/NdOahfnvenvYyz6lctGBx3lRZv0EcUrdqVs8+Btd55XnKz9Gb14tXUsRQCoX3NIKVxXzSmkaVHfLTywc1vNZKY9kvM5kQVtiJ9fkITyQr5BQaGjlKxBby9SxrvO5d7a3aabcXfsya6z6qfUs0yN8dDMZ3Rc4raaGPPMy7XprA0aD/MYNFRfGF3xpkxdjCH2t/SW58/vX1vtDuo7gn/P52zVYrv8ylXxLsfQK4qtKJceSxCTWT3oOUzyE8A/jMjNifea3/Or9pTP9OrOM/mFS66pn44SUCxwNHcwKUxMGHgq98PTr7w9bdlQoGsPLLyoJPrNw8j489PDZ1eLUc48LUoPrrt8VCAv6arfSO/IgANU8uHxV9Z2f2la1znxkWaLA0OuT+AJFEnaV2IiUe55UlIoTuxbOSpDO2PX6etiSo1WDawe4Cgx+nllLlz7YSTaikyljjln7cvvZWa+FYVberVa3Teowx9jpNP7+kwlHPvl4+x+mrbBLEewVSVo81hw0iDM25KB1Xt+vewmbOPWCm126GXMjv6RIwS9ffpYtNoS09mrznFtj88x4crHLhfu0IwayraUV7zrfX7PrehJa/QLBOZTQ3fGzSXfJYpVn4if15ue2HQkf1IY1ltlCTiBL/Eg/lb3Dxzo258XeC/8ld4PkRMqrctsv0bTrXR212jwtZOkiYapcvj20+P0xv3gm2EtOXrB1f5e9Ob6Cv0F2Yc/BJFb3kxc29d8UHlOaPuDOOOevy+jWjZveShQ5H+U3RZVDEqQf91VjWaItWYJ6iu0immhRAZ/SI5d1pfUEA3lQiHjrUFTFDLH+7qO7A/u0nv0La8Oogy61O2tDC/T+K9uH8f3JmX9U71Xx5ttBlfN/3vmpv3tOOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8J/svwAAAP//AwA= + + 00000000-0000-0000-0000-000000000000 + + + + + + 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 + + 00000000-0000-0000-0000-000000000000 + + + + + + 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 + + 00000000-0000-0000-0000-000000000000 + + + + + + + + + + + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + 3006909c-e805-4c62-8255-1e8e709f8f20 + Colour Swatch + Colour Swatch + false + 0 + + 255;64;255;105 + + + + + + + 881 + 175 + 124 + 20 + + + 881.401 + 175.9949 + + + + + + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + DFBuildAssembly + + + + + + true + true + 2 + + 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 + + 2f1524fc-5545-413b-8873-d185930a521c + true + false + true + DFBuildAssembly + DFBuildAssembly + 3 + + false + false + false + false + + + + + + 291 + 180 + 190 + 44 + + + 398 + 202 + + + + + + 2 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 1 + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + The name of the assembly to export. + abedbe99-1b9b-4b6a-a5b8-98b8f1005490 + i_assembly_name + i_assembly_name + true + 0 + 1 + true + 339266f0-2362-4309-95c6-49cc7bf5056a + 1 + The name of the assembly to export. + 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + + + + + + 293 + 182 + 90 + 20 + + + 339.5 + 192 + + + + + + + + 1 + true + The breps of the structure. + dfae0cc7-95f3-4bba-97be-fe7c59b22c31 + i_breps + i_breps + true + 1 + 1 + true + e96ace3f-1930-4d2a-ae94-1a0648c7d34a + 1 + The breps of the structure. + 2ceb0405-fdfe-403d-a4d6-8786da45fb9d + + + + + + 293 + 202 + 90 + 20 + + + 339.5 + 212 + + + + + + + + false + The create DFAssembly object representing the timber elements. + c59121fc-cb98-4fc0-b79f-a82d5cc73567 + o_assembly + o_assembly + false + 0 + 1 + true + 0 + The create DFAssembly object representing the timber elements. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 413 + 182 + 66 + 40 + + + 446 + 202 + + + + + + + + + + true + false + true + IyEgcHl0aG9uMwoKaW1wb3J0IFN5c3RlbQppbXBvcnQgdHlwaW5nCgppbXBvcnQgUmhpbm8KaW1wb3J0IFJoaW5vLkdlb21ldHJ5IGFzIHJnCmltcG9ydCBzY3JpcHRjb250ZXh0IGFzIHNjCgpmcm9tIGdocHl0aG9ubGliLmNvbXBvbmVudGJhc2UgaW1wb3J0IGV4ZWN1dGluZ2NvbXBvbmVudCBhcyBjb21wb25lbnQKCmltcG9ydCBkaWZmQ2hlY2sKZnJvbSBkaWZmQ2hlY2suZGZfZ2VvbWV0cmllcyBpbXBvcnQgREZCZWFtLCBERkFzc2VtYmx5CgoKY2xhc3MgREZCdWlsZEFzc2VtYmx5KGNvbXBvbmVudCk6CiAgICBkZWYgUnVuU2NyaXB0KHNlbGYsCiAgICAgICAgICAgIGlfYXNzZW1ibHlfbmFtZTogc3RyLAogICAgICAgICAgICBpX2JyZXBzOiBTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5MaXN0W1JoaW5vLkdlb21ldHJ5LkJyZXBdKToKICAgICAgICAiIiIKICAgICAgICAgICAgVGhpcyBjb21wb25lbnQgcGFyc2UgYSBzZXJpZXMgb2YgYnJlcHMgcmVwcmVzZW50aW5nIGEgdGltYmVyIHN0cnVjdHVyZSBvciBhIAogICAgICAgICAgICB0aW1iZXIgZWxlbWVudHMgaW50byBhIERGQXNzZW1ibHkgb2JqZWN0LgogICAgICAgICAgICAKICAgICAgICAgICAgOnBhcmFtIGlfYXNzZW1ibHlfbmFtZTogdGhlIG5hbWUgb2YgdGhlIGFzc2VtYmx5CiAgICAgICAgICAgIDpwYXJhbSBpX2JyZXBzOiBsaXN0IG9mIGJyZXBzCgogICAgICAgICAgICA6cmV0dXJuIG9fYXNzZW1ibHk6IHRoZSBERkFzc2VtYmx5IG9iamVjdAogICAgICAgICIiIgogICAgICAgIGJlYW1zOiB0eXBpbmcuTGlzdFtERkJlYW1dID0gW10KICAgICAgICBmb3IgYnJlcCBpbiBpX2JyZXBzOgogICAgICAgICAgICBiZWFtID0gREZCZWFtLmZyb21fYnJlcF9mYWNlKGJyZXApCiAgICAgICAgICAgIGJlYW1zLmFwcGVuZChiZWFtKQoKICAgICAgICBvX2Fzc2VtYmx5ID0gREZBc3NlbWJseShiZWFtcywgaV9hc3NlbWJseV9uYW1lKQoKICAgICAgICByZXR1cm4gb19hc3NlbWJseQoKCiMgaWYgX19uYW1lX18gPT0gIl9fbWFpbl9fIjoKIyAgICAgY29tcCA9IERGQnVpbGRBc3NlbWJseSgpCiMgICAgIG9fYXNzZW1ibHkgPSBjb21wLlJ1blNjcmlwdCgKIyAgICAgICAgIGlfYXNzZW1ibHlfbmFtZSwKIyAgICAgICAgIGlfYnJlcHMKIyAgICAgKQo= + S + + + + + *.*.python + 3.* + + + + + + + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + DFDeconstructAssembly + + + + + + true + true + 2 + + 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 + + 34994163-7d3f-43dc-8734-4b022f2cf4eb + true + false + true + DFDeconstructAssembly + DFDeconstructAssembly + 3 + + false + false + false + false + + + + + + 503 + 188 + 146 + 28 + + + 579 + 202 + + + + + + 1 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 1 + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + The DFAssembly object to deconstruct. + 21bd29cc-8423-43b8-bb2f-6612955f8586 + i_assembly + i_assembly + true + 0 + 1 + true + c59121fc-cb98-4fc0-b79f-a82d5cc73567 + 1 + The DFAssembly object to deconstruct. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 505 + 190 + 59 + 24 + + + 536 + 202 + + + + + + + + false + The set of beams contained by this DFAssembly object. + a6abedea-c082-42b6-afd8-8f07edec21a5 + o_beams + o_beams + false + 0 + 1 + true + 0 + The set of beams contained by this DFAssembly object. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 594 + 190 + 53 + 24 + + + 620.5 + 202 + + + + + + + + + + true + false + true + IyEgcHl0aG9uMwoKaW1wb3J0IFN5c3RlbQppbXBvcnQgdHlwaW5nCgppbXBvcnQgUmhpbm8KaW1wb3J0IFJoaW5vLkdlb21ldHJ5IGFzIHJnCmltcG9ydCBzY3JpcHRjb250ZXh0IGFzIHNjCgpmcm9tIGdocHl0aG9ubGliLmNvbXBvbmVudGJhc2UgaW1wb3J0IGV4ZWN1dGluZ2NvbXBvbmVudCBhcyBjb21wb25lbnQKCmltcG9ydCBkaWZmQ2hlY2sKZnJvbSBkaWZmQ2hlY2suZGZfZ2VvbWV0cmllcyBpbXBvcnQgREZCZWFtLCBERkFzc2VtYmx5CgoKY2xhc3MgREZEZWNvbnN0cnVjdEFzc2VtYmx5KGNvbXBvbmVudCk6CiAgICBkZWYgUnVuU2NyaXB0KHNlbGYsIGlfYXNzZW1ibHkpOgogICAgICAgICIiIgogICAgICAgICAgICBEZWNvbnN0cnVjdCB0aGUgREZBc3NlbWJseSBpbnRvIGEgc2V0IG9mIGRmX2JlYW1zIG9iamVjdHMuCiAgICAgICAgICAgIAogICAgICAgICAgICA6cGFyYW0gaV9hc3NlbWJseTogdGhlIERGQXNzZW1ibHkgb2JqZWN0CgogICAgICAgICAgICA6cmV0dXJuIG9fYmVhbXMKICAgICAgICAiIiIKICAgICAgICBvX2JlYW1zID0gaV9hc3NlbWJseS5iZWFtcwoKICAgICAgICByZXR1cm4gb19iZWFtcwoKCiMgaWYgX19uYW1lX18gPT0gIl9fbWFpbl9fIjoKIyAgICAgY29tcCA9IERGRGVjb25zdHJ1Y3RBc3NlbWJseSgpCiMgICAgIG9fYmVhbXMgPSBjb21wLlJ1blNjcmlwdCgKIyAgICAgICAgIGlfYXNzZW1ibHkKIyAgICAgKQo= + S + + + + + *.*.python + 3.* + + + + + + + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + DFDeconstructBeam + + + + + + true + true + 2 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABgmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkUsoRFEcxn9mvBJZGCUpd4EVJSNZaogUpTHKa+HeOw9q7p3p3pGNpbJVFh4bg4WNNVsLW6WUR8naworYSNf/3FEzqVFOnc6v75zv65zvQCCfNi23shcsO+dExyLa7Ny8VvNMNXU0005YN93s5PRojLLj45YKtd70qCz+NxriCdeECk14yMw6OeEl4YG1XFbxrnDIXNbjwqfC3Y5cUPhe6UaBXxSnfA6ozJATiw4Lh4S1VAkbJWwuO5Zwv3BH3LIlPzBb4LjidcVWetX8uad6YX3CnplWusw2xhhnkik0DFZZIU2OHlltUVyish8p42/1/VPiMsS1gimOETJY6L4f9Qe/u3WT4b5CUn0Eqp48760Tarbha8vzPg897+sIgo9wYRf9mTwMvou+VdQ6DqBxA84ui5qxA+eb0PKQ1R3dl4IyA8kkvJ7IN81B0zXULRR6+9nn+A5i0tXEFeztQ1dKshfLvLu2tLc/z/j9EfkGvWVyxYNnmI8AAAAJcEhZcwAACwwAAAsMAT9AIsgAAAAHdElNRQfoBgoVIwEFfQDnAAACZUlEQVRIS72TXUhTYRjHhaArr7rpypsg6KorKyp0m2dna1O3udXIFY2NXbh07eyjNYgt0X11NfIiwwpj2EVBYGWJFVkXkRJE4qb7yIyQygtbon1snu3pnONzrHX5bvWDBw6cH++f93nep+6/s9dr3IaftUM9HYo1zZmXmpKn2OakBUwPbq6F9cXXkY7yE1Sqg5FnVywD46B5HocL5jxc7AChYlz1tRUeoUaOW/qplaGywBzJgJt6C2FN8Y+QMkS0G5dRJcdF5fQMlQa+PPIF/tCtEL6iWoijSo5DmrIyVGYzhOZD2N830ZWhV12IoEoOI30XEUO89HuI6koVIaH2752oksPNIy62y6f4IBwshvDFtUuPKjkOWfKaeJNzysqQmA4goPymQJUcl2zxmRjiV36EfuM6+PtzEDWxfOtKAdXyblTJ4V7XlFORAqv1DqhGLUBlbGCeuA0xg3AjNqIpN6BKjv3Eiy4fXainZ3umqLQN+LLdHxPnseE4vLAT1eqhZ5xvOscT4LuUhejJzV3hnvMPatfAdlTIOUNn9jDy9E9+JkH1162hY+VRqw5ny/yq+IR721YrQrh5fEGNnJ6DS/VMS64ohpyOvgLVvTB4hmaFkFB7cRFVcs7K8g3cMrJ8gGE4AY2TBpDP2SFwflkI4XZmGlVyuP3gQtIsHyAb80OfYf2vdpVeokqOozm3T389kdfeuPrZJc9C0LoC7nAKzMOjoLt1BVCrnm5rLsi3yzg4Ao1P9UJJHnprF2C3pA8x1Py/C+Dplsx0HRsagf2Pj8OBCdOa5K5nEn/VDvXRwR34idTV/QKicbKSnDlhtQAAAABJRU5ErkJggg== + + f06ff478-ea89-476f-9708-508681fea589 + true + false + true + DFDeconstructBeam + DFDeconstructBeam + 3 + + false + false + false + false + + + + + + 675 + 170 + 168 + 64 + + + 754 + 202 + + + + + + 1 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 3 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + 1 + true + The DFBeam objects to deconstruct. + f8157280-37dc-473b-96ef-0767369c6bd4 + 2 + i_beams + i_beams + true + 1 + 1 + true + a6abedea-c082-42b6-afd8-8f07edec21a5 + 1 + The DFBeam objects to deconstruct. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 677 + 172 + 62 + 60 + + + 717.5 + 202 + + + + + + + + false + The side faces of as Breps of the beam. + 3212063a-9455-4e0d-9d9a-e22a4bafda0c + o_side_faces + o_side_faces + false + 0 + 1 + true + 0 + The side faces of as Breps of the beam. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 769 + 172 + 72 + 20 + + + 805 + 182 + + + + + + + + false + The faces as Breps belonging to joints of the beam. + c85939e6-bd31-49b6-8051-7f4e388b84eb + o_joint_faces + o_joint_faces + false + 0 + 1 + true + 0 + The faces as Breps belonging to joints of the beam. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 769 + 192 + 72 + 20 + + + 805 + 202 + + + + + + + + false + An integer indicating to which joint the joint faces are belonging to. + 0dc0a83b-9dd1-46f8-9764-98720c7595d9 + o_joint_ids + o_joint_ids + false + 0 + 1 + true + 0 + An integer indicating to which joint the joint faces are belonging to. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 769 + 212 + 72 + 20 + + + 805 + 222 + + + + + + + + + + true + false + true + IyEgcHl0aG9uMwoKaW1wb3J0IFN5c3RlbQppbXBvcnQgdHlwaW5nCgppbXBvcnQgUmhpbm8KaW1wb3J0IFJoaW5vLkdlb21ldHJ5IGFzIHJnCmltcG9ydCBzY3JpcHRjb250ZXh0IGFzIHNjCgpmcm9tIGdocHl0aG9ubGliLmNvbXBvbmVudGJhc2UgaW1wb3J0IGV4ZWN1dGluZ2NvbXBvbmVudCBhcyBjb21wb25lbnQKCmltcG9ydCBkaWZmQ2hlY2sKZnJvbSBkaWZmQ2hlY2suZGZfZ2VvbWV0cmllcyBpbXBvcnQgREZCZWFtLCBERkFzc2VtYmx5CgoKY2xhc3MgREZEZWNvbnN0cnVjdEJlYW0oY29tcG9uZW50KToKICAgIGRlZiBSdW5TY3JpcHQoc2VsZiwgaV9iZWFtczogU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuTGlzdFtvYmplY3RdKToKICAgICAgICAiIiIKICAgICAgICAgICAgRGVjb25zdHJ1Y3QgdGhlIERGQmVhbSBvYmplY3QgaW50byBSaGlubyBvYmplY3RzLgogICAgICAgICAgICAKICAgICAgICAgICAgOnBhcmFtIGlfYmVhbXM6IHRoZSBERkJlYW0gb2JqZWN0cwoKICAgICAgICAgICAgOnJldHVybiBvX3NpZGVfZmFjZXM6IHRoZSBzaWRlIGpvaW50cyBvZiB0aGUgYmVhbQogICAgICAgICAgICA6cmV0dXJuIG9fam9pbnRfZmFjZXM6IHRoZSBmYWNlIGpvaW50cyBvZiB0aGUgYmVhbQogICAgICAgICAgICA6cmV0dXJuIG9fam9pbnRfaWRzOiB0aGUgaWRzIGZvciBlYWNoIGZhY2Ugam9pbnQKICAgICAgICAiIiIKICAgICAgICBvX3NpZGVfZmFjZXMsIG9fam9pbnRfZmFjZXMsIG9fam9pbnRfaWRzLCBvX2JyZXBzID0gW10sIFtdLCBbXSwgW10KCiAgICAgICAgZm9yIGlfYiBpbiBpX2JlYW1zOgogICAgICAgICAgICBvX3NpZGVfZmFjZXMgPSBbZi50b19icmVwX2ZhY2UoKSBmb3IgZiBpbiBpX2Iuc2lkZV9mYWNlc10KICAgICAgICAgICAgb19qb2ludF9mYWNlcyA9IFtmLnRvX2JyZXBfZmFjZSgpIGZvciBmIGluIGlfYi5qb2ludF9mYWNlc10KICAgICAgICAgICAgb19qb2ludF9pZHMgPSBbZi5qb2ludF9pZCBmb3IgZiBpbiBpX2Iuam9pbnRfZmFjZXNdCgogICAgICAgIHJldHVybiBvX3NpZGVfZmFjZXMsIG9fam9pbnRfZmFjZXMsIG9fam9pbnRfaWRzCgojIGlmIF9fbmFtZV9fID09ICJfX21haW5fXyI6CiMgICAgIGNvbXAgPSBERkRlY29uc3RydWN0QmVhbSgpCiMgICAgIG9fc2lkZV9mYWNlcywgb19qb2ludF9mYWNlcywgb19qb2ludF9pZHMgPSBjb21wLlJ1blNjcmlwdCgKIyAgICAgICAgIGlfYmVhbXMKIyAgICAgKQo= + S + + + + + *.*.python + 3.* + + + + + + + + + + + c552a431-af5b-46a9-a8a4-0fcbc27ef596 + Group + + + + + 1 + + 0;184;184;184 + + A group of Grasshopper objects + 2f1524fc-5545-413b-8873-d185930a521c + 1 + 1cc2238e-cff7-498b-8a91-cc9778370f4b + Group + build assembly + + + + + + + + + + c552a431-af5b-46a9-a8a4-0fcbc27ef596 + Group + + + + + 1 + + 0;184;184;184 + + A group of Grasshopper objects + 34994163-7d3f-43dc-8734-4b022f2cf4eb + 1 + 824cc45d-ad3b-4e8c-8639-8c54d226dffa + Group + deconstruct assembly + + + + + + + + + + c552a431-af5b-46a9-a8a4-0fcbc27ef596 + Group + + + + + 1 + + 0;184;184;184 + + A group of Grasshopper objects + f06ff478-ea89-476f-9708-508681fea589 + 1 + 0ea6c39d-7df9-4244-9db2-fd0095a99002 + Group + deconstruct beam + + + + + + + + + + 57da07bd-ecab-415d-9d86-af36d7073abc + Number Slider + + + + + Numeric slider for single values + 2ef2efba-b4fd-4973-bc31-6075179631f1 + Number Slider + + false + 0 + + + + + + 41 + 111 + 160 + 20 + + + 41.440613 + 111.44061 + + + + + + 3 + 1 + 1 + 1000 + 0 + 0 + 46 + + + + + + + + + 850b6368-ff26-48ce-9773-ac554ffbaeef + Point Cloud + + + + + Contains a collection of point clouds + 3d693f2c-415c-44e7-b582-24f20c9d4d31 + Point Cloud + PCloud + false + 0 + + + + + + 32 + 17 + 50 + 24 + + + 57.794453 + 29.396591 + + + + + + 1 + + + + + 1 + {0} + + + + + + 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 + + 00000000-0000-0000-0000-000000000000 + + + + + + + + + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + DFCloudSizeDownsample + + + + + + true + 2 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABgmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkU0oRFEcxX9miDRIZiFZvMWwooRkqSFS1DQzytfCe2/MUPOe6b2RjaWyVRY+NgYLG2u2FrZKKR8lawsrYiM9//tGzaRGuXW7v86953TvuRAoZE3Lre4By8478bGoNj0zq9U+U0MLzTTSr5tubjIxmqTi+LilSq033SqL/42G1KJrQpUmPGTmnLzwgvDAWj6neFc4bC7pKeFT4S5HLih8r3SjyC+KMz4HVGbYScaHhcPCWqaMjTI2lxxLuF84krJsyQ9MFzmleF2xlV01f+6pXhhatKcSSpfZzhjjTBJDw2CVZbLk6ZbVFsUlLvvRCv423x8TlyGuZUxxjLCChe77UX/wu1s33ddbTApFoebJ8946oHYbvrY87/PQ876OIPgIF3bJv1KAwXfRt0pa5ACaNuDssqQZO3C+Ca0POd3RfSkoM5BOw+uJfNMMtFxD/Vyxt599ju8gKV1NXMHePnRmJHu+wrvrynv784zfH9Fvn4VyuVUPcboAAAAJcEhZcwAACw8AAAsPAZL5A6UAAAAHdElNRQfoBRMVIA1NV33KAAACvUlEQVRIS+2UXUhTYRjHj4FWUiqtWpGhobHMwjQiJLIgi7oYSBJ0EeVFFEaQIVgRhdDoIvqAoLroIjBBglJriKw19+lHm3nML3JgK7PGbO7M0ZTN7fx73nnOMLIv6abwDz/Oed/zPP/n2XPOXm5e/7Zsm01biN3S8u+JTEsIFwEJgaiWHs9NZMC6ZZTY8kwwqG0wF1nkAjK3pPDfFyUx03i3LQdsuFLnQqllFMf1blReN6BW3TizSKaU+mtRcBohGPdaUXO1F3fuvsGxhkFk8H4s7PNDOTSO3HY3qm4aZhYok9J/LArKJB4QvHWbGZcev0dBpw/ZXX4kfRTA9QfAjQSREI4iq0vA6Xon2NikAuzXGokKyW5atMFMM1tynw+Zd1oCusNteKjpQcaLAag+kKnzC7jX4+DCU1CIwEoiPSIiZdCPfMcYDureoe5yN6z58UKMkpi5PbftROfGDjB0R1/inNaDfa1jyO4JIiUsQglgHZE0Bayi6zIiMRKBKhoF92k0VngJ70NV4zDMu7558Q3csw31JnnDuMOM8qcupPDUcaxbMpiYQJYoYgUzJYqIZCKVWEMsZTEUu5bey6wFmnO08S/EuMeCU03DUNBcOWcAqVMiFriDUNIo0qMEGWYQq9mVRqSkwouFENI7P6NYP4RHF/nvR2TaZGiXN9rzbLihsaDQ6sLWVwJUk1Es6g9ShwEkUJcKKsSFwkiaFJHoCYELhlDg8OFC7QAMhUbZVH7J018T3awnGolYgCO/A/Un9XhSyeN2zTDUrV4U2X3Y3+bF8m4/kp0Ctts9OGL2oLjPi7JmF9Tnr8nmjNmPDvaAqO5V8VE5uCvHHk/UlttxpmkEh5rf4v7ZeLexzjWl9+Q1L9n9XBRYQbDzRU6cee7I8AQbhbxuINIkiz8TSyTYH48VZbD7uZnN638Tx30F9nmE/1mgmekAAAAASUVORK5CYII= + + 79c769c4-85e3-4182-bad5-555fe7d7f97d + true + false + true + DFCloudSizeDownsample + SizeDown + 3 + + false + false + false + false + + + + + + 274 + 48 + 123 + 44 + + + 332 + 70 + + + + + + 2 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 1 + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + The point cloud to reduce the size. + 7e543d95-4317-4a5e-a777-82fe55c12c29 + i_cloud + i_cloud + true + 0 + 1 + true + 4cff25d3-f728-4cb0-a6a9-9cc5a317d323 + 1 + The point cloud to reduce the size. + d73c9fb0-365d-458f-9fb5-f4141399311f + + + + + + 276 + 50 + 41 + 20 + + + 298 + 60 + + + + + + + + true + The size of the wished downsampled cloud. + 20037f9e-e58a-4685-bd53-c988e722d40f + i_size + i_size + true + 0 + 1 + true + 2ef2efba-b4fd-4973-bc31-6075179631f1 + 1 + The size of the wished downsampled cloud. + 48d01794-d3d8-4aef-990e-127168822244 + + + + + + 276 + 70 + 41 + 20 + + + 298 + 80 + + + + + + + + false + The downsampled cloud. + bd58b089-8ae7-48e6-9aec-236ae2d4da13 + o_cloud + o_cloud + false + 0 + 1 + true + 0 + The downsampled cloud. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 347 + 50 + 48 + 40 + + + 371 + 70 + + + + + + + + + + true + false + true + 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 + S + + + + + *.*.python + 3.* + + + + + + + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + script-sync cpython + + + + + + true + 2 + + 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 + + bce95668-a73d-4866-8978-ed68a47ddbd2 + true + false + true + script-sync cpython + scsy-cpy + 3 + + false + false + false + false + + + + + + 278 + -127 + 180 + 84 + + + 393 + -85 + + + + + + 4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 2 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + Connect a button to open a file dialog to select a cpython file to run. + e775cc7d-a2d8-47df-b1da-7e9a38e12648 + select_file + select_file + true + 0 + 1 + true + 59397dc8-81fb-490b-8716-fa219dd9dfc4 + 1 + Connect a button to open a file dialog to select a cpython file to run. + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 280 + -125 + 98 + 20 + + + 330.5 + -115 + + + + + + + + 1 + true + Pass a list with the name of the custom packages you want to reload. This function is useful if you are developing a i.e. PyPI package and you want to reload the submodules after you modified something. The function will reload the package and all its submodules. If you want to reload the package and all its submodules, just pass the package name. If you want to reload only a submodule, pass the package name and the submodule name separated by a dot. If you want to reload multiple submodules, pass the package + 62d9cf4a-042f-47bc-89f7-8cbf98105353 + packages_2_reload + packages_2_reload + true + 1 + 1 + true + e3293690-c1bb-44ae-9138-1b7146d07fa5 + 1 + Pass a list with the name of the custom packages you want to reload. This function is useful if you are developing a i.e. PyPI package and you want to reload the submodules after you modified something. The function will reload the package and all its submodules. If you want to reload the package and all its submodules, just pass the package name. If you want to reload only a submodule, pass the package name and the submodule name separated by a dot. If you want to reload multiple submodules, pass the package + 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + + + + + + 280 + -105 + 98 + 20 + + + 330.5 + -95 + + + + + + + + true + A generic x input. + d8663554-7e0f-4770-8795-06372c27dce3 + i_cloud + i_cloud + true + 0 + 1 + true + 3d693f2c-415c-44e7-b582-24f20c9d4d31 + 1 + A generic x input. + d73c9fb0-365d-458f-9fb5-f4141399311f + + + + + + 280 + -85 + 98 + 20 + + + 330.5 + -75 + + + + + + + + true + Converts to collection of integer numbers + 3fe0fab9-6cf4-40c3-9a63-0c2983b83ef2 + i_size + i_size + true + 0 + 1 + true + 2ef2efba-b4fd-4973-bc31-6075179631f1 + 1 + + 48d01794-d3d8-4aef-990e-127168822244 + + + + + + 280 + -65 + 98 + 20 + + + 330.5 + -55 + + + + + + + + false + The redirected standard output of the component scriptsync. + 984d7ee5-75fd-4b85-b53c-6520521efb4d + stdout + stdout + false + 0 + 1 + true + 0 + The redirected standard output of the component scriptsync. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 408 + -125 + 48 + 40 + + + 432 + -105 + + + + + + + + false + Generic example output of the component + 7dbb50f6-5b11-45c2-aac3-e34efc2847a3 + o_cloud + o_cloud + false + 0 + 1 + true + 0 + Generic example output of the component + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 408 + -85 + 48 + 40 + + + 432 + -65 + + + + + + + + + + true + false + true + from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import Rhino
import rhinoscriptsyntax as rs
import Grasshopper
import Grasshopper as gh
from Grasshopper.Kernel import GH_RuntimeMessageLevel as RML
import sys
import os
import time

import contextlib
import io

import abc
import socket
import threading
import queue
import json

import importlib
import sys

import traceback


class GHThread(threading.Thread, metaclass=abc.ABCMeta):
    """
        A base class for Grasshopper threads.
    """
    def __init__(self, name : str):
        super().__init__(name=name, daemon=False)
        self._component_on_canvas = True
        self._component_enabled = True

    @abc.abstractmethod
    def run(self):
        """ Run the thread. """
        pass

    def _check_if_component_on_canvas(self):
        """ Check if the component is on canvas from thread. """
        def __check_if_component_on_canvas():
            if ghenv.Component.OnPingDocument() is None:
                self._component_on_canvas = False
                return False
            else:
                self._component_on_canvas = True
                return True
        action = System.Action(__check_if_component_on_canvas)
        Rhino.RhinoApp.InvokeOnUiThread(action)

    def _check_if_component_enabled(self):
        """ Check if the component is enabled from thread. """
        def __check_if_component_enabled():
            if ghenv.Component.Locked:
                self._component_enabled = False
            else:
                self._component_enabled = True
        action = System.Action(__check_if_component_enabled)
        Rhino.RhinoApp.InvokeOnUiThread(action)

    def expire_component_solution(self):
        """ Fire the recalculation of the component solution from thread. """
        def __expire_component_solution():
            ghenv.Component.Params.Output[0].ClearData()  # clear the output
            ghenv.Component.ExpireSolution(True)  # expire the component
        action = System.Action(__expire_component_solution)
        Rhino.RhinoApp.InvokeOnUiThread(action)

    def clear_component(self):
        """ Clear the component from thread. """
        def __clear_component():
            ghenv.Component.ClearData()
        action = System.Action(__clear_component)
        Rhino.RhinoApp.InvokeOnUiThread(action)

    def add_runtime_warning(self, exception : str):
        """ Add a warning tab to the component from main thread. """
        action = System.Action(
            lambda: ghenv.Component.AddRuntimeMessage(RML.Warning, exception)
        )
        Rhino.RhinoApp.InvokeOnUiThread(action)

    def add_runtime_error(self, exception : str):
        """ Add an error tab to the component from main thread. """
        action = System.Action(
            lambda: ghenv.Component.AddRuntimeMessage(RML.Error, exception)
        )
        Rhino.RhinoApp.InvokeOnUiThread(action)

    def add_runtime_remark(self, exception : str):
        """ Add a blank tab to the component from main thread. """
        action = System.Action(
            lambda: ghenv.Component.AddRuntimeMessage(RML.Remark, exception)
        )
        Rhino.RhinoApp.InvokeOnUiThread(action)

    @property
    def component_enabled(self):
        self._check_if_component_enabled()
        return self._component_enabled

    @property
    def component_on_canvas(self):
        self._check_if_component_on_canvas()
        return self._component_on_canvas

class ClientThread(GHThread):
    """
    A thread to connect to the VSCode server.
    """
    def __init__(self, vscode_server_ip: str, vscode_server_port: int, name: str,
                 queue_msg: queue.Queue = None, lock_queue_msg: threading.Lock = None,
                 event_fire_msg: threading.Event = None):
        super().__init__(name=name)
        self.vscode_server_ip = vscode_server_ip
        self.vscode_server_port = vscode_server_port
        self.is_connected = False
        self.connect_refresh_rate = 1  # seconds
        self.queue_msg = queue_msg
        self.lock_queue_msg = lock_queue_msg
        self.event_fire_msg = event_fire_msg
        self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    def run(self):
        """ Run the thread. Send the message to the vscode server."""
        while self.component_on_canvas and self.component_enabled:
            try:
                if not self.is_connected:
                    self.connect_to_vscode_server()
                    self.clear_component()
                    self.expire_component_solution()
                    continue

                self.event_fire_msg.wait()
                self.send_message_from_queue()

            except Exception as e:
                self.add_runtime_warning(f"script-sync::Unkown error from run: {str(e)}")
                self.is_connected = False
                self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        self.client_socket.close()

    def send_message_from_queue(self):
        with self.lock_queue_msg:
            if self.queue_msg and not self.queue_msg.empty():
                msg = self.queue_msg.get()
                self.queue_msg.task_done()
                self.event_fire_msg.set()
                self.event_fire_msg.clear()
                self.client_socket.send(msg)

    def connect_to_vscode_server(self):
        """ Connect to the VSCode server. """
        while self.component_on_canvas and not self.is_connected:
            try:
                self.client_socket.send(b"")
                self.is_connected = True
            except socket.error:
                try:
                    self.client_socket.connect((self.vscode_server_ip, self.vscode_server_port))
                    self.is_connected = True
                except (ConnectionRefusedError, ConnectionResetError, socket.error) as e:
                    self.handle_connection_error(e)
            finally:
                time.sleep(self.connect_refresh_rate)

    def handle_connection_error(self, e):
        error_messages = {
            ConnectionRefusedError: "script-sync::Connection refused by the vscode",
            ConnectionResetError: "script-sync::Connection was forcibly closed by the vscode",
            socket.error: f"script-sync::Error connecting to the vscode: {str(e)}, have you tried to press Shift+F4 on VSCode?"
        }
        self.add_runtime_warning(error_messages[type(e)])
        self.is_connected = False if type(e) != socket.error or e.winerror != 10056 else True

class FileChangedThread(GHThread):
    """
        A thread to check if the file has changed on disk.
    """
    def __init__(self,
                path : str,
                name : str
                ):
        super().__init__(name=name)
        self.path = path
        self.refresh_rate = 1000  # milliseconds
        self._on_file_changed = threading.Event()

    def run(self):
        """
            Check if the file has changed on disk.
        """
        last_modified = os.path.getmtime(self.path)
        while self.component_on_canvas and not self._on_file_changed.is_set():
            System.Threading.Thread.Sleep(self.refresh_rate)
            last_modified = self.is_file_modified(last_modified)
        self._on_file_changed.clear()
        return

    def stop(self):
        """ Stop the thread. """
        self._on_file_changed.set()

    def is_file_modified(self, last_modified):
        current_modified = os.path.getmtime(self.path)
        if current_modified != last_modified:
            self.expire_component_solution()
            return current_modified
        return last_modified

class ScriptSyncCPy(component):
    def __init__(self):
        super(ScriptSyncCPy, self).__init__()
        self._var_output = []

        self.is_success = False

        self.client_thread_name : str = f"script-sync-client-thread::{ghenv.Component.InstanceGuid}"
        self.vscode_server_ip = "127.0.0.1"
        self.vscode_server_port = 58260
        self.stdout = None
        self.queue_msg = queue.Queue()
        self.queue_msg_lock = threading.Lock()
        self.event_fire_msg = threading.Event()

        self.filechanged_thread_name : str = f"script-sync-fileChanged-thread::{ghenv.Component.InstanceGuid}"
        self.__path_name_table_value = "script-sync::" + "path::" + str(ghenv.Component.InstanceGuid)
        if self.path is None:
            ghenv.Component.Message = "select-script"

    def RemovedFromDocument(self, doc):
        """ Remove the component from the document. """
        if self.client_thread_name in [t.name for t in threading.enumerate()]:
            client_thread = [t for t in threading.enumerate() if t.name == self.client_thread_name][0]
            client_thread.join()
        if self.filechanged_thread_name in [t.name for t in threading.enumerate()]:
            filechanged_thread = [t for t in threading.enumerate() if t.name == self.filechanged_thread_name][0]
            filechanged_thread.join()
        if self.queue_msg is not None:
            self.queue_msg.join()
        if self.queue_msg_lock is not None:
            self.queue_msg_lock.release()
        if self.event_fire_msg is not None:
            self.event_fire_msg.clear()

        # clear the path from the table view
        del self.path

    def init_script_path(self, select_file : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param select_file: A boolean of the button
        """
        # check if button is pressed
        if select_file is True:
            filename = rs.OpenFileName("Open", "Python Files (*.py)|*.py||")
            if filename is None:
                raise Exception("script-sync::No file selected")
            self.path = filename

        # fi file is in table view before
        if not os.path.exists(self.path):
            raise Exception("script-sync::File does not exist")
    
    def reload_all_modules(self, directory):
        for filename in os.listdir(directory):
            if filename.endswith('.py') and filename != '__init__.py':
                module_name = filename[:-3]  # remove '.py' from filename
                if module_name in sys.modules:
                    importlib.reload(sys.modules[module_name])

    def safe_exec(self, path, globals, locals, packages_2_reload):
        """
            Execute Python3 code safely. It redirects the output of the code
            to a string buffer 'stdout' to output to the GH component param.
            It is send to the vscode server.
            
            :param path: The path of the file to execute.
            :param globals: The globals dictionary.
            :param locals: The locals dictionary.
            :param packages_2_reload: The list of packages to reload, this is used for custom packages developement.
            installed on the system via an editable pip installation for example.
        """
        try:
            with open(path, 'r') as f:
                # reload the specifyed packages
                if packages_2_reload is not None:
                    if packages_2_reload.__len__() != 0:
                        for package in packages_2_reload:
                            for key in list(sys.modules.keys()):
                                if package in key:
                                    #check that the package must have the attribute __file__ (to avoid reloading pyd)
                                    if hasattr(sys.modules[key], '__file__'):
                                        importlib.reload(sys.modules[key])

                # add the path and sub directories to  the sys path
                path_dir = os.path.dirname(path)
                sub_dirs = []
                for root, dirs, files in os.walk(path_dir):
                    for d in dirs:
                        sub_dirs.append(os.path.join(root, d))
                sys.path.extend([path_dir] + sub_dirs)

                # reload all the modules also of the sub directories
                for root, dirs, files in os.walk(path_dir):
                    for d in dirs:
                        self.reload_all_modules(os.path.join(root, d))
                self.reload_all_modules(path_dir)

                # refresh the python interpreter
                importlib.invalidate_caches()

                # parse the code
                code = compile(f.read(), path, 'exec')
                output = io.StringIO()

                # empty the queue and event
                with self.queue_msg_lock:
                    while not self.queue_msg.empty():
                        self.queue_msg.get()
                        self.queue_msg.task_done()
                self.event_fire_msg.clear()

                # clear all the locals dictionary to avoid that the output variables stick between the component
                # executions when it is recomputed
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                for outp in outparam_names:
                    if outp in locals.keys():
                        del locals[outp]

                # execute the code
                with contextlib.redirect_stdout(output):
                    exec(code, globals, locals)
                locals["stdout"] = output.getvalue()

                # send the msg to the vscode server
                msg_json = json.dumps({"script_path": path,
                                       "guid": str(ghenv.Component.InstanceGuid),
                                       "msg": output.getvalue()})
                msg_json = msg_json.encode('utf-8')
                self.queue_msg.put(msg_json)
                self.event_fire_msg.set()

                # pass the script variables to the GH component outputs
                for outp in outparam_names:
                    if outp in locals.keys():
                        self._var_output.append(locals[outp])
                    else:
                        self._var_output.append(None)

                sys.stdout = sys.__stdout__
            return locals

        except Exception as e:
            # Get the traceback
            tb = traceback.format_exc()

            # Send the error message to the vscode server
            err_json = json.dumps({
                "script_path": path,
                "guid": str(ghenv.Component.InstanceGuid),
                "msg": "err:" + str(e),
                "traceback": tb  # Include the traceback in the JSON
            })
            err_json = err_json.encode('utf-8')
            self.queue_msg.put(err_json)
            self.event_fire_msg.set()

            sys.stdout = sys.__stdout__

            err_msg = f"script-sync::Error in the code: {str(e)}\n{tb}"
            raise Exception(err_msg)

    def RunScript(self,
            select_file: bool,
            packages_2_reload: System.Collections.Generic.List[str],
            i_cloud: Rhino.Geometry.PointCloud,
            i_size: int):
        """ This method is called whenever the component has to be recalculated it's the solve main instance. """
        self.is_success = False

        # set the path if button is pressed
        self.init_script_path(select_file)

        # file change listener thread
        if self.filechanged_thread_name not in [t.name for t in threading.enumerate()]:
            FileChangedThread(self.path,
                              self.filechanged_thread_name
                              ).start()

        # set up the tcp client to connect to the vscode server
        _ = [print(t.name) for t in threading.enumerate()]
        if self.client_thread_name not in [t.name for t in threading.enumerate()]:
            ClientThread(self.vscode_server_ip,
                        self.vscode_server_port,
                        self.client_thread_name,
                        self.queue_msg,
                        self.queue_msg_lock,
                        self.event_fire_msg
                        ).start()

        # add to the globals all the input parameters of the component (the locals)
        globals().update(locals())

        res = self.safe_exec(self.path, None, globals(), packages_2_reload)
        self.is_success = True
        return

    def is_nested_iterable(self, lst):
        """ Detect if a list is nested. """
        return any(isinstance(i, list) for i in lst)

    def AfterRunScript(self):
        """
            This method is called as soon as the component has finished
            its calculation. It is used to load the GHComponent outputs
            with the values created in the script.
        """
        if not self.is_success:
            return

        outparam = [p for p in ghenv.Component.Params.Output]
        outparam_names = [p.NickName for p in outparam]

        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == tuple:
                ghenv.Component.Params.Output[idx].VolatileData.Clear()
                ghenv.Component.Params.Output[idx].AddVolatileDataList(gh.Kernel.Data.GH_Path(0), self._var_output[idx])
            # TODO: increase the number of nested lists they can be handles (max 2 deep for now)
            elif type(self._var_output[idx]) == list:
                ghenv.Component.Params.Output[idx].VolatileData.Clear()
                if self.is_nested_iterable(self._var_output[idx]):
                    nbr_lists_aka_branches = len(self._var_output[idx])
                    for i in range(nbr_lists_aka_branches):
                        ghenv.Component.Params.Output[idx].AddVolatileDataList(gh.Kernel.Data.GH_Path(i), self._var_output[idx][i])
                else:
                    ghenv.Component.Params.Output[idx].AddVolatileDataList(gh.Kernel.Data.GH_Path(0), self._var_output[idx])
            else:
                ghenv.Component.Params.Output[idx].VolatileData.Clear()
                ghenv.Component.Params.Output[idx].AddVolatileData(gh.Kernel.Data.GH_Path(0), 0, self._var_output[idx])
        self._var_output.clear()

    @property
    def path(self):
        """ Get the path of the file from the table view to be sticking between the sessions. """
        table_value = ghenv.Component.OnPingDocument().ValueTable.GetValue(
            self.__path_name_table_value, "not_found"
        )
        if table_value != "not_found":
            return table_value
        else:
            return None

    @path.setter
    def path(self, path : str):
        """ Set the path of the file to the table view to be sticking between the sessions. """
        ghenv.Component.OnPingDocument().ValueTable.SetValue(self.__path_name_table_value, path)

        script_name = os.path.basename(path)
        ghenv.Component.Message = f"{script_name}"

        if self.filechanged_thread_name in [t.name for t in threading.enumerate()]:
            _ = [t for t in threading.enumerate() if t.name == self.filechanged_thread_name][0].stop()

    @path.deleter
    def path(self):
        """ Delete the path of the file from the table view if the object is erased. """
        ghenv.Component.OnPingDocument().ValueTable.DeleteValue(self.__path_name_table_value)
 + S + + + + + *.*.python + 3.* + + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + e3293690-c1bb-44ae-9138-1b7146d07fa5 + Panel + + false + 0 + 0 + diffCheck + + + + + + 120 + -56 + 111 + 39 + + 0 + 0 + 0 + + 120.27092 + -55.224453 + + + + + + + 255;213;217;232 + + true + true + false + false + false + true + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 59397dc8-81fb-490b-8716-fa219dd9dfc4 + Button + Button + false + 0 + + + + + + 135 + -126 + 103 + 22 + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + 5c955df9-7a70-4741-89da-b5741eb92c4c + Panel + + false + 0 + 7dbb50f6-5b11-45c2-aac3-e34efc2847a3 + 1 + Double click to edit panel content… + + + + + + 534 + -142 + 281 + 123 + + 0 + 0 + 0 + + 534.5448 + -141.49593 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + 6a1dbff5-37ef-4410-ad8d-5c11b7d61f20 + Panel + + false + 0 + bd58b089-8ae7-48e6-9aec-236ae2d4da13 + 1 + Double click to edit panel content… + + + + + + 468 + 3 + 281 + 123 + + 0 + 0 + 0 + + 468.66248 + 3.602066 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 850b6368-ff26-48ce-9773-ac554ffbaeef + Point Cloud + + + + + Contains a collection of point clouds + a50d769f-20e2-4996-b784-96b8dc97a209 + Point Cloud + PCloud + false + 0 + + + + + + 33 + 51 + 50 + 24 + + + 58.635742 + 63.76397 + + + + + + 1 + + + + + 1 + {0} + + + + + + 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 + + 00000000-0000-0000-0000-000000000000 + + + + + + + + + + + + + c9785b8e-2f30-4f90-8ee3-cca710f82402 + Entwine + + + + + Flatten and combine a collection of data streams + true + 74c3886d-6ac5-4600-9047-bedae3096d2f + Entwine + Entwine + + + + + + 126 + 26 + 79 + 44 + + + 171 + 48 + + + + + + 2 + 8ec86459-bf01-4409-baee-174d0d2b13d0 + 8ec86459-bf01-4409-baee-174d0d2b13d0 + 1 + 8ec86459-bf01-4409-baee-174d0d2b13d0 + + + + + 2 + Data to entwine + b81a4133-5a12-43df-ac6d-33a155ae1e18 + false + Branch {0;0} + {0;0} + true + 3d693f2c-415c-44e7-b582-24f20c9d4d31 + 1 + + + + + + 128 + 28 + 28 + 20 + + + 143.5 + 38 + + + + + + + + 2 + Data to entwine + e610645b-0940-461b-82d1-6d718767df0e + false + Branch {0;1} + {0;1} + true + a50d769f-20e2-4996-b784-96b8dc97a209 + 1 + + + + + + 128 + 48 + 28 + 20 + + + 143.5 + 58 + + + + + + + + Entwined result + 4cff25d3-f728-4cb0-a6a9-9cc5a317d323 + Result + R + false + 0 + + + + + + 186 + 28 + 17 + 40 + + + 194.5 + 48 + + + + + + + + + + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + DFCloudUniformDownsample + + + + + + true + 2 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABgmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkU0oRFEcxX9miDRIZiFZvMWwooRkqSFS1DQzytfCe2/MUPOe6b2RjaWyVRY+NgYLG2u2FrZKKR8lawsrYiM9//tGzaRGuXW7v86953TvuRAoZE3Lre4By8478bGoNj0zq9U+U0MLzTTSr5tubjIxmqTi+LilSq033SqL/42G1KJrQpUmPGTmnLzwgvDAWj6neFc4bC7pKeFT4S5HLih8r3SjyC+KMz4HVGbYScaHhcPCWqaMjTI2lxxLuF84krJsyQ9MFzmleF2xlV01f+6pXhhatKcSSpfZzhjjTBJDw2CVZbLk6ZbVFsUlLvvRCv423x8TlyGuZUxxjLCChe77UX/wu1s33ddbTApFoebJ8946oHYbvrY87/PQ876OIPgIF3bJv1KAwXfRt0pa5ACaNuDssqQZO3C+Ca0POd3RfSkoM5BOw+uJfNMMtFxD/Vyxt599ju8gKV1NXMHePnRmJHu+wrvrynv784zfH9Fvn4VyuVUPcboAAAAJcEhZcwAACxEAAAsRAX9kX5EAAAAHdElNRQfoBRMULx84tHp6AAACzUlEQVRIS+2UW0hUURiF56GXNC/ZMCp4GSd1nJmjzFRgUZqRSSmVSkgSUZAoWpAVSEaB4osRIeFDkIokldJFI29p2lyc1NIaQ7tIpj1kCKXjJN5Sz+rfM+eI0cWSXgoXfHDOPv9e6z97b7ZkWf+2zKEGLRElvP49kWk8MUBAwErkCJ+XJjJg3TKYOepUnahVPRUDRAqE8t8XTWKmA0bOBD33CDWqZzjlacNWJyDKiUfS2mFc3tGyMEQuTF1cVOxOWFmnZ71HcFw2hv3+Y0hZM4Fk92mkrQB2OgO7g8dh4MxiwGFh+s/FuiBKTZyp64GmHXEus9jn9gVnKKRC8Rb6MCMadEZUy0dwQApEugC3gnsoxP4nbG/0RKZg55BgKm/WNPXrOfNYmeIN8n2HEKmy4aJ0HJXKblwL7EVGyDBSvaZQtMeEGs1z5MrHsWUlEEdjWV6jaFQ/Fv+EEW83f6JpTe1Ut4NxRfEOR2STiPbgcZ46vKN8iau6PpwI/4gUH6BAzuNCAJDMfUatthUtXKt9yVgIo8BvcGFAleReSKVBHMiVDc4XnvT8BBON3QyzYLsbj2wvoEwFFGqBc8EUoLWhTtdOG79IQL2qev48n5aO2os2E+mrp3Bf3YOmTWaUb+tAvmoIKRob0jdYkRf+AcV7G1Ad+gKFCscSxfhNItvb+v0SGbjmNnGgQdmFQwGOkAgP4KgfjwzZBEoUAygP6sXD0DY0r2tBhboPxdxrlKknkUa1ka48bq+3wPjtJjtOEz0EEXcJe0ibtgMlsRZk+VhxkE7ORjqGEWQS7cwjwXUGx1xmECudQzw9J6wCknxnERPVI3bM+PHVwT4QOd1Ky5xY3Bj4Ctepc3Z6Lvm/RyKZ7pJNIyesnzbfcapu6LqRl1gkmlsEu1+LCjMJdr+IExfeOyIWgi2F+F5FuAsWfyY2kSglWCiDPS/NbFn/mySSr9EnUHrbvz9AAAAAAElFTkSuQmCC + + fe90b455-ad93-4331-ac9c-438054fdb739 + true + false + true + DFCloudUniformDownsample + UniformDown + 3 + + false + false + false + false + + + + + + 283 + -229 + 167 + 44 + + + 385 + -207 + + + + + + 2 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 1 + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + The point cloud to reduce the size. + 8c241412-8944-4c5d-842d-6c79b9edc8b5 + i_cloud + i_cloud + true + 0 + 1 + true + 4cff25d3-f728-4cb0-a6a9-9cc5a317d323 + 1 + The point cloud to reduce the size. + d73c9fb0-365d-458f-9fb5-f4141399311f + + + + + + 285 + -227 + 85 + 20 + + + 329 + -217 + + + + + + + + true + Every k value points will be deleted. + b14d21d4-a924-4c6d-b1b5-d657877b0cbf + i_every_k_points + i_every_k_points + true + 0 + 1 + true + 2ef2efba-b4fd-4973-bc31-6075179631f1 + 1 + Every k value points will be deleted. + 48d01794-d3d8-4aef-990e-127168822244 + + + + + + 285 + -207 + 85 + 20 + + + 329 + -197 + + + + + + + + false + The downsampled cloud. + ccc3240d-cabd-49e3-b991-d459e2534145 + o_cloud + o_cloud + false + 0 + 1 + true + 0 + The downsampled cloud. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 400 + -227 + 48 + 40 + + + 424 + -207 + + + + + + + + + + true + false + true + IyEgcHl0aG9uMwoKaW1wb3J0IFN5c3RlbQppbXBvcnQgdHlwaW5nCgppbXBvcnQgUmhpbm8KaW1wb3J0IFJoaW5vLkdlb21ldHJ5IGFzIHJnCmZyb20gZ2hweXRob25saWIuY29tcG9uZW50YmFzZSBpbXBvcnQgZXhlY3V0aW5nY29tcG9uZW50IGFzIGNvbXBvbmVudAoKaW1wb3J0IEdyYXNzaG9wcGVyIGFzIGdoCmZyb20gR3Jhc3Nob3BwZXIuS2VybmVsIGltcG9ydCBHSF9SdW50aW1lTWVzc2FnZUxldmVsIGFzIFJNTAoKaW1wb3J0IGRpZmZDaGVjawppbXBvcnQgZGlmZkNoZWNrLmRmX2dlb21ldHJpZXMKZnJvbSBkaWZmQ2hlY2sgaW1wb3J0IGRmX2N2dF9iaW5kaW5ncwoKY2xhc3MgREZDbG91ZFVuaWZvcm1Eb3duc2FtcGxlKGNvbXBvbmVudCk6CiAgICBkZWYgUnVuU2NyaXB0KHNlbGYsCiAgICAgICAgaV9jbG91ZDogcmcuUG9pbnRDbG91ZCwKICAgICAgICBpX2V2ZXJ5X2tfcG9pbnRzOiBpbnQsCiAgICApIC0+IHJnLlBvaW50Q2xvdWQ6CiAgICAgICAgIiIiCiAgICAgICAgICAgIERvd25zYW1wbGUgYSBwb2ludCBjbG91ZCB1c2luZyBpbiBhIHVuaWZvcm0gd2F5IGJ5IHNlbGVjdGluZyBldmVyeSBrIHBvaW50cyB0byBkZWxldGUuCgogICAgICAgICAgICA6cGFyYW0gaV9jbG91ZDogaW5wdXQgcG9pbnQgY2xvdWQKICAgICAgICAgICAgOnBhcmFtIGlfZXZlcnlfa19wb2ludHM6IG51bWJlciBvZiBldmVyeSBrIHBvaW50cyB0byBkZWxldGUKCiAgICAgICAgICAgIDpyZXR1cm4gb19jbG91ZDogZG93bnNhbXBsZWQgcG9pbnQgY2xvdWQKICAgICAgICAiIiIKICAgICAgICBkZl9jbG91ZCA9IGRmX2N2dF9iaW5kaW5ncy5jdnRfcmhjbG91ZF8yX2RmY2xvdWQoaV9jbG91ZCkKICAgICAgICBkZl9jbG91ZC51bmlmb3JtX2Rvd25zYW1wbGUoaV9ldmVyeV9rX3BvaW50cykKICAgICAgICBvX2Nsb3VkID0gZGZfY3Z0X2JpbmRpbmdzLmN2dF9kZmNsb3VkXzJfcmhjbG91ZChkZl9jbG91ZCkKCiAgICAgICAgcmV0dXJuIFtvX2Nsb3VkXQoKIyBpZiBfX25hbWVfXyA9PSAiX19tYWluX18iOgojICAgICBjb20gPSBERkNsb3VkVW5pZm9ybURvd25zYW1wbGUoKQojICAgICBvX2Nsb3VkID0gY29tLlJ1blNjcmlwdCgKIyAgICAgICAgIGlfY2xvdWQsCiMgICAgICAgICBpX2V2ZXJ5X2tfcG9pbnRzLAojICAgICAgICAgKQ== + S + + + + + *.*.python + 3.* + + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + 7e134d83-c33c-4f83-9e4b-4c998ec971d2 + Panel + + false + 0 + ccc3240d-cabd-49e3-b991-d459e2534145 + 1 + Double click to edit panel content… + + + + + + 529 + -280 + 281 + 123 + + 0 + 0 + 0 + + 529.8063 + -279.61618 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + FastGlobalRegistration + + + + + + true + 2 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABgmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkU0oRFEcxX9miDRIZiFZvMWwooRkqSFS1DQzytfCe2/MUPOe6b2RjaWyVRY+NgYLG2u2FrZKKR8lawsrYiM9//tGzaRGuXW7v86953TvuRAoZE3Lre4By8478bGoNj0zq9U+U0MLzTTSr5tubjIxmqTi+LilSq033SqL/42G1KJrQpUmPGTmnLzwgvDAWj6neFc4bC7pKeFT4S5HLih8r3SjyC+KMz4HVGbYScaHhcPCWqaMjTI2lxxLuF84krJsyQ9MFzmleF2xlV01f+6pXhhatKcSSpfZzhjjTBJDw2CVZbLk6ZbVFsUlLvvRCv423x8TlyGuZUxxjLCChe77UX/wu1s33ddbTApFoebJ8946oHYbvrY87/PQ876OIPgIF3bJv1KAwXfRt0pa5ACaNuDssqQZO3C+Ca0POd3RfSkoM5BOw+uJfNMMtFxD/Vyxt599ju8gKV1NXMHePnRmJHu+wrvrynv784zfH9Fvn4VyuVUPcboAAAAJcEhZcwAACxEAAAsRAX9kX5EAAAAHdElNRQfoBRMRHDBhxeD4AAACSElEQVRIS2MYBUMbLDJ6Fr7Q6HkBlEs9MN/oRXuHyc/fdab//4Nwi+mff7OM3hyASpMHjugeMDike8gQZDjMYHQ8w/jdOahy4gHIYCC+D8T/gRZgGBoR8v9/RiSCv8TwiQ1UK2EANFQAiN+DDIdZkBD2/3+lM8JA7+r//8MLEfx5Ri/nQLXjBkDDFIB4PhCfhxkOFAZbYJ76H8wGGVbq//9/Ttb//8mtCAtAcTPB5Mv7OUav14MNgwGooQr7tHfdBdKfYAbbZyf93+6yF24JyLCCWIglcZMghoIsAfkMZgkMg+ILbPgp7WNpZ7RO/AfhY7oH/5/SO/Z/Y8J+sKFzineA8aL0nf+3uewHG5xeDgkaGBtkkVUppgWTjT89Y9ikse4AzLUwPCl+4f+InHIwG2TwXsv9YEts20r+B+6CGAzyBSiIYGyQL7BasF1zMziFIOM5gcv+n9M4+b87aMb/0KW9/yfHrgBbsDBjD9hAUDA5VyB84Djt/3//PEwLwEF0QGfvcZjBJ7SP/F/qvup/Ufuk/4vcV/y/oHnm/zLDFf87a1b9d63KRQkSEDu8H+ILkBgsZcEiGZ6agAarAvEGmCWnDU/83xK+Dczep7wT7iuQgQuAPoC5HOZKkG+MkJIpzqIDaIgDEDdcVj//F2boOc1TcAtA+JDuYXBqyfFFGAhyeXAChN1j8u0b1Dj8AGhYARDDMxgQg+PpoO4RuMEgw0BBAeODInSp4WN5qBGkAaDhoBw9H2jBB1DBNtX4w22yDRsFww0wMAAAM5FY0OMLikIAAAAASUVORK5CYII= + + 15a7c537-9d6a-4fb2-b0c3-4691f6775732 + true + false + true + FastGlobalRegistration + FastGReg + 3 + + false + false + false + false + + + + + + 936 + -141 + 221 + 164 + + + 1086 + -59 + + + + + + 8 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 1 + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + Connect a button to recompute the registration. + fd1d5fbf-af64-47a4-bf6d-2ddd2f5d2207 + i_recompute + i_recompute + true + 0 + 1 + true + 70e3f280-d48d-4a26-8373-0eb52cb51d20 + 1 + Connect a button to recompute the registration. + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 938 + -139 + 133 + 20 + + + 1006 + -129 + + + + + + + + true + The source point cloud. + 3aefc1e5-4547-4590-973a-40a6fee84ea3 + i_cloud_source + i_cloud_source + true + 0 + 1 + true + a50d769f-20e2-4996-b784-96b8dc97a209 + 1 + The source point cloud. + d73c9fb0-365d-458f-9fb5-f4141399311f + + + + + + 938 + -119 + 133 + 20 + + + 1006 + -109 + + + + + + + + true + The target cloud. + ffa0ea7f-e5da-412f-bd40-3dabdbecd8d5 + i_cloud_target + i_cloud_target + true + 0 + 1 + true + 0 + The target cloud. + d73c9fb0-365d-458f-9fb5-f4141399311f + + + + + + 938 + -99 + 133 + 20 + + + 1006 + -89 + + + + + + + + true + The radius used to search for neighbors in the KDTree.it is expressed relative to the point cloud size (0.01 means radiusKDTreeSearch = 1% of maxSize(pointCloud). It is used for the calculation of FPFHFeatures. + 8558e29b-6ddd-4de4-935f-ce03f47a8be9 + i_radius_kd_search + i_radius_kd_search + true + 0 + 1 + true + 0 + The radius used to search for neighbors in the KDTree.it is expressed relative to the point cloud size (0.01 means radiusKDTreeSearch = 1% of maxSize(pointCloud). It is used for the calculation of FPFHFeatures. + 9d51e32e-c038-4352-9554-f4137ca91b9a + + + + + + 938 + -79 + 133 + 20 + + + 1006 + -69 + + + + + + + + true + The maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures. A higher value will result in heavier computation but potentially more precise. + 97decf41-bf27-4c80-bac5-8f9b0ea4f5f2 + i_neighbours_kd_search + i_neighbours_kd_search + true + 0 + 1 + true + 0 + The maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures. A higher value will result in heavier computation but potentially more precise. + 48d01794-d3d8-4aef-990e-127168822244 + + + + + + 938 + -59 + 133 + 20 + + + 1006 + -49 + + + + + + + + true + The maximum distance between correspondences. A higher value will result in more correspondences, but potentially include wrong ones. + 1e56f825-f7f7-493c-b4a4-3e5e18a85324 + i_max_corrspondence_dist + i_max_corrspondence_dist + true + 0 + 1 + true + 0 + The maximum distance between correspondences. A higher value will result in more correspondences, but potentially include wrong ones. + 9d51e32e-c038-4352-9554-f4137ca91b9a + + + + + + 938 + -39 + 133 + 20 + + + 1006 + -29 + + + + + + + + true + The number of iterations to run the RanSaC registration algorithm. A higher value will take more time to compute but increases the chances of finding a good transformation. As parameter of the FastGlobalRegistrationOption options. + fb9a8192-3f99-4dff-9067-46cde3eddae4 + i_iteration_number + i_iteration_number + true + 0 + 1 + true + 0 + The number of iterations to run the RanSaC registration algorithm. A higher value will take more time to compute but increases the chances of finding a good transformation. As parameter of the FastGlobalRegistrationOption options. + 48d01794-d3d8-4aef-990e-127168822244 + + + + + + 938 + -19 + 133 + 20 + + + 1006 + -9 + + + + + + + + true + The maximum number of tuples to consider in the FPFH hyperspace. A higher value will result in heavier computation but potentially more precise. As parameter of the FastGlobalRegistrationOption options. + 2f924938-5607-497c-95cf-4e9a0c12de5c + i_max_tuple_count + i_max_tuple_count + true + 0 + 1 + true + 0 + The maximum number of tuples to consider in the FPFH hyperspace. A higher value will result in heavier computation but potentially more precise. As parameter of the FastGlobalRegistrationOption options. + 48d01794-d3d8-4aef-990e-127168822244 + + + + + + 938 + 1 + 133 + 20 + + + 1006 + 11 + + + + + + + + false + The computed transformation. + a79008e5-2303-45de-be3e-f7c64e9e3b45 + o_x_form + o_x_form + false + 0 + 1 + true + 0 + The computed transformation. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 1101 + -139 + 54 + 160 + + + 1128 + -59 + + + + + + + + + + true + false + true + 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 + S + + + + + *.*.python + 3.* + + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 70e3f280-d48d-4a26-8373-0eb52cb51d20 + Button + Button + false + 0 + + + + + + 808 + -175 + 103 + 22 + + + + + + + + + + + + + + + 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 + + + + + \ No newline at end of file diff --git a/src/gh/examples/normal_estimation.ghx b/src/gh/examples/normal_estimation.ghx new file mode 100644 index 00000000..5424448c --- /dev/null +++ b/src/gh/examples/normal_estimation.ghx @@ -0,0 +1,790 @@ + + + + + + + + 0 + 2 + 2 + + + + + + + 1 + 0 + 8 + + + + + + d5e887b6-b770-4141-aafc-5d8da5356208 + Shaded + 1 + + 100;102;0;255 + + + 100;0;150;0 + + + + + + 638537389965512241 + + false + normal_estimation.ghx + + + + + 0 + + + + + + 179 + 45 + + 1.2750001 + + + + + 0 + + + + + + + 0 + + + + + not_found + F:\diffCheck\temp\test.py + not_found + F:\diffCheck\src\gh\components\DF_normal_segmentator\code.py + not_found + F:\diffCheck\src\gh\components\DF_cloud_normal_estimator\code.py + not_found + F:\diffCheck\src\gh\components\DF_normal_segmentator\code.py + F:\diffCheck\src\gh\components\DF_cloud_normal_estimator\code.py + not_found + not_found + F:\diffCheck\src\gh\components\DF_cloud_normal_estimator\code.py + not_found + F:\diffCheck\temp\test.py + not_found + + + + + IBOIS, EPFL + andrea.settimi@epfl.ch + Andrea Settimi + + + + + 2 + + + + + Robert McNeel & Associates + 00000000-0000-0000-0000-000000000000 + Grasshopper + 8.8.24170.13001 + + + + + RhinoCodePluginGH, Version=8.8.24170.13001, Culture=neutral, PublicKeyToken=552281e97c755530 + 8.8.24170.13001 + + 066d0a87-236f-4eae-a0f4-9e42f5327962 + RhinoCodePluginGH + + + + + + + + 4 + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + DFCloudNormalEstimator + + + + + Evaluate the normals of a point cloud. + true + 2 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABg2lDQ1BJQ0MgcHJvZmlsZQAAKM+VkUsoRFEcxn8znmlkYZQk3YXHhhKSpYZIURqjZrBw7x0z1NxrundkY6lslYXHxmthY83WwlYp5VGytrAiNtL1P3fUTGqUU6fz6zvn+zrnOxA8yJiWW94Nlp1zoqMRLZ6Y0aqeqaSFBjpo0k03OzE1EqPk+LgloNabLpXF/0ZtcsE1IaAJD5pZJyc8L9y/mssq3hEOm4t6UvhUuNORCwrfK93I84vitM9BlRl2YtEh4bCwli5io4jNRccS7hNuTVq25AfjeU4qXlNsZVbMn3uqF4YW7OkppctsZpQxJphEw2CFJTLk6JLVFsUlKvuREv4m3z8pLkNcS5jiGGYZC933o/7gd7duqrcnnxSKQMWT5721QdUWfG163ueh530dQdkjXNgF//IBDLyLvlnQWvehbh3OLguasQ3nG9D4kNUd3ZfKZAZTKXg9kW9KQP011Mzme/vZ5/gOYtLV+BXs7kF7WrLnSry7uri3P8/4/RH5BsVkcsjVm6zlAAAACXBIWXMAAAsSAAALEgHS3X78AAAAB3RJTUUH6AYeFSwYOfV0IAAAAhdJREFUSEvtk89rE1EQx9eLIFQM1D8gF+8i4tk/IfTmRSQhiTGb+JYm5ncIySU3wUNuQfAfiCfBKthbL5acPPsPCIVCC9rU8fudztssWxDU4KkDH3bevJnvvDe7G1zZfzEXyHVzN2sQFuPQQpuxRqORA1+BRPe/aRP4I9v+O4PAXYPisluZqzh9d/tMn+Clpa8N3bfAOfjBk1g4NhRRVE+bxE4t+Xxe3LNpci9rpWtjMvgMblpIDckZcJQolkqlEp+cRFGkJHKeWPnaIHxiz0NwD0lZ8BosrSjm6YMvMgjfq99sNqXb7cpkMknm8LafgFNxGkS3EKBoFj6TjoEWFAoFFfLrUfuNtF4MVHQ6vRgNm/BmPidBThu0Wq0SEEIxNhl2XmkShchwONQ95tDnWJxz6rNRsVhMi5NFgM776Y3o0UcJd/bUpwCfbNJut2U+n+vaH4Zx+ryFr0+wCMIwvPSF1Ot1FSuXyzKbzbRJ8hb0q9Wq5jBGuE7rgFyAqx74AItrtZoKoLF0Oh2Nj8fjeByEI+n3+xpnDWNeA/iXfPE1wbkD3gJNoGiv11M/fW1/Uor72KD6QZ7fin808lCF08YNMIL4uU/mCLzv4dfCEfo1P4hSqeTXS5P7vSHRgeQPduk9gaXLrFa7j9/59QJkTOLPjIWAP96R2179pO+uyaltb9YwkjNwAm5YaLMG4e+cO7HQlf2LBcEvb4BK/rPgY5UAAAAASUVORK5CYII= + + 3b02c38b-dde9-4637-a19f-60f12a996fad + true + false + true + DFCloudNormalEstimator + DFCNormEstim + 3 + + false + false + false + false + + + + + + 145 + 57 + 126 + 84 + + + 206 + 99 + + + + + + 4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 1 + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + The point cloud to evaluate. + db609572-19db-493f-bf66-1dfe1075320e + i_cloud + i_cloud + true + 0 + 1 + true + 2ebab33f-a47a-463d-a5e7-48b99a2c6370 + 1 + The point cloud to evaluate. + d73c9fb0-365d-458f-9fb5-f4141399311f + + + + + + 147 + 59 + 44 + 20 + + + 170.5 + 69 + + + + + + + + true + The knn search value (by default 100). + 47eff061-a4af-4168-b3c1-914b3fba72c0 + i_knn + i_knn + true + 0 + 1 + true + 0 + The knn search value (by default 100). + 48d01794-d3d8-4aef-990e-127168822244 + + + + + + 147 + 79 + 44 + 20 + + + 170.5 + 89 + + + + + + + + true + The radius search. If value is provided the search will be hybrid. + 1d1b852c-1088-4cf0-86f7-9c9a6b285890 + i_radius + i_radius + true + 0 + 1 + true + 0 + The radius search. If value is provided the search will be hybrid. + 48d01794-d3d8-4aef-990e-127168822244 + + + + + + 147 + 99 + 44 + 20 + + + 170.5 + 109 + + + + + + + + true + Switch between Open3d (true) or Cilantro (false) library. Default is Open3d. + 424f8ebc-232e-41fa-a00f-e0e6b055a928 + i_bool + i_bool + true + 0 + 1 + true + 0 + Switch between Open3d (true) or Cilantro (false) library. Default is Open3d. + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 147 + 119 + 44 + 20 + + + 170.5 + 129 + + + + + + + + false + The cloud with normals computed. + 6d0f144a-3df5-46ad-bb49-206c88ce9dc6 + o_cloud + o_cloud + false + 0 + 1 + true + 0 + The cloud with normals computed. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 221 + 59 + 48 + 80 + + + 245 + 99 + + + + + + + + + + true + false + true + IyEgcHl0aG9uMwoKaW1wb3J0IFN5c3RlbQoKaW1wb3J0IFJoaW5vCmltcG9ydCBSaGluby5HZW9tZXRyeSBhcyByZwpmcm9tIGdocHl0aG9ubGliLmNvbXBvbmVudGJhc2UgaW1wb3J0IGV4ZWN1dGluZ2NvbXBvbmVudCBhcyBjb21wb25lbnQKCmltcG9ydCBkaWZmQ2hlY2sKaW1wb3J0IGRpZmZDaGVjay5kZl9nZW9tZXRyaWVzCmZyb20gZGlmZkNoZWNrIGltcG9ydCBkZl9jdnRfYmluZGluZ3MKCmNsYXNzIERGQ2xvdWROb3JtYWxFc3RpbWF0b3IoY29tcG9uZW50KToKICAgIGRlZiBSdW5TY3JpcHQoc2VsZiwKICAgICAgICBpX2Nsb3VkIDogcmcuUG9pbnRDbG91ZCA9IE5vbmUsCiAgICAgICAgaV9rbm4gOiBpbnQgPSBOb25lLAogICAgICAgIGlfcmFkaXVzIDogZmxvYXQgPSBOb25lLAogICAgICAgIGlfc3dpdGNoX21vZGUgOiBib29sID0gVHJ1ZQogICAgKToKICAgICAgICAiIiIKICAgICAgICAgICAgRXZhbHVhYXRlIHRoZSBuIG9ybWFscyBvZiBhIHBvaW50IGNsb3VkLgoKICAgICAgICAgICAgOnBhcmFtIGlfY2xvdWQ6IFBvaW50IGNsb3VkIHRvIGV2YWx1YXRlIG5vcm1hbHMuCiAgICAgICAgICAgIDppX2tubjogTnVtYmVyIG9mIG5lYXJlc3QgbmVpZ2hib3JzIHRvIGNvbnNpZGVyLgogICAgICAgICAgICA6aV9yYWRpdXM6IFJhZGl1cyBvZiB0aGUgc2VhcmNoLgogICAgICAgICAgICA6aV9zd2l0Y2hfbW9kZTogU3dpdGNoIGJldHdlZW4gT3BlbjNkICh0cnVlKSBvciBDaWxhbnRybyAoZmFsc2UpIGxpYnJhcnkuCiAgICAgICAgIiIiCiAgICAgICAgb19jbG91ZCA9IHJnLlBvaW50Q2xvdWQoKQoKICAgICAgICBkZl9jbG91ZCA9IGRmX2N2dF9iaW5kaW5ncy5jdnRfcmhjbG91ZF8yX2RmY2xvdWQoaV9jbG91ZCkKCiAgICAgICAgaWYgaV9rbm4gaXMgTm9uZToKICAgICAgICAgICAgaV9rbm4gPSAxMDAKCiAgICAgICAgZGZfY2xvdWQuZXN0aW1hdGVfbm9ybWFscygKICAgICAgICAgICAgdXNlX2NpbGFudHJvX2V2YWx1YXRvcj1pX3N3aXRjaF9tb2RlLAogICAgICAgICAgICBrbm49aV9rbm4sCiAgICAgICAgICAgIHNlYXJjaF9yYWRpdXM9aV9yYWRpdXMKICAgICAgICAgICAgKQoKICAgICAgICBvX2Nsb3VkID0gZGZfY3Z0X2JpbmRpbmdzLmN2dF9kZmNsb3VkXzJfcmhjbG91ZChkZl9jbG91ZCkKCiAgICAgICAgcmV0dXJuIG9fY2xvdWQKCiMgaWYgX19uYW1lX18gPT0gIl9fbWFpbl9fIjoKIyAgICAgY29tcCA9IERGQ2xvdWROb3JtYWxFc3RpbWF0b3IoKQojICAgICBvX2Nsb3VkID0gY29tcC5SdW5TY3JpcHQoCiMgICAgICAgICBpX2Nsb3VkLAojICAgICAgICAgaV9rbm4sCiMgICAgICAgICBpX3JhZGl1cywKIyAgICAgICAgIGlfc3dpdGNoX21vZGUKIyAgICAgKQ== + S + + + + + *.*.python + 3.* + + + + + + + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + DFNormalSegmentator + + + + + Cluster a point cloud based on normals. + true + 2 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABg2lDQ1BJQ0MgcHJvZmlsZQAAKM+VkUsoRFEcxn8znmlkYZQk3YXHhhKSpYZIURqjZrBw7x0z1NxrundkY6lslYXHxmthY83WwlYp5VGytrAiNtL1P3fUTGqUU6fz6zvn+zrnOxA8yJiWW94Nlp1zoqMRLZ6Y0aqeqaSFBjpo0k03OzE1EqPk+LgloNabLpXF/0ZtcsE1IaAJD5pZJyc8L9y/mssq3hEOm4t6UvhUuNORCwrfK93I84vitM9BlRl2YtEh4bCwli5io4jNRccS7hNuTVq25AfjeU4qXlNsZVbMn3uqF4YW7OkppctsZpQxJphEw2CFJTLk6JLVFsUlKvuREv4m3z8pLkNcS5jiGGYZC933o/7gd7duqrcnnxSKQMWT5721QdUWfG163ueh530dQdkjXNgF//IBDLyLvlnQWvehbh3OLguasQ3nG9D4kNUd3ZfKZAZTKXg9kW9KQP011Mzme/vZ5/gOYtLV+BXs7kF7WrLnSry7uri3P8/4/RH5BsVkcsjVm6zlAAAACXBIWXMAAAsSAAALEgHS3X78AAAAB3RJTUUH6AYeFTMI6Rhq2gAAA1xJREFUSEvtlF1MW3UYxntrvMEZoxcuQTMSo6IYtyybQxpnszHYxqrOOZgUekpLaUtLOUOcROQj0FbHh7AxZFQcWnEfHWGsuIXUERISYyTGC69MvVNnSRkLmS7Mn+85nO3Kz8UbzZ7kzT9Nz/nlyfM+/2O6o/+2KiDPuWbFbPz891QOJcrdN1I1D1ynft0yDY8uZZqeXmg2/r49CTRPc6zBXfes4H3wF9RHrvJa7iJvrk/Tsuk7OvJnuozH/74McEoGx12/orn2Z1/TXHMoL4P3iS9o3vQ5oYIEPZYhjmzvyjZe/WsJPEvAGTlRBO4T187sZd21REKruG7dMk2nOUbvtj4GdoSJ7mqyGa//sQSaLdCozLzm3LVmBf9D16iXSF5dt0B3fpr2LV8SMX9K37aTfGwdYbCojZE9rxPbq6bOlAaSU5Vuv4FblQbVphS+FfDSTdf77pVF5uiL1F33FPxE2DzLcNEMY9ZJju4I8aG1g/5CDyf3BZk44OOC4mLK6WDcay/R4XaoUjSgTKVxBu9b0SNpzV2mc/0VwpvTtG1OESmYY7BwnC5LN32FzZx+uYNZd4ijxRVMlnu4WOXkfLVC3GfnE78SN70An2kx3BzNtev+6yhrZZGPLdG+IUPLxh858vz3HH5umtmKr+jf3sX7u9s4YT1E0tVCwlbHJVeAKZeDiRqFU7V2Pgo4+CDojJv2Gg3RRi4N3rU/43l4maYnr1D7eJqx4jTvbv2a4xJJdOcIA0URzpW9I6eP8bIGZtwNXKqVaGyljHvsjPkVRuuqGK530a/WlJgOwJyWt1a/gNTPm3OVyMZFDj51mbef/YaQOUG0OEG3JUzM2k38lXbmJJILlY3M+hu56JS8VZ8eSazOwUjQmXqvvjrZo3pW2yTdzpFLcza4eiNp3bBA+JnLdOYn6bWcE/CgXr+hnW8xUdbC0G43SUcD0/ZqPZLEG3WMlu655XpAdf/+p6Mxd9EsN7I5kv/DjZB5ksNbTzBQeEyv3/CuJmIvqZzZH2D0RRuJctutRWqRHFf2I67pUz3zBu7P1WMZ9MsiM5prrdtSv9RZqZ90e3WRHn2R8xJJUiLhmOqmV/XEOw7WZhmIf6bJcm/WtFIdPe9WMtLtjLiOjgarbg92R/83mUy/AboPW8n24gXuAAAAAElFTkSuQmCC + + 358a76ba-fe34-4290-8929-fe2a7f785dd7 + true + false + true + DFNormalSegmentator + DFCNorSeg + 3 + + false + false + false + false + + + + + + 312 + 87 + 232 + 124 + + + 469 + 149 + + + + + + 6 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 1 + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + The point cloud to reduce the size. + b60b87f2-928f-4827-ab8e-95a36b0f4976 + i_cloud + i_cloud + true + 0 + 1 + true + 6d0f144a-3df5-46ad-bb49-206c88ce9dc6 + 1 + The point cloud to reduce the size. + d73c9fb0-365d-458f-9fb5-f4141399311f + + + + + + 314 + 89 + 140 + 20 + + + 385.5 + 99 + + + + + + + + true + The normal threshold in degrees (under that it consider to the same cluster). + 39f29f39-49d8-4370-8a6e-83ad46da989e + i_normal_threshold_degree + i_normal_threshold_degree + true + 0 + 1 + true + 0 + The normal threshold in degrees (under that it consider to the same cluster). + 9d51e32e-c038-4352-9554-f4137ca91b9a + + + + + + 314 + 109 + 140 + 20 + + + 385.5 + 119 + + + + + + + + true + The smallest cluster allowed. + 5f5ce061-8713-4244-9efd-02b616c3c272 + i_min_cluster_size + i_min_cluster_size + true + 0 + 1 + true + 0 + The smallest cluster allowed. + 48d01794-d3d8-4aef-990e-127168822244 + + + + + + 314 + 129 + 140 + 20 + + + 385.5 + 139 + + + + + + + + true + If true use knn, otherwise radius search. + 479c3899-cdd2-4cf0-97de-afdcc79c0f96 + i_use_knn_neighborhood + i_use_knn_neighborhood + true + 0 + 1 + true + 0 + If true use knn, otherwise radius search. + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 314 + 149 + 140 + 20 + + + 385.5 + 159 + + + + + + + + true + The knn size. + 11f62761-5c39-4ea1-8ece-d0d8f19f0a54 + i_knn_neighborhood_size + i_knn_neighborhood_size + true + 0 + 1 + true + 0 + The knn size. + 48d01794-d3d8-4aef-990e-127168822244 + + + + + + 314 + 169 + 140 + 20 + + + 385.5 + 179 + + + + + + + + true + The size of the radius. + 6cd0038f-b2a9-4f81-b137-c6bfa172db6c + i_radius_neighborhood_size + i_radius_neighborhood_size + true + 0 + 1 + true + 0 + The size of the radius. + 9d51e32e-c038-4352-9554-f4137ca91b9a + + + + + + 314 + 189 + 140 + 20 + + + 385.5 + 199 + + + + + + + + false + The segmented clouds. + dc7440d0-d17d-45d5-80db-34cf22eb2113 + o_clusters + o_clusters + false + 0 + 1 + true + 0 + The segmented clouds. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 484 + 89 + 58 + 120 + + + 513 + 149 + + + + + + + + + + true + false + true + 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 + S + + + + + *.*.python + 3.* + + + + + + + + + + + 850b6368-ff26-48ce-9773-ac554ffbaeef + Point Cloud + + + + + Contains a collection of point clouds + 2ebab33f-a47a-463d-a5e7-48b99a2c6370 + Point Cloud + PCloud + false + 0 + + + + + + 47 + 58 + 50 + 24 + + + 72.454056 + 70.216644 + + + + + + 1 + + + + + 1 + {0} + + + + + + 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 + + 00000000-0000-0000-0000-000000000000 + + + + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + 6676bfbc-8d0e-406b-a16e-38e6c0a66e57 + Panel + + false + 0 + dc7440d0-d17d-45d5-80db-34cf22eb2113 + 1 + Double click to edit panel content… + + + + + + 577 + 99 + 160 + 100 + + 0 + 0 + 0 + + 577.3333 + 99.966675 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + + + + + + 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 + + + + + \ No newline at end of file diff --git a/tests/entry_test.cc b/tests/entry_test.cc new file mode 100644 index 00000000..e6dd32ce --- /dev/null +++ b/tests/entry_test.cc @@ -0,0 +1,17 @@ +#include + +// Function to test +int add(int a, int b) { + return a + b; +} + +// Test case +TEST(AddTest, HandlesPositiveInput) { + EXPECT_EQ(6, add(2, 4)); +} + +// Main function +int main(int argc, char **argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} \ No newline at end of file diff --git a/tests/unit_tests/DFPointCloudTest.cc b/tests/unit_tests/DFPointCloudTest.cc new file mode 100644 index 00000000..8e552928 --- /dev/null +++ b/tests/unit_tests/DFPointCloudTest.cc @@ -0,0 +1,21 @@ +#include +#include "diffCheck.hh" + + +TEST(DFPointCloudTest, TestConstructor) { + std::vector points = {Eigen::Vector3d(1, 2, 3)}; + std::vector colors = {Eigen::Vector3d(255, 255, 255)}; + std::vector normals = {Eigen::Vector3d(0, 0, 1)}; + + diffCheck::geometry::DFPointCloud dfPointCloud(points, colors, normals); + + // Verify that the points, colors, and normals are set correctly + EXPECT_EQ(dfPointCloud.Points[0], points[0]); + EXPECT_EQ(dfPointCloud.Colors[0], colors[0]); + EXPECT_EQ(dfPointCloud.Normals[0], normals[0]); +} + +int main(int argc, char **argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} \ No newline at end of file